UI_PSF_radio.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_hiddenfeature.h"
#include "../AUDIO/audio.h"
#include "../TUNER/tuner.h"
#include "../MENU/tmplt.h"
#include "xim.h"
#include "ui.h"
#include "ui_assert.h"
#include "../HDD/hdd.h"


/*-- LOCAL DEFINITIONS ------------------------------------------------------*/
enum tuner_seek_dir
{
    TUNER_SEEK_UP,
    TUNER_SEEK_DOWN
};

static int seekctl;
#define _SEEK_START         0
#define _SEEK_CONTINUE      1
#define _SEEK_DONE          2
#define _seekcontinue() {   seekctl = _SEEK_CONTINUE;}
#define _seekdone(s)    {   seekctl = _SEEK_DONE; \
                            sysParam.station = TUNER_tune(TUNER_SET, s);\
                            CODEC_hpVolume(sysParam.volume);}

static void _updateRadioDisplay(USHORT, HMENU, int);
static void _seeksetup(int);
static int  _seektest(void);
static void _radioGUIon(BOOL, MSG_DATA);
static PARENT_STATE _ximAction(UINT);
static PARENT_STATE _stateEnd(void);

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

/*-- GLOBAL DATA ------------------------------------------------------------*/

/*-- FUNCTIONS --------------------------------------------------------------*/
#pragma CODE_SECTION(UI_PSF_radio, ".radio_code")
PARENT_STATE UI_PSF_radio( 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_FMTUNER);
                SYS_presetable();               
                if(!SYS_isRadioActive())
                {
                    SYS_radioActive();
                        
                    TUNER_control(ON);
                    TUNER_initFIR();
                    SYS_delayMicrosecond(300000);
                    AUDIO_initInterface(AM_FMRADIO, AF_PCM, 0, 0);
                    AUDIO_setInterface(AI_START);
                    TUNER_tune(TUNER_SET, sysParam.station);
                    CODEC_hpVolume(sysParam.volume);
                    SYS_audioNotPaused();
                    HDD_shutdown();
                }                                   
                _radioGUIon(TRUE, d2);
                return P_RADIO;
            }
            case SHIDDENFEATURE:
            {
                if(1 != d2) break;
                _stateEnd();
                SYS_HF_myfiTestEnable();
                sysParam.myfiChannel = 963;
                mMSG_send(sysMsgQ, SYS_MSG_ID, SSTART2PLAY, 0xA5A5, SYS_FOREVER);
                return P_NULL;
            }
            case SSTATE_END:
            {
                return _stateEnd();
            }
            case SGO2PRESET:
            {
                if(UI_presetType(d2) == PRESET_RADIO)
                {
                    int station = UI_presetStation(d2);
                    if(sysParam.station != station)
                    {
                        sysParam.station = station;                 
                        TUNER_tune(TUNER_SET, station);
                    }
                    _radioGUIon(TRUE, d2);
                }
                else 
                {
                    _radioGUIon(FALSE, d2);
                    AUDIO_setInterface(AI_SHUTDOWN);
                    return P_PLAY;
                }
                return P_RADIO;
            }
            case SSTARTRADIO:
            case SRESUMEPLAY:
            case SENDOFMENU:
            {
                _radioGUIon(TRUE, curPresetIdx);
                return P_RADIO;         
            }
            case SPRESET:
            {
                UI_presetRadio(d2, sysParam.station);
                _updateRadioDisplay(sysParam.station, menu, d2);
                return P_RADIO;
            }
            case SSTART2RECORD: 
            case SSTART2HISI:
            {
                SYS_deleteDiskDbTask(SYS_FOREVER);
// Bugzilla #157 Pt. 2b
                if(SYS_isAudioPaused())
                {
                    SYS_toggleAudioPaused();                
                    mMENU_update(menu, 7, (ULONG)text_null, FALSE);
                    CODEC_hpVolume(sysParam.volume);
                }
                mMENU_refresh(menu);
                _radioGUIon(FALSE, DONTCARE);
                return((SSTART2RECORD == d1)? P_RECORD:P_HISI);
            }
            case SXIM_EXIT: 
            {
                return(_ximAction(d2));
            }
        }   
        break;

    case KBD_MSG_ID:
        switch(d1)
        {
            case KEY_HSELECT:
                sysParam.station = TUNER_tune(TUNER_SET, TUN_MAX_REAL_FREQ);
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                return P_RADIO;
            case KEY_HBACK:
                sysParam.station = TUNER_tune(TUNER_SET, TUN_MIN_REAL_FREQ);
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                return P_RADIO;
            case KEY_BACK:
                // Auto resume play window.
                SYS_autoResumePlayEnable();
                _radioGUIon(FALSE, DONTCARE);
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, SBROWSE, DONTCARE, SYS_FOREVER);
                return P_RADIO;
            
            case KEY_HREWIND:
            case KEY_RREWIND:
                sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station);
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                return P_RADIO;
                
            case KEY_REWIND:
                _seeksetup(TUNER_SEEK_DOWN);
                return P_RADIO;
                
            case KEY_FORWARD:  
                _seeksetup(TUNER_SEEK_UP);
                return P_RADIO;
                
            case KEY_HFORWARD:
            case KEY_RFORWARD:
                sysParam.station = TUNER_tune(TUNER_INC, sysParam.station);
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                return P_RADIO; 
                
            case KEY_PLAY:
                SYS_toggleAudioPaused();                
                if(SYS_isAudioPaused())
                {
                    mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE);
                    CODEC_hpVolume(0);  
                }
                else
                {
                    mMENU_update(menu, 7, (ULONG)text_null, FALSE); 
                    CODEC_hpVolume(sysParam.volume);
                }
                mMENU_refresh(menu);
                return P_RADIO;
                
            case KEY_UP:
            case KEY_HUP:
            case KEY_DOWN:
            case KEY_HDOWN:
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, SVOLWIN_CREATE, DONTCARE, SYS_FOREVER);
                return P_RADIO;
                
            case KEY_SELECT:
                SYS_autoResumePlayEnable();
                mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_RADIO, SYS_FOREVER);
                return P_RADIO;
        }
        break;
    
    case TMR_MSG_ID:
        switch(d1)
        {
            case TFRWD_DOUBLECLICK:
                if(TUNER_SEEK_DOWN == d2)   
                    sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station);
                else                        
                    sysParam.station = TUNER_tune(TUNER_INC, sysParam.station);
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                break;
            
            case TTUNERSEEK:
                if( _SEEK_DONE != _seektest())
                {
                    unsigned int oldStation;
                    oldStation = sysParam.station;
                    if(TUNER_SEEK_DOWN == d2)   
                    {
                        sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station);
                        if(oldStation < sysParam.station) {_seekdone(oldStation);}
                        else _seekcontinue();
                    }
                    else
                    {                       
                        sysParam.station = TUNER_tune(TUNER_INC, sysParam.station);
                        if(oldStation > sysParam.station) {_seekdone(oldStation);}
                        else _seekcontinue();
                    }               
                }
                else 
                {
                    TMR_delete(TMR_TUNERSEEK);
// Bugzilla #157 Pt. 2a
                    if(SYS_isAudioPaused())
                    {
                        SYS_toggleAudioPaused();                
                        mMENU_update(menu, 7, (ULONG)text_null, FALSE);
                        CODEC_hpVolume(sysParam.volume);
                    }
                    mMENU_refresh(menu);
                }
                _updateRadioDisplay(sysParam.station, menu, DONTCARE);
                break;
        }   
        break;      
    }
    
    return P_RADIO;
}


#pragma CODE_SECTION (_updateRadioDisplay, ".radio_code")
// Function updates radio MENU with station display and a preset if available.
// 
// station: FM channel in 100KHz.
// menu:    radio MENU handle.
// presetIdx: preset index if not DONTCARE.
static void _updateRadioDisplay(USHORT station, HMENU menu, int presetIdx)
{
    ULONG           dptr;
    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);    
    
    if( (presetIdx < 1)||(presetIdx > 5) )
    {
        presetIdx = UI_isPresetStation(station);
    }
    // Update preset display.
    if( ((presetIdx >= 1)&&(presetIdx <= 5))&&
        (station == UI_presetStation(presetIdx)) )
    {
        curPresetIdx = presetIdx;
        // Valid preset station, display preset icon. 
        mMENU_update(menu, 5, (ULONG)graf_icon_preset, FALSE);  

        // Update preset text display.
        switch(presetIdx)
        {       
            case 1: dptr = (long)text_preset01; break;
            case 2: dptr = (long)text_preset02; break;
            case 3: dptr = (long)text_preset03; break;
            case 4: dptr = (long)text_preset04; break;
            case 5: dptr = (long)text_preset05; break;
        }
        mMENU_update(menu, 6, dptr, TRUE);  
    }
    else 
    {
        // Clear preset display.
        mMENU_update(menu, 5, (ULONG)graf_icon_null, FALSE);    
    }   
    mMENU_refresh(menu);
}


#pragma CODE_SECTION (_seeksetup, ".radio_code")
// Function sets up the tuner seeking timers.
static void _seeksetup(int direction)
{
    if(TRUE == TMR_isActive(TMR_FRWD_DOUBLECLICK))
    {
        // Double click detected.
        TMR_delete(TMR_FRWD_DOUBLECLICK);
        TMR_create(TMR_TUNERSEEK, 20, TTUNERSEEK, direction, AUTO_RELOAD);
        if (sysParam.x_automute == XTRA_ON)
        {
            CODEC_hpVolume(0);
        }
        seekctl = _SEEK_START;
    }
    else
    {               
        TMR_create( TMR_FRWD_DOUBLECLICK, 20, TFRWD_DOUBLECLICK, direction, NO_RELOAD );
        TMR_delete(TMR_TUNERSEEK);
    }
}


#pragma CODE_SECTION (_seektest, ".radio_code")
// Function tests to see if channel is locked.
static int _seektest(void)
{
    int status;
    if(_SEEK_CONTINUE != seekctl) return seekctl;
    
    status = TUNER__spiReadStatus();
    if(!(status & TUNER_STATUS_VALID))  SYS_die(UI_PSF_RADIO);
    if (status & TUNER_STATUS_LOCKED)   seekctl = _SEEK_DONE; 
    else seekctl = _SEEK_CONTINUE;
    
    return seekctl;
}

#pragma CODE_SECTION (_radioGUIon, ".radio_code")
// Function controls the radio GUI.
static void _radioGUIon(BOOL on, MSG_DATA d2)
{
    if(FALSE == on)
    {
        mMENU_action(menu, MENU_CLOSE); 
        TMR_delete(TMR_FRWD_DOUBLECLICK);
        TMR_delete(TMR_TUNERSEEK);          
    }
    else
    {
        SYS_autoResumePlayDisable();
        if(MENU_isValid(menu) == FALSE )
        {
            MENU_buf[0] = DP_RADIO;
            menu = mMENU_create((void*)&MENU_buf[0]);
        }
        if(SYS_isAudioPaused())     
        {
            SYS_autoffEnable();
            mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE);
        }
        else        
        {
            SYS_autoffDisable();
            mMENU_update(menu, 7, (ULONG)text_null, FALSE);
        }   
        _updateRadioDisplay(sysParam.station, menu, d2);
        mMENU_refresh(menu);
    }
}


#pragma CODE_SECTION(_ximAction, ".radio_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 ) 
        {
        case XIM_DEV_EQ:
            UI_menuBrowse(DONTCARE, DONTCARE, MENU_EQ);
            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_RADIO;
}

#pragma CODE_SECTION(_stateEnd, ".radio_code")
// Function completely stops the radio.
static PARENT_STATE _stateEnd(void)
{
    SYS_autoResumePlayDisable();
    _radioGUIon(FALSE, DONTCARE);
    UI_presetRadio(0, sysParam.station);
    AUDIO_setInterface(AI_SHUTDOWN);
    return P_NULL;
}

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

---