UI_PSF_play.c

Go to the documentation of this file.

/*****************************************************************************
                           C   M O D U L E   F I L E

    Copyright (c) 2003 Neuros Audio LLC, All rights reserved.

******************************************************************************/

/*-- HEADER FILE INCLUDES ---------------------------------------------------*/
#include "../SYSTEM/sys_main.h"
#include "../SYSTEM/sys_clock.h"
#include "../SYSTEM/sys_param.h"
#include "../SYSTEM/sys_hardware.h"
#include "../SYSTEM/sys_hiddenfeature.h"
#include "../AUDIO/audio.h"
#include "../DECODER/decoder.h"
#include "../ear/ear.h"
#include "../FMXMIT/xmit_inc.h"         
#include "ui.h"
#include "ui_assert.h"
#include "xim.h"
#include "playQ.h"
#include "m3u.h"

/*-- LOCAL DEFINITIONS ------------------------------------------------------*/
static PARENT_STATE _startPlay(MSG_DATA, BOOL);
static BOOL _setupPlay(ULONG, st_PLAYQ *);
static void _stopPlay(void);
static void _setupPlayMenu(st_PLAYQ *);
static void _updatePlayTime(void);
static PARENT_STATE _prevNextMusic(int);
static void _displayMyfiChannel(void);
static PARENT_STATE _ximAction(UINT);
static PARENT_STATE _stateEnd(void);
static void _add2mymix(void);
static BOOL _playFromMymix(void);

static void _linkitGUIon(BOOL);
static void _updateLinkitDisplay(USHORT, HMENU);

static void _abInit(void);
static void _abReset(ULONG);
static void _abCheck(void);

#define F_PLAY_FROMDB       0x0001
#define F_PLAY_PAUSED       0x0002

#define PLAY_isFromDb()     (playFlag &   F_PLAY_FROMDB)
#define PLAY_fromDb()       {playFlag |=  F_PLAY_FROMDB;}
#define PLAY_notFromDb()    {playFlag &= ~F_PLAY_FROMDB;}

#define PLAY_wasPaused()        (playFlag &   F_PLAY_PAUSED)
#define PLAY_setPaused()        {playFlag |=  F_PLAY_PAUSED;}
#define PLAY_unsetPaused()  {playFlag &= ~F_PLAY_PAUSED;}

/*-- STATIC DATA ------------------------------------------------------------*/
static HMENU            menu = INVALID_MENU_HDL;
static int              playFlag;

/*-- GLOBAL DATA ------------------------------------------------------------*/
PLAY_SRC                playSource;

/*-- FUNCTIONS --------------------------------------------------------------*/
#pragma CODE_SECTION(UI_PSF_play, ".play_code")
PARENT_STATE UI_PSF_play( st_MSG * msgIN )
{   
    MSG_ID          id = msgIN->id;     
    MSG_DATA        d1 = msgIN->d1; 
    MSG_DATA        d2 = msgIN->d2;
    
    switch(id)
    {
    case SYS_MSG_ID:
        
        switch(d1)
        {
            case SSTATE_START:
            {
                SYS_clockSetup(CLOCK_PLAY);
                if(SYS_HF_linkit())
                {
                    AUDIO_initInterface(AM_ILINK, AF_ILINK, 0, 0);
                    AUDIO_setInterface(AI_START);
                    SYS_audioNotPaused();
                    _linkitGUIon(TRUE);
                    return P_PLAY;
                }
                
                #ifdef DJ_SUPPORT
                _abInit();
                #endif
                return _startPlay(d2, TRUE);
            }
            case SSTATE_END:
            {
                if(SYS_HF_linkit())
                {
                    _stopPlay();
                    return P_NULL;
                }
                return(_stateEnd());
            }
            case SSTARTRADIO: 
                _stopPlay();
                return P_RADIO;
                
            case SRESUMEPLAY:
            case SENDOFMENU:
            {
                if(MENU_isValid(menu) == FALSE )
                {
                    _setupPlayMenu(UI_playQcurrent());
                    menu = mMENU_create((void*)&MENU_buf[0]);
                    _displayMyfiChannel();
                    if(SYS_isAudioPaused()) 
                    {
                        mMENU_update(menu, 5, (ULONG)graf_icon_pause, FALSE);
                    }
                    else                    
                    {
                        mMENU_update(menu, 5, (ULONG)graf_icon_play, FALSE);
                    }
                    _updatePlayTime();
                }
                return P_PLAY;          
            }
            case SPRESET:
            {
                if(SYS_isPresetable())
                {
                    ULONG fptr;
//DeepB
// Bugzilla #213
// Only get file pointer while paused
                    if (SYS_isAudioPaused())
                        fptr = AUDIO_getFilePtr();
                    else
                        fptr = 0;
                    UI_presetAudio(d2, UI_presetDbId(0),
                                    UI_playQcurrent()->actvTrack, 
                                    UI_presetFldEntry(0),
                                    UI_presetFldIdx(0), 
                                    fptr);
                    switch(UI_presetFldIdx(0))
                    {
                        case 1:  UI_msgbxCreate(MSGBX_PLAYLIST_PRESETDONE); break;
                        case 2:  UI_msgbxCreate(MSGBX_ARTIST_PRESETDONE);   break;
                        case 3:  UI_msgbxCreate(MSGBX_ALBUM_PRESETDONE);    break;
                        case 4:  UI_msgbxCreate(MSGBX_GENRE_PRESETDONE);    break;
                        case 5:  UI_msgbxCreate(MSGBX_RECORDING_PRESETDONE);break;
                        default: UI_msgbxCreate(MSGBX_SONGS_PRESETDONE);    break;
                    }
                }
                return P_PLAY;
            }
            case SAUDIOTIME_UPDT:
            {
                #ifdef DJ_SUPPORT
                _abCheck();
                #endif
                _updatePlayTime();
                return P_PLAY;
            }
            case SENDOFMUSIC:
            {
                #ifdef DJ_SUPPORT
                if( (Ui.abMode)&&(2 == Ui.abStart) ) return _prevNextMusic(0);
                #endif
                DECODER_cacheDepthReset(1);
                return _prevNextMusic(1);
            }
            case SPLAYQCHANGED: 
            {
                #ifdef M3U_SUPPORT
                if( UI_getPlaySource() != PLAY_FROM_PLAYQ )
                {
                    st_PLAYQ * q = UI_playQcurrent();
                    
                    UI_presetAudio(0, 0x1234, 1, DONTCARE, DONTCARE, 0);
                            
                    DB_LOCK(SYS_FOREVER);
                    UI_m3uPut(0, q->fname, q->artist, q->title, q->album, q->genre, q->duration, q->size);
                    *UI_m3uActvItemPtr(0) = 2;
                    UI_m3uChgOrder(0, 0);
                    DB_UNLOCK();
                    UI_playQreset(0x1234);
                    return P_PLAY;
                }
                #endif
            }
            case SMYMIXCHANGED:
            {
                if(FALSE == UI_playQreset(d2))
                {
                    // No playable contents.
                    _stopPlay();
                    UI_msgbxCreate(MSGBX_CONTENTSNA);
                    return P_NULL;
                }
                return P_PLAY;
            }
            case SSHUFFLECHANGED:
            {
                UI_playQreset(DONTCARE);
                return P_PLAY;
            }
            case SMIFIQUALITYCHANGED:
            {
                AUDIO_resetMyfiQuality();
                return P_PLAY;
            }
            case SMIFIMODECHANGED:
            {
                // Check new myfi mode.
                if( ((sysParam.myfiMode == 1) // off.
                    &&(AUDIO_isMyfiActive())) ||
//DeepB
                    ((sysParam.myfiMode == 2) // on
                    && (!AUDIO_isMyfiActive())) ||
//Auto detectar
                    ((sysParam.myfiMode == 3) // auto-detect.
                    &&((AUDIO_isMyfiActive()) == (SYS_isHPpresent()))) )
                {
                    // Restart.
                    UI_presetAudio(0, UI_presetDbId(0),
                            UI_playQcurrent()->actvTrack, 
                            UI_presetFldEntry(0),
                            UI_presetFldIdx(0), 
                            AUDIO_getFilePtr());
                    _stopPlay();
                    return _startPlay(0, FALSE);
                }
                break;
            }
            case SMYFICHANNELCHANGED:
            {
                _displayMyfiChannel();
                return P_PLAY;
            }
            case SXIM_EXIT: 
            {
                return(_ximAction(d2));
            }
            case SMSGBOX_EXIT:
            {
                if(MENU_curMsgbx() == MSGBX_CONTENTSNA)
                {
                    return P_NULL;
                }
                else if(MENU_curMsgbx() == MSGBX_REMOVEQRECORD)
                {
                    if(BTN_YES == d2)
                    {
                        _stateEnd();
                        UI_m3uRemove(0, UI_playQcurrent()->actvTrack);
                        // Start next track from the very beginning.
                        nandSysParam.preset[0].share.audio.fptr = 0L;
                        return _startPlay(0, TRUE);                                     
                    }
                    else return P_PLAY;
                }
                else if(MENU_curMsgbx() == MSGBX_DELETERECORD)
                {
                    D2PEAR_ID   earID;
                    st_PLAYQ *  q = UI_playQcurrent();
                    
                    if( BTN_CANCEL == d2 ) return P_PLAY;
                    
                    if( (BTN_NEUROS == d2)||(BTN_PCDELETE == d2) )
                    {
                        _stateEnd();
                        FAT_delete(q->fname);
                        switch(UI_getPlaySource())
                        {
                            case PLAY_FROM_IDEDHISI:
                                DB_deleteRecordByMdb(DBnav.idedhisi, q->mdb);
                                break;
                            case PLAY_FROM_FAILEDHISI:
                                DB_deleteRecordByMdb(DBnav.failedhisi, q->mdb);
                                break;
                            case PLAY_FROM_AUDIODB:
                                DB_deleteRecordByMdb(DBnav.audio, q->mdb);
                                UI_audioPresetUpdate(-1);
                                break;
                            default: SYS_die(UI_PSF_PLAY);
                        }     
                    }
                    
                    earID = (BTN_NEUROS == d2)? DELETE_NEUROS_AUDIO: DELETE_PC_AUDIO;
                    
                    if(SYS_isHDDpresent())
                    {
                        UI_earPut(strDISKC, earID,(PEAR_DATA)q->fname,strlen(q->fname)+1, 0);
                        SYS_NAND_DBMOD_2HDD_PENDING();
                    }
                    else
                    {
                        UI_earPut(strDISKD, earID,(PEAR_DATA)q->fname,strlen(q->fname)+1, 0);
                        SYS_NAND_CONTENTS_CHANGED();
                    }   
                    // Start next track from the very beginning.
                    nandSysParam.preset[0].share.audio.fptr = 0L;
                    return _startPlay(0, TRUE);                                     
                }
                else if(MENU_curMsgbx() == MSGBX_DELETERECORDFILE)
                {
                    if(BTN_YES == d2)
                    {
                        st_PLAYQ *  q = UI_playQcurrent();
                        _stateEnd();
                        FAT_delete(q->fname);
                        UI_updateMembar();
                        return P_NULL;
                    }
                }
                else if(MENU_curMsgbx() == MSGBX_DELETEHISICLIP)
                {
                    if(BTN_YES == d2)
                    {
                        st_PLAYQ *  q = UI_playQcurrent();
                        
                        _stateEnd();
                        FAT_delete(q->fname);
                        if(UI_getPlaySource() == PLAY_FROM_UNIDEDHISI)
                        {
                            DB_deleteRecordByMdb(DBnav.unidedhisi, q->mdb);
                            UI_earPut(SYS_isHDDpresent()? strDISKC:strDISKD,
                                        HISI_DELETE_UNIDED_CLIP,(PEAR_DATA)q->fname, strlen(q->fname)+1, 0);
                            
                            if(SYS_isHDDpresent())
                            {
                                SYS_NAND_DBMOD_2HDD_PENDING();
                            }
                            else
                            {
                                SYS_NAND_CONTENTS_CHANGED();
                            }
                        }
                        return P_NULL;
                    }
                }
                return P_PLAY;
            }
            case SCURRENTAUDIOFILE:
            {
                AUDIO_setCurrentTrack();
                return P_PLAY;
            }
            case SNEXTAUDIOFILE:
            {
                AUDIO_getCacheTrackFile(d2);
                return P_PLAY;
            }
        }   
        break;
    
    case TMR_MSG_ID:
        switch(d1)
        {
            case TTXTSCROLL: 
                mMENU_action(menu, MENU_TXTSCROLL);
                return P_PLAY;
        }
        break;
        
    case KBD_MSG_ID:
        switch(d1)
        {
            case KEY_BACK:
                if(SYS_HF_linkit())
                {
                    _stopPlay();
                    return P_NULL;
                }
                
                if(!PLAY_isFromDb())
                { 
                    _stopPlay();
                    return (SYS_wasFromHisi())? P_HISIDONE:P_RECORDDONE;
                }
                mMENU_action(menu, MENU_CLOSE);
                // Auto resume play window.
                SYS_autoResumePlayEnable();
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, SBROWSE, DONTCARE, SYS_FOREVER);
                return P_PLAY;
            
            case KEY_HREWIND:
                if(SYS_HF_myfiTest())
                {
                    //sysParam.myfiChannel = 911;
                    sysParam.myfiChannel = 875;
                    _updateLinkitDisplay(sysParam.myfiChannel, menu);
                    XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2);
                }
            case KEY_RREWIND:
                if(SYS_HF_linkit()) return P_PLAY;
                DECODER_frwd();
                return P_PLAY;
                
            case KEY_REWIND:    
                if(SYS_HF_linkit()) return P_PLAY;
                DECODER_cacheDepthReset(0);
                #ifdef DJ_SUPPORT
                if(Ui.abStart == 2)
                {
                    AUDIO_setFilePtr(Ui.aPtr);
                    return P_PLAY;
                }
                #endif
//DeepB
// To previous song
// if on first 5 seconds
// of non-paused song
                if((Audio.playtime < 5) && !(SYS_isAudioPaused())) return _prevNextMusic(-1);
                else return _prevNextMusic(0);          
                    
            case KEY_FORWARD:           
                if(SYS_HF_linkit()) return P_PLAY;
                DECODER_cacheDepthReset(0);
                #ifdef DJ_SUPPORT
                if(Ui.abStart == 2) 
                {
                    AUDIO_setFilePtr(Ui.aPtr);
                    return P_PLAY;
                }
                #endif
                return _prevNextMusic(1);
                
            case KEY_HFORWARD:
                if(SYS_HF_myfiTest())
                {
                    //sysParam.myfiChannel = 1049;
                    sysParam.myfiChannel = 1041;
                    _updateLinkitDisplay(sysParam.myfiChannel, menu);
                    XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2);
                }
            case KEY_RFORWARD:
                if(SYS_HF_linkit()) return P_PLAY;
                DECODER_ffwd();
                return P_PLAY;  
                
            case KEY_PLAY:
                
                SYS_toggleAudioPaused();
                if(SYS_isAudioPaused()) 
                {
                    PLAY_setPaused();
                    AUDIO_setInterface(AI_PAUSE);
                    if(SYS_HF_linkit()) 
                        mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE);
                    else
                        mMENU_update(menu, 5, (ULONG)graf_icon_pause, FALSE);
                }
                else
                {
                    PLAY_unsetPaused();
                    AUDIO_setInterface(AI_START);
                    AUDIO_setInterface(AI_UNMUTE);
                    if(SYS_HF_linkit()) 
                        mMENU_update(menu, 7, (ULONG)text_null, FALSE); 
                    else
                        mMENU_update(menu, 5, (ULONG)graf_icon_play, FALSE);
                }
                mMENU_refresh(menu);
                return P_PLAY;
                
            case KEY_HUP:
            case KEY_UP:
            case KEY_RUP:
                if(SYS_HF_linkit())
                {
                    if(sysParam.myfiChannel < MAX_CHANNEL) 
                    {
                        sysParam.myfiChannel+=sysParam.x_granularity;
                        _updateLinkitDisplay(sysParam.myfiChannel, menu);
                        XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2);
                    }
                    return P_PLAY;
                }
            case KEY_HDOWN:
            case KEY_DOWN:
            case KEY_RDOWN:
                if(SYS_HF_linkit())
                {
                    if(sysParam.myfiChannel > MIN_CHANNEL)
                    { 
                        sysParam.myfiChannel-=sysParam.x_granularity;
                        _updateLinkitDisplay(sysParam.myfiChannel, menu);
                        XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2);
                    }
                    return P_PLAY;
                }           
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, (AM_MYFI == Audio.mode)?
                            SMYFICHANNELWIN_CREATE:SVOLWIN_CREATE, DONTCARE, SYS_FOREVER);
                return P_PLAY;
                
            case KEY_SELECT:
            {
                int ximPtr;

                if(SYS_HF_linkit()) return P_PLAY;
                SYS_autoResumePlayEnable();
                
                if(PLAY_FROM_PLAYQ == UI_getPlaySource())
                {
                    ximPtr = (AM_MYFI == Audio.mode)? XIMWIN_PLAYER_MYFIQ:XIMWIN_PLAYERQ;
                }
                else
                {
                    ximPtr = (AM_MYFI == Audio.mode)? XIMWIN_PLAYER_MYFI:XIMWIN_PLAYER;
                    
                    if(PLAY_FROM_AUDIODB == UI_getPlaySource())                     
                    {
                        if(FALSE == _playFromMymix())
                        {
                            ximPtr = (AM_MYFI == Audio.mode)? 
                                XIMWIN_PLAYER_MYFI_ADD2MYMIX:XIMWIN_PLAYER_ADD2MYMIX;
                        }
                    }                   
                }
                
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, ximPtr, SYS_FOREVER);
                return P_PLAY;
            }
        }
        break;
    }
    
    return P_PLAY;
}


#pragma CODE_SECTION (_add2mymix, ".play_code")
static void _add2mymix(void)
{
    char mymix[8];
    int  pri;
    st_PLAYQ *  q = UI_playQcurrent();

    DB_LOCK(SYS_FOREVER);
    pri = SYS_SETPRI(SYS_BGDPRI);
    SYS_kbdDisabled();
    SYS_setBusy();
    
    GEN_readXdata((ULONG)mymixRecord, (USHORT*)mymix, 8);

    // Currently it is hard coded that playlist has to be second 
    // child of Audio DB. Ideally a string compare shall be done
    // to locate position of playlist key.
    
    // Query audio mdb if from play queue.
    if(PLAY_FROM_PLAYQ == UI_getPlaySource())
    {
        q->mdb = DB_getMdbByRecord(DBnav.audio, (const unsigned short *)q->title);
    }
    
    if(FALSE == DB_add2child(q->mdb, DB_childID(DBnav.audio, 1), (DB_DATA *)mymix))
    {
        //SYS_die(UI_SF_DBMENU_ADD2MYMIX);
    }
    else
    {           
        if(FALSE == UI_earPut(SYS_isHDDpresent()? strDISKC:strDISKD,
                ADD_NEUROS_AUDIO_2Q,(PEAR_DATA)q->fname, strlen((const char*)q->fname)+1, 0))
        {
            UI_msgbxCreate(MSGBX_DISKFULL);
        }
            
        UI_audioPresetUpdate(1);
    }
        
    DB_UNLOCK();
    SYS_clearBusy();
    SYS_SETPRI(pri);
        
//DeepB
// I hate those messages
//  UI_msgbxCreate(MSGBX_ADD2MYMIXDONE);
    
        
    if(SYS_isHDDpresent())
    { 
        SYS_NAND_DBMOD_2HDD_PENDING();
    }
    else
    {
        SYS_NAND_CONTENTS_CHANGED();
    }
    SYS_kbdEnabled();
}

#pragma CODE_SECTION (_playFromMymix, ".play_code")
static BOOL _playFromMymix( void )
{
    const char * mymix;

    if(UI_getPlayQGbl()->flag&F_PLAYQGBL_FROMPLAYLIST)
    {
        mymix = (const char *)UI_getPlayQGbl()->playlist;
        
        if(mymix[0] == ( ('!'<<8)|'M') )
        {
            if(mymix[1] == ( ('y'<<8)|' ') )
            {
                if(mymix[2] == ( ('M'<<8)|'i') )
                {   
                    if(mymix[3] == ( ('x'<<8)| 0) )
                    {
                        if(mymix[4] == 0) return TRUE;
                    }
                }
            }
        }
    }   
    return FALSE;
}

#pragma CODE_SECTION(_stateEnd, ".decoder_code")
// Function completely shuts down the play state.
static PARENT_STATE _stateEnd(void)
{
    // Always sets preset controls, which are used by the
    // play interface, in case play is resumed from 
    // delete operation etc.
    UI_presetAudio(0, UI_presetDbId(0),
                    UI_playQcurrent()->actvTrack, 
                    UI_presetFldEntry(0),
                    UI_presetFldIdx(0), 
                    AUDIO_getFilePtr());
    
    // Break the checksum if preset is not desirable.
    if( (!SYS_isPresetable())&&(PRESET_PLAYQ != UI_presetType(0)) )
    {
        SYS_breakPreset(0);
    }
    _stopPlay();
    if(!PLAY_isFromDb())
    {   
        return (SYS_wasFromHisi())? P_HISIDONE:P_RECORDDONE;
    }
    return P_NULL;
}

#pragma CODE_SECTION(_setupPlay, ".decoder_code")
// Function sets up the player to play.
static BOOL _setupPlay(ULONG offset, st_PLAYQ * playQ)
{
    AUDIO_MODE  mode;

    if(NULL == playQ) return FALSE;
    
//DeepB
    if(SYS_isMyFiOff()||((sysParam.myfiMode == 3)&&(SYS_isHPpresent())))    mode = AM_PLAY;
    else                                    mode = AM_MYFI;
    
    if(FALSE == AUDIO_initInterface(mode,
                        playQ->format, 
                        offset,
                        playQ->duration))
    {
        return FALSE;
    }                               
    AUDIO_setInterface(AI_START);
    #ifdef DJ_SUPPORT
    _abReset(Audio.file.size);
    #endif

    SYS_audioNotPaused();
    SYS_playActive();
    return TRUE;
}

#pragma CODE_SECTION(_stopPlay, ".decoder_code")
// Function stops the playback.
static void _stopPlay(void)
{
    SYS_autoResumePlayDisable();
    mMENU_action(menu, MENU_CLOSE); 
    AUDIO_setInterface(AI_SHUTDOWN);
    if(SYS_HF_linkit())
    {
        SYS_HF_linkitDisable();
        SYS_HF_myfiTestDisable();
    }
    else UI_playQshutdown();
    mMENU_statusBar(STBAR_SYSIDLE, NULL);
}

//#pragma CODE_SECTION(_startPlay, ".play_code")
#pragma CODE_SECTION(_startPlay, ".decoder_code")
// Function sets to start the playback.
static PARENT_STATE _startPlay(MSG_DATA d2, BOOL createMenu)
{
    ULONG           startFptr;
    st_PLAYQ *      playQ;
    
    SYS_notPresetable();
    PLAY_fromDb();
    
    DECODER_cacheDepthReset(0);
                
    // if d2 == DONTCARE, play from record or hisi.
    // else play from audio/hisi DB. 
    if(DONTCARE == d2)
    {
        playQ = UI_setupPlayQ( DB_INVALID_ID,0,0,0);                    
        startFptr= 0;
        PLAY_notFromDb();
    }
    else
    {   
        playQ = UI_setupPlayQ(  UI_presetDbId(d2),      // DB ID
                                UI_presetFldIdx(d2),    // DB fldIdx
                                UI_presetFldEntry(d2),  // DB fldEntry
                                UI_presetDbEntry(d2));  // DB entry.
        startFptr = UI_presetFptr(d2);
        if( PRESET_PLAYQ != UI_presetType(0) )
        {
            if(DB_rootID(UI_presetDbId(d2)) == DBnav.audio) 
            {
                SYS_presetable();
                if( NULL == playQ )
                {
                    SYS_breakPreset(d2);
                    if(0 == d2)
                    {
                        // Try play all before reporting error.
                        playQ = UI_setupPlayQ(DBnav.audio,-1,0,1);
                        startFptr = 0L;
                    }
                }
            }
        }
    }
                
    do
    {
        if(TRUE == _setupPlay(startFptr,playQ)) break;
        else
        {
            playQ = UI_playQnext();
            startFptr = 0;
        }
    }while(playQ);
                
    // Nothing playable?
    if(NULL == playQ) 
    {
        UI_msgbxCreate(MSGBX_CONTENTSNA);
        return P_PLAY;                  
    }
    
    if(TRUE == createMenu)
    {
        _setupPlayMenu(playQ);
        menu = mMENU_create((void*)&MENU_buf[0]);
        _displayMyfiChannel();
    }
                    
    if(SYS_isPresetable())
    {
        UI_presetAudio(0, UI_presetDbId(d2),
                        UI_presetDbEntry(d2), 
                        UI_presetFldEntry(d2),
                        UI_presetFldIdx(d2), 
                        Audio.fptr);
        SYS_breakPreset(0);
    }
                
    return P_PLAY;
}

#pragma CODE_SECTION(_prevNextMusic, ".decoder_code")
// Function checks to bring up previous/next track.
static PARENT_STATE _prevNextMusic(int prev)
{
    st_PLAYQ * playQ;
    ULONG      dptr = 0L;
    
    AUDIO_setInterface(AI_STOP);
    
    do
    {
        if(-1 == prev )     playQ = UI_playQprevious();
        else if( 1 == prev) playQ = UI_playQnext();
        else
        {
            #ifdef DJ_SUPPORT
            if( (2 == Ui.abStart)&&(Ui.abMode) ) dptr = Ui.aPtr;
            #endif
            playQ = UI_playQcurrent();
        }
        
        if(NULL == playQ) break;
        if(TRUE == _setupPlay(dptr, playQ)) break;
    } while(playQ);
    
    if(NULL == playQ)
    {
        PARENT_STATE ret = P_NULL;
        
        _stopPlay();
        if(!PLAY_isFromDb())
        {
            ret = SYS_wasFromHisi()? P_HISIDONE:P_RECORDDONE;   
        }       
        return ret;
    }
    
    if(MENU_isValid(menu) == TRUE )
    {
        mMENU_action(menu, MENU_CLOSE); 
        _setupPlayMenu(playQ);
        menu = mMENU_create((void*)&MENU_buf[0]);
        _displayMyfiChannel();
    }

    return P_PLAY;
}

#pragma CODE_SECTION(_setupPlayMenu, ".decoder_code")
// Function sets up player display.
static void _setupPlayMenu(st_PLAYQ * playQ)
{
    int * pD = (int *)&MENU_buf[0];

    *pD++ = DP_PLAYER;

    // pData structure.
    // 0,1:     artist display data pointer.
    // 2,3:     title display data pointer.
    // 4,5:     album display data pointer.
    // 6,7:     bps display data pointer.
    // 8,9:     genre/playlist display data pointer.
    // 10,11:   total time in seconds.
    // 12:      repeat control.
    // 13:      shuffle mode control.
    // 14:      media format.
    if ( (sysParam.x_layout == XTRA_TITLE_BOLD) )
    {
        *pD++ = 0;
        *pD++ = (int)playQ->title;
        
        *pD++ = 0;
        *pD++ = (int)playQ->artist;
    }
    else
    {
        *pD++ = 0;
        *pD++ = (int)playQ->artist;
        
        *pD++ = 0;
        *pD++ = (int)playQ->title;
    }
    *pD++ = 0;
    *pD++ = (int)playQ->album;

    *pD++ = 0;
    *pD++ = 0;

    *pD++ = 0;
    *pD++ = (UI_getPlayQGbl()->flag&F_PLAYQGBL_FROMPLAYLIST)?
            (int)UI_getPlayQGbl()->playlist:(int)playQ->genre;

    if(playQ->duration > 0)
    {
        *pD++ = (int)(playQ->duration>>16);
        *pD++ = (int)(playQ->duration&0x0ffff);
    }
    else
    {
        // default to 3:40.
        *pD++ = 0;
        *pD++ = 220;
    }
    
    *pD++ = sysParam.repeat;
    *pD++ = sysParam.shuffle;
    
    *pD++ = (int)playQ->format;
    #ifdef DJ_SUPPORT
    *pD++ = (int)Ui.abStart;
    #endif
    // Update myfi icon display.
    mMENU_statusBar(STBAR_SYSIDLE, NULL);
}

#pragma CODE_SECTION(_updatePlayTime, ".decoder_code")
// Function updates play time display.
static void _updatePlayTime(void)
{
    st_PLAYMENU *   pPlay;
    char            strTime[16];
    ULONG           curTime = SYS_getCurPlayTime();

    GEN_createTimeString(curTime, strTime);         
    mMENU_update(menu, 6, (ULONG)strTime, FALSE);
                
    // Reposition value bar.
    pPlay = (st_PLAYMENU*)mMENU_getObj(menu);
    if(pPlay) mMENU_vbarReposition(pPlay->vbar, curTime);
                
    mMENU_refresh(menu);
}

#pragma CODE_SECTION(_displayMyfiChannel, ".decoder_code")
// Function displays the active FM out channel.
static void _displayMyfiChannel(void)
{
    ULONG           dptr = (ULONG)text_null;
    char            strStation[15];
    char *          pC = &strStation[0];
    
    if(AM_MYFI == Audio.mode)
    {
        /* Station to string. */
        pC += GEN_int2ASCII(sysParam.myfiChannel, strStation, FALSE, 0);
        
        /* Insert '.' */
        *pC     = *(pC-1);
        *(pC-1) = '.';
        pC++;
        *pC++ = 'M';
        *pC++ = 'H';
        *pC++ = 'z';
        *pC   = 0;
        dptr  = (ULONG)strStation;
    }
    mMENU_update(menu, 9, dptr, FALSE);
    mMENU_refresh(menu);
}


#pragma CODE_SECTION(_ximAction, ".decoder_code")
// Function handles various DB XIMs.
static PARENT_STATE _ximAction(UINT ximID)
{
    XIM_ACTTYPE         actType;
    XIM_ACTID           actID;
    
    actType = (XIM_ACTTYPE)((ximID & 0xC000)>>14);          
    actID = (XIM_ACTID)(ximID & 0x3FFF);
    
    #ifdef DJ_SUPPORT
    SYS_autoResumePlayDisable();
    #endif
    
    switch( actType ) 
    {
    case XIM_ACT_DEV:   /* Device completed actions. */
        actID = (XIM_ACTID)(actID | XIM_DEV_IDMASK);
        switch( actID ) 
        {
        #ifdef DJ_SUPPORT
        case XIM_DEV_DJ:
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_DJ);
            break;
        #endif
        
        case XIM_DEV_SHUFFLE:
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_SHUFFLE);
            break;
            
        case XIM_DEV_FMOUT:
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_MYFI_MODE);
            break;
            
        case XIM_DEV_REPEAT:        
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_REPEAT);
            break;

        case XIM_DEV_EQ:
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_EQ);
            break;
            
        case XIM_DEV_MYFIGAIN:
            mMENU_action(menu, MENU_CLOSE); 
            UI_menuBrowse(SENDOFMENU, DONTCARE, MENU_MYFI_GAIN);
            break;
            
        case XIM_DEV_DELETE:
            switch(UI_getPlaySource())
            {
            case PLAY_FROM_RECORD_DONE:
                UI_msgbxCreate(MSGBX_DELETERECORDFILE);         
                break;
                
            case PLAY_FROM_HISI_DONE:           
            case PLAY_FROM_UNIDEDHISI:
                UI_msgbxCreate(MSGBX_DELETEHISICLIP);
                break;
            
            case PLAY_FROM_IDEDHISI:            
            case PLAY_FROM_FAILEDHISI:          
            case PLAY_FROM_AUDIODB:         
                UI_msgbxCreate(MSGBX_DELETERECORD);
                break;
            }
            break;
        
        case XIM_DEV_ADD2QUEUE:
            _add2mymix();
            break;
                
        case XIM_DEV_REMOVE:
            UI_msgbxCreate(MSGBX_REMOVEQRECORD);    
            break;
            
        case XIM_DEV_STOP_PLAY: 
            return(_stateEnd());
            
        default:
            #ifndef DJ_SUPPORT
            SYS_autoResumePlayDisable();
            #endif
            break;
        }
        break;
    }
    
    // All defaults to simply close XIM and do nothing.
    return P_PLAY;
}


#pragma CODE_SECTION (_linkitGUIon, ".decoder_code")
// Function controls the linkIt MyFi GUI.
static void _linkitGUIon(BOOL on)
{
    if(FALSE == on)
    {
        mMENU_action(menu, MENU_CLOSE); 
        TMR_delete(TMR_FRWD_DOUBLECLICK);
        TMR_delete(TMR_TUNERSEEK);          
    }
    else
    {
        if(MENU_isValid(menu) == FALSE )
        {
            MENU_buf[0] = DP_LINKIT;
            menu = mMENU_create((void*)&MENU_buf[0]);
        }
        if(SYS_isAudioPaused())     
        {
            mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE);
        }
        else        
        {
            mMENU_update(menu, 7, (ULONG)text_null, FALSE);
        }   

        _updateLinkitDisplay(sysParam.myfiChannel, menu);
        mMENU_refresh(menu);
    }
}

#pragma CODE_SECTION (_updateLinkitDisplay, ".decoder_code")
// Function updates linkIt MyFi display.
// 
// station: FM channel in 100KHz.
// menu:    menu handle.
static void _updateLinkitDisplay(USHORT station, HMENU menu)
{
    char            strStation[6];
    int             ii;

    ii = GEN_int2ASCII(station, strStation, FALSE, 0);
    
    // Insert '.'
    strStation[ii+1] = 0;
    strStation[ii] = strStation[ii-1];
    strStation[ii-1] = '.';
    
    mMENU_update(menu, 3, (ULONG)strStation, FALSE);    
    mMENU_refresh(menu);
}

#ifdef DJ_SUPPORT
#pragma CODE_SECTION (_abInit, ".decoder_code")
// Function initializes AB repeat controls.
static void _abInit(void)
{
    Ui.abMode = 0; // Disabled.
    Ui.abStart= 0; // Not started.
}

#pragma CODE_SECTION (_abReset, ".decoder_code")
// Function resets AB repeat controls upon track start.
static void _abReset(ULONG len)
{
    if(2 == Ui.abStart ) return;
    
    Ui.aPtr = 0;
    Ui.bPtr = 0;
    Ui.abPtr= 0;
    Ui.abStep = 0;
    Ui.abLen= len;
}

#pragma CODE_SECTION (_abCheck, ".decoder_code")
// Function checks to support AB repeat.
static void _abCheck(void)
{
    if(Ui.abStart == 2)
    {
        if(AUDIO_getFilePtr() >= Ui.bPtr)
        {
            AUDIO_setFilePtr(Ui.aPtr);
        }   
    }
}
#endif

/*****************************************************************************
                Neuros Audio LLC. Confidential Proprietary
 *****************************************************************************/

---