www.pudn.com > 6027_HD65.rar > combine.c
/**********************************************************************/
/*************** MTK CONFIDENTIAL & COPYRIGHTED ****************/
/*************** ****************/
/*************** $Modtime:: 04/08/03 4:17p $ ****************/
/*************** $Revision:: 42 $ ****************/
/*************** ****************/
/*************** Description : Key-Combine State ****************/
/*************** Machine ****************/
/*************** ****************/
/*************** Company : MediaTek Inc. ****************/
/*************** Programmer : Sung-Ching Lin ****************/
/**********************************************************************/
#define _COMBINE_C_
#pragma NOAREGS
#include "general.h"
#include "posi.h"
#include "../../custom/demo/fslist/flcomm.h"
#include "../../procdef.h"
#ifdef MT1379_MANUFACTURE_TEST
extern void vOsdShowTestInfo(BYTE bIndex) large;
extern void vCheckTestStatus(void) large;
extern BOOL fgCheckIfTested() large;
#ifdef RS232_LOG
extern void DRS232LogS(char *pcStr);
extern void DRS232LogB(BYTE bV1, BYTE bV2, BYTE bV3, BYTE bV4);
#endif
#endif
extern void vSetupMenuClose(void) large;
extern void vShowMenuAfterPause(void) large;
// *********************************************************************
// Static Function Prototype
// *********************************************************************
static void vShowDiscType(BYTE bDiscType) large;
/************************************************************************
Function : void vSetPlayType(BYTE bType)
Description : 8032 play type define, set play type dependant setting
Parameter : None
Return : None
************************************************************************/
void vSetPlayType(BYTE bType) large
{
#ifdef MT1379_MANUFACTURE_TEST
vWBDisable(WB_SELMENU);
if ((bType != SV_DVD_VIDEO))// && (bType != SV_DATA))
{
vOsdShowTestInfo(5);
_bPlayPostKey = IR_EJECT;
return;
}
/*
else
{
if (fgCheckIfTested())
{
_bPlayPostKey=IR_EJECT;
return;
}
}
*/
#endif
switch (bType)
{
case SV_DVD_VIDEO:
case SV_DVD_AUDIO:
case SV_MINI_DVD:
{
#ifdef DVD_DISC_ID_CHK
if (!fgIsDiscInitChecked())
{
return;
}
else
#endif
{
_bPlayType = PLAY_TYPE_DVD;
vSetKeyState(KEY_NONISO);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
vDVDInit(bType);
}
break;
}
case SV_SVCD:
case SV_CVD:
case SV_VCD3_0:
case SV_VCD2_0:
case SV_VCD1_1:
case SV_VCD6_0:
case SV_VCD6_1:
{
#ifdef VCD_SUPPORT
#ifdef VCD_DISC_ID_CHK
if (!fgIsDiscInitChecked())
{
return;
}
else
#endif
{
_bPlayType = PLAY_TYPE_VCD;
vSetKeyState(KEY_NONISO);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
vVCDInit(bType);
}
#else
_bPlayPostKey = IR_EJECT;
#endif /* #ifdef VCD_SUPPORT */
break;
}
#ifdef SUPPORT_DATA_DISC
case SV_DATA:
{
#ifdef ISO_DISC_ID_CHK
if (!fgIsDiscInitChecked())
{
return;
}
else
#endif
{
_bPlayType = PLAY_TYPE_ISO;
vSetKeyState(KEY_ISO);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
vISOInit(bType);
}
break;
}
#ifdef SUPPORT_PCD
case SV_PCD:
{
#ifdef PCD_DISC_ID_CHK
if (!fgIsDiscInitChecked())
{
return;
}
else
#endif
{
_bPlayType = PLAY_TYPE_PCD;
vSetKeyState(KEY_ISO);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
vPCDInit(bType);
}
break;
}
#endif /* SUPPORT_PCD */
#endif /* SUPPORT_DATA_DISC */
case SV_DTS_CS:
case SV_CDDA:
case SV_SACD:
case SV_CDG:
case SV_HDCD:
{
#ifdef CDDA_DISC_ID_CHK
if (!fgIsDiscInitChecked())
{
return;
}
else
#endif
{
#ifdef CDDA_USE_CDFS
_bPlayType = PLAY_TYPE_ISO;
vSetKeyState(KEY_ISO);
#else
_bPlayType = PLAY_TYPE_CDDA;
vSetKeyState(KEY_NONISO);
#endif
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
#ifdef CDDA_USE_CDFS
vISOInit(bType);
#else
vCDDAInit(bType);
#endif
}
break;
}
case SV_AUDIO_IN:
{
_bPlayType = PLAY_TYPE_AIN;
vSetKeyState(KEY_NONISO);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
vAINInit(bType);
break;
}
default:
{
vSetKeyState(KEY_INIT);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
_bPlayType = PLAY_TYPE_NONE;
break;
}
} /* switch (bType) */
vOsdDisplayChange(DISP_INIT, 0);
#ifdef DISC_IDENT_AUTO_MUTE_OFF
if (_bPlayType != PLAY_TYPE_NONE)
{
if (fgIsMute()) // if mute on
{
vAdspMute(ADSP_OFF, 0);
vOsdShowMute(OSD_MUTE_CLEAR);
}
}
#endif
vShowDiscType(bType);
}
/************************************************************************
Function : void vClearPlayType(void)
Description : Clear play type related setting
Parameter : None
Return : None
************************************************************************/
void vClearPlayType(void) large
{
if (fgIsDvdPlay())
{
vDVDExit();
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
vVCDExit();
}
#endif
#ifdef SUPPORT_DATA_DISC
else if (fgIsIsoPlay())
{
vISOExit();
}
#ifdef SUPPORT_PCD
else if (fgIsPcdPlay())
{
vPCDExit();
}
#endif
#endif /* SUPPORT_DATA_DISC */
#ifndef CDDA_USE_CDFS
else if (fgIsCddaPlay())
{
vCDDAExit();
}
#endif
#ifdef AUDIO_IN_EN
else if (fgIsAinPlay())
{
vAINExit();
}
#endif
_bPlayType = PLAY_TYPE_NONE;
vSetKeyState(KEY_INIT);
if ( fgIsInSetupMenu() )
{
vSetKeyState(KEY_SETUP);
}
}
#ifdef AUDIO_IN_EN
// *********************************************************************
// Function : void vPlayerFuncSwitch(BYTE bMode) large
// Description :
// Parameter : None
// Return : None
// *********************************************************************
void vPlayerFuncSwitch(BYTE bMode) large
{
if (_fgNotify == FALSE) // system init stage
{
if (bMode == PLAYER_FUNC_AIN)
{
_bPlayerFuncMode = PLAYER_FUNC_AIN;
}
else /* if (bMode == PLAYER_FUNC_DVD) */
{
_bPlayerFuncMode = PLAYER_FUNC_DVD;
}
}
else // system run stage
{
if (bMode == PLAYER_FUNC_AIN)
{
if (fgIsFuncAin() == FALSE)
{
vPlayerReset();
_bPlayerFuncMode = PLAYER_FUNC_AIN;
vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_OPEN, 0, 0);
_bUISrvStatus = PLAYER_SRV_STOP;
if (_bDiscLoadSt >= DISC_LOAD_STARTUP)
{
_fgSkipSrvStart = TRUE;
}
}
}
else /* if (bMode == PLAYER_FUNC_DVD) */
{
if (fgIsFuncDvd() == FALSE)
{
vPlayerReset();
_bPlayerFuncMode = PLAYER_FUNC_DVD;
vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_CLOSE, 0, 0);
}
}
}
}
#endif /* AUDIO_IN_EN */
// *********************************************************************
// Function : void vPlayerReset(void) large
// Description : called from playback
// Parameter : None
// Return : None
// *********************************************************************
void vPlayerReset(void) large
{
BYTE i;
/* check setup menu exist moved to WB reset */
// clear play type, call every play module exit function
vClearPlayType();
// reset player timer beep count
#if (defined(DVD_MENU_SHOW_VFD_WHEEL) || defined(JPEG_DECODING_SHOW_VFD_WHEEL))
_bPlayerTimerBeepCnt = PLAYER_TIMER_BEEP_PERIOD*2;
#else
_bPlayerTimerBeepCnt = PLAYER_TIMER_BEEP_PERIOD;
#endif
// reset display mode
vOsdShowWb(OSD_WB_RESET);
// reset zoom indicator flag
_rOsdStateCtx.fgZoomBrShow = FALSE;
// reset EQ state
_rEqState.bDispType = OSD_EQ_TYPE_DISABLE;
// reset input state
vResetInputState();
// for RISC communication states
_bLastSyncUop = UOP_NONE;
_bLastPbcState = SV_PBC_INIT;
// reset osd state
vOsdDisplayChange(DISP_INIT, 0);
// reset search state
_rSearchStateCtx.bType = SEARCH_NONE;
// reset program state
#ifdef PLAYER_PROGRAM
vSelMenuReset();
#endif
// this is play type dependant
#ifdef PLAYER_KARAOKE
if (bAdspCurrVocal() != VOCAL_NO_ASSIST)
{
vAdspVocalAssist(VOCAL_NO_ASSIST);
}
#ifdef KARAOKE_MIC_REC
vMicRecCtrl(MIC_REC_CTRL_RESET);
#endif
#else /* not define PLAYER_KARAOKE */
if (bAdspCurrVocal() != AUDIO_STEREO)
{
vAdspLR(AUDIO_STEREO);
}
#endif /* PLAYER_KARAOKE */
vAdspReset();
#if !defined(NO_SM_NOTIFY)
SmInit();
#endif
// for vocal assist
#ifdef PLAYER_KARAOKE
_fgVocalOn = FALSE;
#endif
#ifdef AUDIO_STREAM_CHANGE_MUTE
_fgAstChg = FALSE;
#endif
}
/************************************************************************
Function :
Description : This function must be moved to screen saver moudle
Parameter :
Return : = 0 -> screen saver not allowed
> 0 -> screen saver allowed
************************************************************************/
BOOL fgScrSaverCheck(void) large
{
BYTE bInitState = bSharedInfo(SI_INIT_STATE);
BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
switch (bInitState)
{
case SV_LOADING_DISC:
case SV_TRAY_CLOSING:
case SV_TRAY_ERROR:
return (FALSE); /* not allowed */
case SV_TRAY_OPENING:
case SV_NO_DISC:
case SV_UNKNOWN_DISC:
return (TRUE); /* allowed */
case SV_DISC_IDENTIFIED:
default:
break; /* not determined */
}
switch (bPbcState)
{
case SV_STOP:
case SV_STOP_RESUME:
case SV_PAUSE:
case SV_STEP:
case SV_STEP_BACK:
case SV_SETUP_PAUSE:
case SV_PTL_ERR:
case SV_REGION_ERR:
case SV_DISC_ERR:
case SV_SET_TMP_PTL:
return (TRUE); /* allowed */
case SV_PLAY:
case SV_FF:
case SV_SF:
case SV_FR:
case SV_SR:
case SV_FREEZE:
case SV_DIGEST9:
case SV_DIGEST4:
case SV_PBC_INIT:
return (FALSE); /* not allowed */
case SV_DIGEST:
case SV_STILL:
#ifdef SUPPORT_DATA_DISC
if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
|| fgIsPcdPlay()
#endif
)
{
//if (fgFsMenuIsDecoding() == FALSE)
if (fgFlCheckStatus(FL_STATUS_BUSY) == FALSE)
{
/* if not decoding, allowed */
return (TRUE);
}
else
{
/* if is decoding, not allowed */
return (FALSE);
}
}
else
{
/* DVD/VCD is not allowed in still mode */
return (FALSE);
}
break;
#endif /* SUPPORT_DATA_DISC */
default:
break; /* not determined */
}
return (FALSE); /* default is not allowed */
}
#ifdef PLAYER_STOP_SRV_STOP
/************************************************************************
Function :
Description :
Parameter :
Return : = 0 -> servo stop is not allowed
> 0 -> servo stop is allowed
************************************************************************/
BOOL fgSrvStopCheck(void) large
{
BYTE bInitState = bSharedInfo(SI_INIT_STATE);
BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
switch (bInitState)
{
case SV_LOADING_DISC:
case SV_TRAY_CLOSING:
case SV_TRAY_OPENING:
case SV_TRAY_ERROR:
case SV_NO_DISC:
return (FALSE); /* not allowed */
case SV_UNKNOWN_DISC:
return (TRUE); /* allowed */
case SV_DISC_IDENTIFIED:
default:
break; /* not determined */
}
#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
if (bPbcState == SV_STOP_RESUME)
{
bPbcState = SV_STOP;
}
#endif
if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
|| fgIsPcdPlay()
#endif
)
{
if (fgFlCheckStatus(FL_STATUS_BUSY) == FALSE)
{
/* if not decoding, allowed */
return (TRUE);
}
else
{
/* if is decoding, not allowed */
return (FALSE);
}
}
switch (bPbcState)
{
case SV_STOP:
if (_bLastSyncUop == UOP_STOP)
{
/* clear _bLastSyncUop flag immediately */
_bLastSyncUop = UOP_NONE;
/* change to stop state due to previous UOP command */
return (TRUE); /* allowed */
}
else if (fgIsUopUpdate() && (bSharedInfo(SI_UOP_RET_VAL) == SV_NO_ERROR))
{
/* any key changed to stop state */
return (TRUE); /* allowed */
}
else if (_bLastPbcState == SV_PBC_INIT)
{
return (TRUE);
}
else
{
return (FALSE); /* not allowed */
}
case SV_STOP_RESUME:
case SV_PAUSE:
case SV_STEP:
case SV_STEP_BACK:
case SV_PTL_ERR:
case SV_REGION_ERR:
case SV_DISC_ERR:
case SV_SET_TMP_PTL:
case SV_PLAY:
case SV_FF:
case SV_SF:
case SV_FR:
case SV_SR:
case SV_FREEZE:
case SV_DIGEST9:
case SV_DIGEST4:
case SV_DIGEST:
case SV_STILL:
/* DVD/VCD is not allowed in still mode */
return (FALSE);
default:
break; /* not determined */
}
return (FALSE); /* default is not allowed */
}
#endif /* PLAYER_STOP_SRV_STOP */
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vShowInitState(BYTE bInitState) large
{
BYTE bTmp;
BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
/* show or clear ICON/message first */
vOsdShowInitState(bInitState);
switch (bInitState)
{
case SV_LOADING_DISC:
#ifdef HDCD_EN
vSetSharedInfo(SI_FS_DISC_TYPE,0);//init
#endif
if (fgIsInSetupMenu())
{
vSetupMenuClose();
}
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vClearPlayType();
}
#endif /* AUDIO_IN_EN */
break;
case SV_TRAY_OPENING:
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vClearPlayType();
}
#endif /* AUDIO_IN_EN */
/* the vPlayerReset() has been moved to eject key routine */
//reset video when tray out
#ifdef RESET_VDO_TRAY_OUT
vResetVdoPage();
#endif
#ifdef EEPROM_LASTMEM_EJECT_WR_BACK
if (_rOsdStateCtx.fgLastMemWrBack == TRUE)
{
bTmp = bSharedInfo(SI_LASTMEM_NS);
if (bTmp > 0)
{
vSendPeriCmd(MISC_CMD_EEPROM_SVC, EEPROM_CMD_WR_SLOT, bTmp - 1);
}
_rOsdStateCtx.fgLastMemWrBack = FALSE;
}
#endif /* EEPROM_LASTMEM_EJECT_WR_BACK */
break;
case SV_TRAY_CLOSING:
vClearPlayType();
break;
case SV_TRAY_ERROR:
break;
case SV_NO_DISC:
#ifdef AUDIO_IN_EN
if (fgIsFuncAin())
{
vSetPlayType(SV_AUDIO_IN);
}
#endif /* AUDIO_IN_EN */
break;
case SV_UNKNOWN_DISC:
break;
case SV_DISC_IDENTIFIED:
#ifdef EN_DISC_ID_CHK
vSetDiscInitFlag(DISC_INIT_DISC_TYPE);
if (fgIsDiscInitFinished())
{
vSendPeriCmd(MISC_CMD_EEPROM_SVC, EEPROM_CMD_CHK_DISC_ID, 0);
}
#else
/* always assume RISC notify disc type first */
vSetPlayType(bDiscType);
#endif
break;
default:
break;
}
if (bInitState != SV_DISC_IDENTIFIED)
{
vAdspAudioTypeChange(bSharedInfo(SI_A_CODE_MODE), 0xff, bInitState);
}
#ifdef AUDIO_IN_EN
if (bInitState == SV_DISC_IDENTIFIED)
{
if (_bDiscLoadSt == DISC_LOAD_TOC)
{
_bDiscLoadSt = DISC_LOAD_IDENT;
}
}
else if ((bInitState == SV_DISC_IDENTIFIED) || (bInitState == SV_DISC_IDENTIFIED))
{
if (_bDiscLoadSt >= DISC_LOAD_STARTUP)
{
_bDiscLoadSt = DISC_LOAD_IDENT;
}
}
#endif /* AUDIO_IN_EN */
#ifdef PLAYER_STOP_SRV_STOP
if (bInitState == bSharedInfo(SI_INIT_STATE))
{
if (fgSrvStopCheck() == TRUE) /* for unknown disc */
{
_bUISrvStatus = PLAYER_SRV_STOP;
}
}
#endif /* PLAYER_STOP_SRV_STOP */
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vShowPbcState(BYTE bPbcState) large
{
BYTE bTmp;
WORD wFileNo;
switch (bPbcState)
{
case SV_STOP:
#ifdef PLAYER_FLMENU
// prevent showing stop icon while beginning to repeat
if (!fgIsIsoItemAV(bSharedInfo(SI_ISO_ITEM_TYPE)) && !fgFlCheckStatus(FL_STATUS_IN_JPEG))
#else
VfdShowStatus(VFD_STATUS_STOP);
if (!fgIsIsoItemAV(bSharedInfo(SI_ISO_ITEM_TYPE)))
#endif
{
vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
}
vOsdDisplayChange(DISP_STOP, 0);
break;
case SV_STOP_RESUME:
VfdShowStatus(VFD_STATUS_HOLD);
vOsdShowPbcState(SV_STOP_RESUME, 0, OSD_NO_DISAPPEAR);
vOsdDisplayChange(DISP_STOP_RESUME, 0);
break;
case SV_PLAY:
if(fgIsIsoPlay())
{
#if 0
// show file no in VFD
wFileNo = wIsoFileNo();
wFileNo = wWRDToBCD(wFileNo + 1); /* from 1 ~ Ns */
#ifdef VFD_FLD_CH100
vVfdWord(VFD_WORD_CH100, bHiByte(wFileNo), 0); /* note already in BCD */
#else
vVfdWord(VFD_WORD_TT, bHiByte(wFileNo), 0); /* note already in BCD */
#endif //VFD_FLD_CH100
vVfdWord(VFD_WORD_CH, bLoByte(wFileNo), 1);
#endif
}
vOsdShowPbcState(SV_PLAY, 0, OSD_NO_DISAPPEAR);
break;
case SV_FF:
case SV_SF:
case SV_FR:
case SV_SR:
vOsdDisplayChange(DISP_TRICK, bPbcState);
break;
case SV_PAUSE:
#ifdef SUPPORT_PCD
if (fgIsPcdPlay())
{
vOsdShowPbcState(SV_PAUSE, 0, OSD_TIMEOUT_SHORT);
}
else
#endif
{
if(!bSharedInfo(SH_PAUSE_SHOW_WB))
{
vOsdShowPbcState(SV_PAUSE, 0, OSD_NO_DISAPPEAR);
}
}
break;
case SV_STEP:
vOsdShowPbcState(SV_STEP, 0, OSD_NO_DISAPPEAR);
break;
case SV_STEP_BACK:
vOsdShowPbcState(SV_STEP_BACK, 0, OSD_NO_DISAPPEAR);
break;
case SV_FREEZE:
break;
case SV_STILL:
vOsdShowPbcState(SV_STILL, 0, OSD_NO_DISAPPEAR);
break;
#ifdef PLAYER_DIGEST
case SV_DIGEST9:
case SV_DIGEST4:
case SV_DIGEST:
if(fgIsIsoPlay()
#ifdef SUPPORT_PCD
|| fgIsPcdPlay()
#endif
)
{
VfdShowStatus(VFD_STATUS_DIGEST);
}
vOsdShowPbcState(bPbcState, 0, OSD_NO_DISAPPEAR);
break;
#endif
case SV_PTL_ERR:
case SV_SET_TMP_PTL:
/* clear status first */
/* vOsdPosClear(OSD_POS_PLAY_STATUS); */
/* call the password check function */
if (fgIsDvdPlay() && (fgIsInputStateValid(INPUT_STATE_PASSWORD) == FALSE))
{
fgSetPlayPostKey(IR_PASSWORD);
}
break;
case SV_REGION_ERR:
#ifndef EN_DISC_ID_CHK /* not define EN_DISC_ID_CHK */
if (fgIsDvdPlay())
{
vClearPlayType();
vOsdPosShow(OSD_POS_ERROR, OSD_MSG_WRONG_REGION, OSD_NO_DISAPPEAR);
vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
}
#endif /* not define EN_DISC_ID_CHK */
break;
case SV_DISC_ERR:
vOsdPosShow(OSD_POS_ERROR, OSD_MSG_DISC_ERROR, OSD_NO_DISAPPEAR);
vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
break;
default:
break;
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vChangePbcState(BYTE bPbcState) large
{
BYTE bTmp;
/* for state change only */
if (bPbcState == _bLastPbcState)
{
return;
}
switch (_bLastPbcState)
{
case SV_STOP:
case SV_STOP_RESUME:
#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
if ((_bLastPbcState == SV_STOP_RESUME) ||
(_bLastPbcState == SV_STOP))
{
vOsdPosClear(OSD_POS_STOP_MSG1);
vOsdPosClear(OSD_POS_STOP_MSG2);
}
#elif (STOP_RESUME_STYLE == STOP_RESUME_TWO_STOP)
if (_bLastPbcState == SV_STOP_RESUME)
{
vOsdPosClear(OSD_POS_STOP_MSG1);
}
#endif
break;
case SV_PLAY:
case SV_FF:
case SV_SF:
case SV_FR:
case SV_SR:
case SV_PAUSE:
case SV_STEP:
case SV_STEP_BACK:
case SV_FREEZE:
case SV_STILL:
/* fgIsDiscPlay() */
break;
case SV_DIGEST9:
case SV_DIGEST4:
case SV_DIGEST:
case SV_PTL_ERR:
case SV_REGION_ERR:
case SV_DISC_ERR:
case SV_SET_TMP_PTL:
break;
default:
/* error? */
break;
}
switch (bPbcState)
{
case SV_STOP:
case SV_STOP_RESUME:
vOsdCoreSetPlayStatus(OSD_SHOW_CLEAR, 0);
#ifdef STOP_CANCEL_USR_CTRL
if ((!fgIsIsoPlay()
#ifdef SUPPORT_PCD
&& !fgIsPcdPlay()
#endif
)
#ifdef SINGLE_STOP_KEEP_USR_CTRL
&& (bPbcState != SV_STOP_RESUME)
#endif
)
{
bTmp = bSharedInfo(SI_USR_PBC_CTRL);
if (bTmp == SV_PROGRAM)
{
if(bPbcState != SV_STOP_RESUME)
{
vSendUopCmd(UOP_PROGRAM, SV_PROGRAM_STOP, 0, 0);
}
}
else if (bTmp == SV_SHUFFLE)
{
vSendUopCmd(UOP_SHUFFLE, SV_OFF, 0, 0);
}
else if (bTmp == SV_RANDOM)
{
vSendUopCmd(UOP_RANDOM, SV_OFF, 0, 0);
}
}
#endif /* STOP_CANCEL_USR_CTRL */
#ifdef STOP_RESUME_CANCEL_REPEAT
if (!fgIsIsoPlay()
#ifdef SUPPORT_PCD
&& !fgIsPcdPlay()
#endif
)
{
bTmp = bSharedInfo(SI_REPEAT_MODE);
if ((bTmp != SV_REPEAT_NONE) &&
(bTmp != SV_REPEAT_ABNONE))
{
vSendUopCmd(UOP_REPEAT, SV_REPEAT_NONE, 0, 0);
}
}
#endif /* STOP_RESUME_CANCEL_REPEAT */
break;
case SV_PLAY:
case SV_FF:
case SV_SF:
case SV_FR:
case SV_SR:
case SV_PAUSE:
case SV_STEP:
case SV_STEP_BACK:
case SV_FREEZE:
case SV_STILL:
/* fgIsDiscPlay() */
if (!fgIsDiscPlay(_bLastPbcState) && (_bLastPbcState != SV_PBC_INIT))
{
vStatusDispRecall();
if (_bLastPbcState == SV_STOP)
{
/* if previous state is STOP, the time information may be incorrect! */
if (fgIsDvdPlay())
{
#ifndef NEW_SHOW
vDVDShowTotalTimeMark();
#else
vShowTotalTimeMark();
#endif
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
#ifndef NEW_SHOW
vVCDShowTotalTimeMark();
#else
vShowTotalTimeMark();
#endif
}
#endif
}
}
#ifdef CDDA_USE_CDFS
#ifdef CDG_SUPPORT
if(bSharedInfo(SI_CDG_DISC) == SV_ON)
{
vDisableWB(FSMENU_OSD_WBIDX_BASIC);
}
#endif
#endif
break;
case SV_DIGEST9:
case SV_DIGEST4:
case SV_DIGEST:
case SV_PTL_ERR:
case SV_REGION_ERR:
case SV_DISC_ERR:
case SV_SET_TMP_PTL:
break;
default:
/* error? */
break;
}
/* to update VFD */
VfdShowTrick(bPbcState);
#ifdef PLAYER_STOP_SRV_STOP
if (fgSrvStopCheck() == TRUE)
{
_bUISrvStatus = PLAYER_SRV_STOP;
}
#endif
_bLastPbcState = bPbcState;
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vShowUsrPbcCtrl(BYTE bMode) large
{
WORD wPos;
if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT;
}
else
{
wPos = OSD_POS_REPEAT;
}
}
else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT_LEFT;
}
else
{
wPos = OSD_POS_REPEAT_LEFT;
}
}
switch (bMode)
{
case SV_REPEAT_NONE:
case SV_REPEAT_ABNONE:
vOsdPosClear(wPos);
break;
case SV_REPEAT_ALL:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_ALL, OSD_NO_DISAPPEAR);
break;
case SV_REPEAT_TRACK:
case SV_REPEAT_LIST:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_TRK, OSD_NO_DISAPPEAR);
break;
case SV_REPEAT_TITLE:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_TT, OSD_NO_DISAPPEAR);
break;
case SV_REPEAT_CHAPTER:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_CH, OSD_NO_DISAPPEAR);
break;
case SV_REPEAT_SET_A:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_A, OSD_NO_DISAPPEAR);
break;
case SV_REPEAT_AB:
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_AB, OSD_NO_DISAPPEAR);
#ifdef KARAOKE_MIC_REC
vMicRecCtrl(MIC_REC_CTRL_INIT);
#endif
break;
case SV_RANDOM:
vOsdPosShow(wPos, OSD_MSG_RANDOM, OSD_NO_DISAPPEAR);
break;
case SV_SHUFFLE:
if (_rOsdStateCtx.fgRepeatShow == TRUE)
{
vOsdPosShow(wPos, OSD_MSG_SHUFFLE, OSD_NO_DISAPPEAR);
}
break;
case SV_PROGRAM:
vOsdPosShow(wPos, OSD_MSG_PROGRAM, OSD_NO_DISAPPEAR);
break;
#ifdef PLAYER_DIGEST
case SV_USR_DIGEST:
// show OSD
if (fgIsCddaPlay())
{
vOsdPosShow(wPos, OSD_MSG_SCAN, OSD_NO_DISAPPEAR);
}
else
{
#if 0
vOsdPosShow(wPos, OSD_MSG_DIGEST, OSD_NO_DISAPPEAR);
#else
vOsdPosClear(wPos);
#endif
}
// show VFD
if (fgIsDvdPlay())
{
#ifdef DVD_DGST_SHOW_MSG_ONLY
#ifdef VFD_STATUS_DIGEST
VfdShowStatus(VFD_STATUS_DIGEST);
#endif
#else
VfdShowPlayInfo(VFD_INFO_TITLE_CHAPTER, bSharedInfo(SI_TT_NO), bSharedInfo(SI_CHAP_NO));
#endif
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
#ifdef VCD_DGST_SHOW_MSG_ONLY
#ifdef VFD_STATUS_DIGEST
VfdShowStatus(VFD_STATUS_DIGEST);
#endif
#else
VfdShowPlayInfo(VFD_INFO_TRACK, 0, bSharedInfo(SI_TRACK_NO));
#endif //VCD_DGST_SHOW_MSG_ONLY
}
#endif
else if (fgIsIsoPlay() || fgIsCddaPlay())
{
/* ? */
}
break;
#endif /* #ifdef PLAYER_DIGEST */
default:
vOsdPosClear(wPos);
break;
}
if (fgIsUsrCtrlMode(bMode))
{
if (bCurrRemainType() != OSD_SHOW_DISABLE)
{
if (fgIsDvdPlay())
{
bDvdCheckRemainShow(FALSE, bCurrRemainType());
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
bVcdCheckRemainShow(FALSE, bCurrRemainType());
}
#endif
#ifndef CDDA_USE_CDFS
else if (fgIsCddaPlay())
{
bCddaCheckRemainShow(FALSE, bCurrRemainType());
}
#endif
}
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
BOOL fgShowRepeatMode(BYTE bMode) large
{
BOOL fgRet = FALSE; /* default is continue update */
WORD wPos;
WORD wMsg = 0;
if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT;
}
else
{
wPos = OSD_POS_REPEAT;
}
}
else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT_LEFT;
}
else
{
wPos = OSD_POS_REPEAT_LEFT;
}
}
switch (bMode)
{
case SV_REPEAT_ALL:
wMsg = OSD_MSG_ICON_RPT_ALL;
fgRet = TRUE;
break;
case SV_REPEAT_TRACK:
case SV_REPEAT_LIST:
wMsg = OSD_MSG_ICON_RPT_TRK;
fgRet = TRUE;
break;
case SV_REPEAT_TITLE:
wMsg = OSD_MSG_ICON_RPT_TT;
fgRet = TRUE;
break;
case SV_REPEAT_CHAPTER:
wMsg = OSD_MSG_ICON_RPT_CH;
fgRet = TRUE;
break;
case SV_REPEAT_NONE:
case SV_REPEAT_ABNONE:
wMsg = 0xffff;
fgRet = FALSE; /* continue update PBC state */
break;
default:
break;
}
#ifdef PLAYER_GOTO
// megaa Goto
if (fgIsInGoto())
{
if (wMsg == 0xffff)
{
vShowGotoRepeat(OSD_MSG_OFF);
}
else if (wMsg != 0)
{
vShowGotoRepeat(wMsg);
}
}
#endif
if (_rOsdStateCtx.fgRepeatShow == TRUE)
{
if (wMsg == 0xffff)
{
vOsdPosClear(wPos);
}
else if (wMsg != 0)
{
vOsdPosShow(wPos, wMsg, OSD_NO_DISAPPEAR);
}
}
return (fgRet);
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
BOOL fgShowAuxCtrl(BYTE bMode) large
{
#ifdef PLAYER_FLMENU
//BOOL fgFlMenuOn = fgFsMenuIsMenuOn();
BOOL fgFlMenuOn = fgFlCheckStatus(FL_STATUS_IN_MENU);
WORD wTmp;
#endif
BOOL fgRet = FALSE; /* default is continue update */
WORD wPos;
if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT;
}
else
{
wPos = OSD_POS_REPEAT;
}
}
else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
{
if (fgIsIsoPlay())
{
wPos = OSD_POS_ISO_REPEAT_LEFT;
}
else
{
wPos = OSD_POS_REPEAT_LEFT;
}
}
switch (bMode)
{
case SV_REPEAT_SET_A:
#ifdef PLAYER_FLMENU
if (fgFlMenuOn)
{
vFlIpShowInfo(IP_INFO_USR_AUX_CTRL, bMode, 0);
}
else
#endif /* PLAYER_FLMENU */
{
#ifdef PLAYER_GOTO
if (fgIsInGoto())
{
vShowGotoPbc(OSD_MSG_ICON_RPT_A);
}
#endif /* PLAYER_GOTO */
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_A, OSD_NO_DISAPPEAR);
}
fgRet = TRUE;
break;
case SV_REPEAT_LAST_SP: // temp use A-B icon
case SV_REPEAT_INSTANT: // temp use A-B icon
case SV_REPEAT_AB:
#ifdef PLAYER_FLMENU
if (fgFlMenuOn)
{
vFlIpShowInfo(IP_INFO_USR_AUX_CTRL, bMode, 0);
}
else
#endif
{
#ifdef PLAYER_GOTO
if (fgIsInGoto())
{
vShowGotoPbc(OSD_MSG_ICON_RPT_AB);
}
#endif
vOsdPosShow(wPos, OSD_MSG_ICON_RPT_AB, OSD_NO_DISAPPEAR);
}
fgRet = TRUE;
#ifdef KARAOKE_MIC_REC
if (bMode == SV_REPEAT_AB)
{
vMicRecCtrl(MIC_REC_CTRL_INIT);
}
#endif
break;
case SV_REPEAT_NONE:
case SV_REPEAT_ABNONE:
#ifdef PLAYER_FLMENU
if (fgFlMenuOn)
{
vFlIpShowInfo(IP_INFO_USR_AUX_CTRL, bMode, 0);
}
else
#endif
{
#ifdef PLAYER_GOTO
if (fgIsInGoto())
{
vShowGotoPbc(OSD_MSG_NULL);
}
#endif
vOsdPosClear(wPos);
}
#ifdef KARAOKE_MIC_REC
vMicRecCtrl(MIC_REC_CTRL_RESET);
#endif
fgRet = FALSE; /* continue update repeat mode and PBC state */
break;
default:
break;
}
return (fgRet);
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowDiscType(BYTE bDiscType) large
{
/* vOsdPosClear(OSD_POS_INIT); */ /* No need, since disc type show is moved to layer 2 */
#ifdef VFD_HDCD_LED
VfdLed(0, 0xFF);
#endif
switch (bDiscType)
{
case SV_DVD_VIDEO:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_EMPTY, OSD_TIMEOUT);
break;
case SV_DVD_AUDIO:
#ifdef SUPPORT_DVD_AUDIO
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_DVD_AUDIO, OSD_TIMEOUT);
#endif
break;
#ifdef VCD_SUPPORT
case SV_VCD3_0:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_VCD30, OSD_TIMEOUT);
break;
case SV_VCD2_0:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_VCD20, OSD_TIMEOUT);
break;
case SV_VCD1_1:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_VCD11, OSD_TIMEOUT);
break;
case SV_SVCD:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_SVCD, OSD_TIMEOUT);
break;
case SV_CVD:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_CVD, OSD_TIMEOUT);
break;
#endif /* #ifdef VCD_SUPPORT */
case SV_DATA:
vOsdPosClear(OSD_POS_DISC_TYPE);
break;
case SV_PCD: // - for KODAK picture CD.
/* FsMenu initial moved to vISOinit() */
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_PICTURE_CD, OSD_TIMEOUT);
break;
case SV_CDDA:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_CD, OSD_TIMEOUT);
#ifndef CDDA_AUTO_PLAY
vOsdShowTrack(OSD_TOTAL, 0, bSharedInfo(SI_TRACK_NS), OSD_NO_DISAPPEAR);
#endif
break;
case SV_DTS_CS:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_DTS_CD, OSD_TIMEOUT);
vOsdShowTrack(OSD_TOTAL, 0, bSharedInfo(SI_TRACK_NS), OSD_NO_DISAPPEAR);
break;
case SV_CDG:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_CD_G, OSD_TIMEOUT);
vOsdShowTrack(OSD_TOTAL, 0, bSharedInfo(SI_TRACK_NS), OSD_NO_DISAPPEAR);
break;
case SV_HDCD:
#ifdef HDCD_EN
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_HDCD, OSD_TIMEOUT);
#else
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_CD, OSD_TIMEOUT);
#endif
vOsdShowTrack(OSD_TOTAL, 0, bSharedInfo(SI_TRACK_NS), OSD_NO_DISAPPEAR);
#ifdef VFD_HDCD_LED
VfdLed(0, 0xFF);
#endif
break;
case SV_MINI_DVD:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_MINI_DVD, OSD_TIMEOUT);
break;
#ifdef SUPPORT_SACD
case SV_SACD:
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_SACD, OSD_TIMEOUT);
#endif
case SV_AUDIO_IN:
/* don't clear OSD */
break;
default:
vOsdPosClear(OSD_POS_DISC_TYPE);
break;
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowAudioAppl(BYTE bType) large
{
BYTE bVocalMode = bAdspCurrVocal();
switch (bType)
{
case SV_A_APPL_KARA:
break;
case SV_A_APPL_SURR:
case SV_A_APPL_NONE:
default:
if (fgIsAc3Vocal(bVocalMode))
{
#ifdef PLAYER_KARAOKE
vAdspVocalAssist(VOCAL_NO_ASSIST);
#endif
}
break;
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowVideoFormat(void) large
{
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowVideoBitrate(void) large
{
#ifdef PLAYER_GOTO
if (fgIsInGoto())
{
vUpdateGotoShow(GOTO_SHOW_PANEL_BITRATE);
}
#endif
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowAudioBitrate(void) large
{
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vAINUpdateBitRate();
}
#endif /* AUDIO_IN_EN */
#ifdef PLAYER_FLMENU
if (fgIsIsoPlay())
{
vFlIpShowInfo(IP_INFO_BITRATE, 0,
bSharedInfo(SI_A_BITRATE0) + bSharedInfo(SI_A_BITRATE1) * 256);
}
#endif
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
static void vShowAudioFreqBitLen(void) large
{
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vAINUpdateBitLen();
}
#endif /* AUDIO_IN_EN */
}
/************************************************************************
Function :
Description : UOP return dispatch
Parameter :
Return :
************************************************************************/
BYTE bHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
BYTE bResult = UOP_UPDATE;
/* if ((bUopId > UOP_LAST_GENERIC_UOP) || (bUopId < UOP_PLAYBACK_START)) */
if ((bUopId > UOP_LAST_RISC_UOP) && (bUopId != UOP_NONE))
{
return (UOP_OK); /* not show ERROR */
}
/* clear last sync UOP flag here */
if (bUopId == _bLastSyncUop)
{
/* check servo stop */
#ifdef PLAYER_STOP_SRV_STOP
if (fgSrvStopCheck() == TRUE)
{
_bUISrvStatus = PLAYER_SRV_STOP;
}
#endif
_bLastSyncUop = UOP_NONE;
}
/* dispatch the UOP return */
if ((bUopId >= UOP_SYSTEM_START) && (bUopId <= UOP_SYSTEM_MAX))
{
bResult = bCOMHandleUopRet(bUopId, bUopRet);
}
/* else if ((bUopId >= UOP_PLAYBACK_START) && (bUopId <= UOP_PLAYBACK_MAX)) */
/* else if ((bUopId >= UOP_PLAYBACK_START) && (bUopId <= UOP_LAST_RISC_UOP)) */
else if ((bUopId != UOP_NONE) && (bUopId <= UOP_LAST_RISC_UOP))
{
#ifndef NEW_PLAY
if (fgIsDvdPlay())
{
bResult = bDVDHandleUopRet(bUopId, bUopRet);
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
bResult = bVCDHandleUopRet(bUopId, bUopRet);
}
#endif
#ifdef SUPPORT_DATA_DISC
else if (fgIsIsoPlay())
{
bResult = bISOHandleUopRet(bUopId, bUopRet);
}
#ifdef SUPPORT_PCD
else if (fgIsPcdPlay())
{
bResult = bPCDHandleUopRet(bUopId, bUopRet);
}
#endif
#endif /* SUPPORT_DATA_DISC */
#ifndef CDDA_USE_CDFS
else if (fgIsCddaPlay())
{
bResult = bCDDAHandleUopRet(bUopId, bUopRet);
}
#endif
#ifdef AUDIO_IN_EN
else if (fgIsAinPlay())
{
bResult = bAINHandleUopRet(bUopId, bUopRet);
}
#endif
#else /* NEW_PLAY*/
bResult = bDiscHandleUopRet(bUopId, bUopRet);
#endif
}
if (bResult == UOP_FAIL)
{
vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
}
else /* UOP O.K. */
{
vOsdShowError(OSD_ERROR_CLEAR, 0);
}
return (bResult);
}
/************************************************************************
Function :
Description : Error return dispatch
Parameter :
Return :
************************************************************************/
BYTE bHandleErrRet(BYTE bItem) large
{
BYTE bRet = UOP_OK;
switch (bItem)
{
case bSIItemIndex(SI_OSD_ERR_RET):
{
if (bSharedInfo(SI_OSD_ERR_RET) == SV_ERR_OSD_MEM_FULL)
{
#ifdef RS232_WB_DEBUG
DBGLogS(" mem full \n");
#endif
vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
}
break;
}
case bSIItemIndex(SI_UOP_ID):
case bSIItemIndex(SI_UOP_RET_VAL):
case bSIItemIndex(SI_UOP_SUB_ID):
{
bRet = bHandleUopRet(_rOsdStateCtx.bUopRetId, _rOsdStateCtx.bUopRetVal);
break;
}
default:
/* not a valid item, ignore it! */
break;
} /* switch (bItem) */
if (bRet == UOP_FAIL)
{
vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
}
else /* UOP O.K. */
{
vOsdShowError(OSD_ERROR_CLEAR, 0);
}
return (bRet);
}
/************************************************************************
Function :
Description : Share info update handle
Parameter :
Return :
************************************************************************/
void vGroupPbcUpdateUsrCtrl(BYTE bItem) large
{
BYTE bAuxCtrl = bSharedInfo(SI_USR_AUX_CTRL);
BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);
BYTE bUsrPbc = bSharedInfo(SI_USR_PBC_CTRL);
switch (bItem)
{
case bSIItemIndex(SI_USR_AUX_CTRL):
case bSIItemIndex(SI_REPEAT_MODE):
case bSIItemIndex(SI_USR_PBC_CTRL):
{
if (fgShowAuxCtrl(bAuxCtrl))
{
break;
}
/* for ISO play, we do not need to show repeat mode and user control mode */
if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
|| fgIsPcdPlay()
#endif
)
{
if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
{
vOsdPosClear(OSD_POS_ISO_REPEAT);
}
else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
{
vOsdPosClear(OSD_POS_ISO_REPEAT_LEFT);
}
break;
}
if (fgShowRepeatMode(bRepeatMode))
{
break;
}
vShowUsrPbcCtrl(bUsrPbc);
break;
}
} /* switch (bItem) */
#if (defined(PLAYER_PROGRAM) || defined(PLAYER_DIGEST))
if (bItem == bSIItemIndex(SI_USR_PBC_CTRL))
{
if (fgIsInputStateValid(INPUT_STATE_PROGRAM))
{
vSelMenuUsrPbcChange();
}
#ifdef PLAYER_DIGEST
else if (fgIsInputStateValid(INPUT_STATE_DIGEST))
{
vDigestUsrPbcChange();
}
#endif
}
#endif
VfdShowUsrMode(bUsrPbc);
VfdShowRepeatMode(bRepeatMode);
VfdShowRepeatAB(bAuxCtrl);
}
/************************************************************************
Function :
Description : Share info update handle
Parameter :
Return :
************************************************************************/
void vGroupPbcUpdate(BYTE bItem) large
{
BYTE bTmp1, bTmp2;
#ifdef PLAYER_GOTO
BYTE pbStr[] = { 0 };
#endif
switch (bItem)
{
#ifdef MT1379_MANUFACTURE_TEST
case bSIItemIndex(SI_MANU_TEST_ST):
{
vCheckTestStatus();
_bPlayPostKey = IR_EJECT;
return;
}
#endif
case bSIItemIndex(SI_INIT_STATE):
{
bTmp1 = bSharedInfo(SI_INIT_STATE);
VfdShowInitStatus(bTmp1);
vShowInitState(bTmp1);
break;
}
case bSIItemIndex(SI_DISC_TYPE):
{
bTmp1 = bSharedInfo(SI_DISC_TYPE);
VfdShowDiscType(bTmp1);
vAdspAudioTypeChange(SV_A_CODE_NONE, bTmp1, SV_DISC_IDENTIFIED);
/* vShowDiscType(bTmp); */ /* move to vSetPlayType() */
if (fgIsInSetupMenu())
{
vSetupMenuClose();
}
break;
}
case bSIItemIndex(SI_UPGRADE_ST):
{
vUpgShowState(bSharedInfo(SI_UPGRADE_ST));
return;
}
}
if (fgIsNonPlay())
{
#ifdef EN_DISC_ID_CHK
if ((bItem == bSIItemIndex(SI_PBC_STATE)) &&
fgIsDiscInitFlagSet(DISC_INIT_DISC_TYPE))
{
if ((bSharedInfo(SI_PBC_STATE) == SV_REGION_ERR) &&
(bSharedInfo(SI_DISC_TYPE) == SV_DVD_VIDEO))
{
// reset init flag
vResetDiscInitFlag();
// clear play type
if (!fgIsNonPlay())
{
vClearPlayType();
}
// clear OSD
vOsdShowInitState(SV_DISC_IDENTIFIED);
// sho error message
vOsdPosShow(OSD_POS_ERROR, OSD_MSG_WRONG_REGION, OSD_NO_DISAPPEAR);
vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
}
}
#endif /* EN_DISC_ID_CHK */
return; /* not a good method! */
}
switch (bItem)
{
#ifdef KARAOKE_MIC_REC
case bSIItemIndex(SI_REC_PROGRESS):
{
if (bEepromReadByte(MIC_SW_POS) == EV_ON)
{
vMicRecProgressUpdate();
}
break;
}
case bSIItemIndex(SI_AB_STATE):
{
if (bEepromReadByte(MIC_SW_POS) == EV_ON)
{
vMicRecStateChange(bSharedInfo(SI_AB_STATE));
}
break;
}
#endif /* KARAOKE_MIC_REC */
case bSIItemIndex(SI_PBC_SWITCH): /* only usefule for disc play startup */
{
#ifdef VCD_SUPPORT
if (fgIsVcdPlay())
{
bTmp1 = bSharedInfo(SI_PBC_SWITCH);
VfdShowPbcSwitch(bTmp1 == SV_PBC_ON);
#if 0
if (bTmp1 == SV_PBC_ON)
{
vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
}
else if (bTmp1 == SV_PBC_OFF)
{
vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_OFF, OSD_TIMEOUT_SHORT);
}
#endif
if (bCurrRemainType() != OSD_SHOW_DISABLE)
{
bVcdCheckRemainShow(FALSE, bCurrRemainType());
}
}
#endif /* #ifdef VCD_SUPPORT */
break;
}
case bSIItemIndex(SI_PBC_STATE):
case bSIItemIndex(SI_PBC_SPEED):
{
bTmp1 = bSharedInfo(SI_PBC_STATE);
#ifdef PLAYER_GOTO
if (fgIsInGoto())
{
if (fgChkGotoExit() == TRUE)
{
fgSetPlayPostKey(IR_GOTO);
}
else if (bTmp1 == SV_PLAY)
{
vGotoShowIcon(OSD_MSG_ICON_PLAY, pbStr);
}
}
#endif /* PLAYER_GOTO */
vChangePbcState(bTmp1);
vShowPbcState(bTmp1);
vAdspPbcChange(bTmp1);
break;
}
case bSIItemIndex(SI_USR_AUX_CTRL):
case bSIItemIndex(SI_REPEAT_MODE):
case bSIItemIndex(SI_USR_PBC_CTRL):
{
vGroupPbcUpdateUsrCtrl(bItem);
break;
}
#ifdef PLAYER_ZOOMIN_INDICATOR
case bSIItemIndex(SI_ZOOM_OFST_X_HI):
case bSIItemIndex(SI_ZOOM_OFST_X_LO):
case bSIItemIndex(SI_ZOOM_OFST_Y_HI):
case bSIItemIndex(SI_ZOOM_OFST_Y_LO):
{
if (fgIsZoomBrShow())
{
vZoomBrUpdate();
}
break;
}
#endif /* PLAYER_ZOOMIN_INDICATOR */
case bSIItemIndex(SI_ZOOM_SWITCH):
{
bTmp1 = bSharedInfo(SI_ZOOM_SWITCH);
bTmp2 = bSharedInfo(SI_ISO_ITEM_TYPE);
#ifdef DDISC_FTYPE_JPEG_SUPPORT
if (fgIsIsoPlay()
|| (
#ifdef SUPPORT_PCD
fgIsPcdPlay() &&
#endif
(fgFlCheckStatus(FL_STATUS_IN_JPEG))))
{
vOsdShowZoomPct(bTmp1);
VfdShowZoom(TRUE);
if ((bTmp1 == 0) && fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
{
/* need to escape zoom control mode */
fgSetPlayPostKey(IR_ZOOM_IN);
VfdShowZoom(FALSE);
}
}
else
#endif
{
#ifdef DDISC_FTYPE_JPEG_SUPPORT
if ((fgIsIsoPlay() && (!fgFlCheckStatus(FL_STATUS_IN_JPEG))) &&
fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
{
/* need to escape zoom control mode */
fgSetPlayPostKey(IR_ZOOM_IN);
VfdShowZoom(FALSE);
}
else
#endif
{
vOsdShowZoom(bTmp1);
#ifdef PLAYER_ZOOMIN_INDICATOR
if ((bTmp1 >= SV_ZOOM_IN_MIN) &&
(bTmp1 <= SV_ZOOM_IN_MAX))
{
if (fgIsZoomBrShow())
{
vZoomBrUpdate();
}
else
{
vZoomBrOn();
}
}
else // not in zoom-in mode
{
if (fgIsZoomBrShow())
{
vZoomBrOff();
}
}
#endif /* PLAYER_ZOOMIN_INDICATOR */
if ((bTmp1 == SV_ZOOM_OFF) || (bTmp1 >= SV_ZOOM_MODE_MAX))
{
VfdShowZoom(FALSE);
}
else
{
VfdShowZoom(TRUE);
}
}
}
break;
}
default:
break;
}
}
/************************************************************************
Function :
Description : Share info update handle
Parameter :
Return :
************************************************************************/
void vGroupTimeUpdate(BYTE bItem) large
{
#ifdef KARAOKE_SCORING
BOOL fgShow = FALSE;
BOOL fgRmn2Sec = FALSE;
BOOL fgRmnLast2Sec = FALSE;
BYTE bKScore;
#ifdef KARAOKE_SCORE_TEST
BYTE pbStr[13];
WORD wHit0;
WORD wHit1;
WORD wMiss;
#else
BYTE pbStr[4];
#endif
#endif
switch (bItem)
{
case bSIItemIndex(SI_TIME_SS):
{
vOsdDisplayChange(DISP_TIME_MARK, 0);
#ifdef KARAOKE_SCORING
if (fgIsDvdPlay() && bSharedInfo(SI_DVD_DOM) == SV_VTSTT_DOM)
{
fgShow = TRUE;
if (bSharedInfo(SI_TIME_CHAPTER_RMN_SS) <= 2)
{
fgRmn2Sec = TRUE;
if (bSharedInfo(SI_TIME_CHAPTER_RMN_HH) == 0 &&
bSharedInfo(SI_TIME_CHAPTER_RMN_MM) == 0)
fgRmnLast2Sec = TRUE;
}
}
else if (fgIsVcdPlay() || fgIsCddaPlay())
{
fgShow = TRUE;
if (bSharedInfo(SI_TIME_TRACK_RMN_SS) <= 2)
{
fgRmn2Sec = TRUE;
if (bSharedInfo(SI_TIME_TRACK_RMN_HH) == 0 &&
bSharedInfo(SI_TIME_TRACK_RMN_MM) == 0)
fgRmnLast2Sec = TRUE;
}
}
if (fgShow)
{
bKScore = bAdspGetKScore();
pbStr[0] = 3;
pbStr[1] = '0';
pbStr[2] = BCD_HI(bKScore) + '0';
pbStr[3] = BCD_LO(bKScore) + '0';
if(fgAdspKscoreSupport())
{
vOsdPosShowArg(OSD_POS_KSCORE, OSD_MSG_KSCORE, OSD_TIMEOUT, pbStr);
}
#ifdef KARAOKE_SCORE_TEST
vAdspGetKSHitMiss(&wHit0,&wHit1, &wMiss);
pbStr[0] = 12;
pbStr[1] = bDigToAsc(wHit0 / 0x1000);
wHit0 %= 0x1000;
pbStr[2] = bDigToAsc(wHit0 / 0x100);
wHit0 %= 0x100;
pbStr[3] = bDigToAsc(wHit0 / 0x10);
wHit0 %= 0x10;
pbStr[4] = bDigToAsc(wHit0);
pbStr[5] = bDigToAsc(wHit1 / 0x1000);
wHit1 %= 0x1000;
pbStr[6] = bDigToAsc(wHit1 / 0x100);
wHit1 %= 0x100;
pbStr[7] = bDigToAsc(wHit1 / 0x10);
wHit1 %= 0x10;
pbStr[8] = bDigToAsc(wHit1);
pbStr[9] = bDigToAsc(wMiss / 0x1000);
wMiss %= 0x1000;
pbStr[10] = bDigToAsc(wMiss / 0x100);
wMiss %= 0x100;
pbStr[11] = bDigToAsc(wMiss / 0x10);
wMiss %= 0x10;
pbStr[12] = bDigToAsc(wMiss);
vOsdPosShowArg(OSD_POS_KSINFO, OSD_MSG_KSHITMISS, OSD_TIMEOUT, pbStr);
#endif
}
#endif /* KARAOKE_SCORING */
break;
}
default:
break;
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupNvUpdateAngle(BYTE bAglNo, BYTE bAglNs) large
{
if (bAglNs > 9)
{
bAglNs = 0;
}
VfdShowAngle(bAglNs > 1);
if (fgIsInputStateValid(INPUT_STATE_ANGLE_CHANGE))
{
if (bAglNs > 1)
{
vOsdShowAngle(OSD_ANGLE_HILI, bAglNo, bAglNs);
}
else
{
fgSetPlayPostKey(IR_TIME_OUT);
}
}
else if (fgIsAngleShow())
{
vOsdShowAngle(OSD_ANGLE_NORMAL, bAglNo, bAglNs);
}
else
{
vOsdShowAngle(OSD_ANGLE_CLEAR, 0, 0);
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupNvUpdate(BYTE bItem) large
{
BYTE bMode, bDefMode;
switch (bItem)
{
case bSIItemIndex(SI_AGL_NS):
case bSIItemIndex(SI_AGL_NO):
{
vGroupNvUpdateAngle(bSharedInfo(SI_AGL_NO), bSharedInfo(SI_AGL_NS));
#ifdef PLAYER_GOTO
if (fgIsInGoto()) // megaa Goto
{
vShowGotoAngle();
}
#endif
break;
}
case bSIItemIndex(SI_TT_NO): /* SI_FILE_NS_HI */
case bSIItemIndex(SI_TT_NS): /* SI_FILE_NS_LO */
case bSIItemIndex(SI_CHAP_NO): /* SI_TRACK_NO, SI_FILE_NO_HI */
case bSIItemIndex(SI_CHAP_NS): /* SI_TRACK_NS, SI_FILE_NO_LO */
{
vOsdDisplayChange(DISP_PLAY_INFO, bItem);
#ifdef PLAYER_GOTO
if (fgIsInGoto()) // megaa Goto
{
#ifdef GOTO_IN_TRACK_ONLY
if (fgIsVcdPlay() && (fgChkGotoExit() == TRUE))
{
fgSetPlayPostKey(IR_GOTO);
}
else
#endif /* GOTO_IN_TRACK_ONLY */
{
vUpdateGotoShow(GOTO_SHOW_PANEL_ALL);
vShowGotoChapter();
vShowGotoTitle();
vShowGotoTime();
vShowGotoTimeCH();
}
} /* fgIsInGoto() */
#endif /* PLAYER_GOTO */
#ifdef KARAOKE_SCORING
vAdspResetKScore();
#endif /* KARAOKE_SCORING */
break;
}
case bSIItemIndex(SI_DVD_DOM): /* SI_VCD_DOM */
#ifdef PLAYER_GOTO
// megaa Goto begin
if (fgIsInGoto())
{
#ifdef GOTO_VTSTT_DOM_ONLY
if (fgChkGotoExit() == TRUE)
{
fgSetPlayPostKey(IR_GOTO);
}
else
#endif
{
vShowGotoChapter();
vShowGotoTitle();
vShowGotoAngle();
vDealGotoAudio(FALSE);
if (bSharedInfo(SI_DVD_DOM) == SV_VTSTT_DOM)
{
vDealGotoSubtitle(FALSE);
}
else
{
vShowGotoSubtitle(OSD_MSG_OFF);
}
}
} /* fgIsInGoto() */
#endif /* PLAYER_GOTO */
if (fgIsDvdPlay())
{
vDVDShowDomainInfo();
}
#ifdef VCD_SUPPORT
else if (fgIsVcdPlay())
{
vVCDShowDomainInfo();
}
#endif
break;
case bSIItemIndex(SI_DVD_MENU_TYPE):
/* vDVDShowMenuType(); */
#ifdef PLAYER_GOTO
if (fgIsInGoto()) // megaa Goto !!!!!!!!!!!!
{
vUpdateGotoShow(GOTO_SHOW_PANEL_ALL);
vShowGotoSubtitle(OSD_MSG_OFF);
vShowGotoTime();
vShowGotoTimeCH();
vShowGotoRepeat(OSD_MSG_OFF);
}
#endif /* PLAYER_GOTO */
break;
/* case bSIItemIndex(SI_STILL_SWITCH): */
#ifdef PLAYER_GOTO
case bSIItemIndex(SI_HLI_STATE):
{
#ifdef GOTO_VTSTT_DOM_ONLY
if (fgIsInGoto())
{
if (fgChkGotoExit() == TRUE)
{
fgSetPlayPostKey(IR_GOTO);
}
}
#endif /* GOTO_VTSTT_DOM_ONLY */
break;
}
#endif /* PLAYER_GOTO */
case bSIItemIndex(SI_PBC_CTRL_VALID):
{
/* assume only SVCD/VCD notify this */
if ((bSharedInfo(SI_PBC_CTRL_VALID) == SV_PBC_OFF) ||
(bSharedInfo(SI_VCD_PBC_OFF) == TRUE))
{
vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_OFF, OSD_TIMEOUT_SHORT);
}
else /* disc with PBC and allow it on */
{
vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
}
break;
}
case bSIItemIndex(SI_ASPECT_CHG_VALID):
{
/* redraw general page
1. if setup menu on &
2. current show page is general page
*/
vSetupAspChg();
/*
bDefMode = bSharedInfo(SI_ASPECT_CHG_VALID) ;
bMode = bEepromReadByte(ASPECT_POSITION);
#ifdef TREAT_PS_LB_AS_THE_SAME
if ((bMode == SV_4_3_PS) && (!(SV_PSCAN_ON & bDefMode)))
bMode = SV_4_3_LB ;
else if ((bMode == SV_4_3_LB) && (!(SV_LB_ON & bDefMode)))
bMode = SV_4_3_PS ;
#endif
vSetSharedInfo(SI_FORCE_ASPECT_RATIO, bMode);
vSetSharedInfo(SI_ASPECT_RATIO, bMode);
if (SV_BLOCK_ON & bDefMode)
vNotifySharedInfo(SI_FORCE_ASPECT_RATIO, 0, 0);
else
vNotifySharedInfo(SI_ASPECT_RATIO, 0, 0);
*/
break;
}
default:
break;
}
}
/************************************************************************
Function :
Description : show P/N ISO_LOGO
Parameter :
Return :
************************************************************************/
void vGroupSetUpdate(BYTE bItem) large
{
switch (bItem)
{
case bSIItemIndex(SI_TV_SYSTEM):
if((fgIsIsoPlay() || fgIsPcdPlay()) && (_bFlCmdTarget == FL_CMD_TARGET_MENU))
{
#if(defined CDDA_USE_CDFS && defined CDG_SUPPORT)
if(bSharedInfo(SI_CDG_DISC) != SV_ON)
#endif
vPlayerShowLogo(ISO_STOP_LOGO, ISO_LOGO_COLOR);
}
break;
}
}
#ifdef HDCD_EN
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupDiscTypeUpdate(BYTE bItem) large
{
switch (bItem)
{
case bSIItemIndex(SI_A_CODE_MODE):
if(bSharedInfo(SI_A_CODE_MODE) == SV_A_CODE_HDCD)
{
#ifdef RS232_LOG
DBGLogS(" disc is SV_A_CODE_HDCD \n");
#endif
vSetSharedInfo(SI_FS_DISC_TYPE, SV_HDCD);
}
break;
}
}
#endif /*#ifdef HDCD_EN */
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupStreamUpdate(BYTE bItem) large
{
BYTE bTmp1, bTmp2;
switch (bItem)
{
#ifdef PLAYER_GOTO
// megaa Goto begin
case bSIItemIndex(SI_AST_NO):
{
if (fgIsInGoto())
{
vDealGotoAudio(FALSE);
}
break;
}
case bSIItemIndex(SI_SPST_NO):
{
if (fgIsInGoto())
{
vDealGotoSubtitle(FALSE);
}
break;
}
// megaa Goto end
#endif
case bSIItemIndex(SI_A_CODE_MODE):
{
bTmp1 = bSharedInfo(SI_A_CODE_MODE);
bTmp2 = bSharedInfo(SI_DISC_TYPE);
VfdShowAudioType(bTmp1);
vAdspAudioTypeChange(bTmp1, bTmp2, SV_DISC_IDENTIFIED);
#ifdef PLAYER_GOTO
if (fgIsInGoto()) // megaa Goto
{
vDealGotoAudio(FALSE);
}
#endif
#ifdef VCD_SUPPORT
if (fgIsVcdPlay())
{
/* update panel L/R icon, not show OSD */
vVCDShowAudioLR(FALSE);
}
else
#endif
#ifndef CDDA_USE_CDFS
if (fgIsCddaPlay())
{
/* update panel L/R icon, not show OSD */
//vVCDShowAudioLR(FALSE);
#ifdef SHOW_CD_STREAM_TYPE
if (bTmp1 == SV_A_CODE_HDCD)
{
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_HDCD, OSD_TIMEOUT);
}
else if (bTmp1 == SV_A_CODE_PCM)
{
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_CD, OSD_TIMEOUT);
}
#endif /* SHOW_CD_STREAM_TYPE */
#ifdef VFD_HDCD_LED
if (bSharedInfo(SI_TRACK_NO) > 1)
{
if (bTmp1 == SV_A_CODE_HDCD)
{
VfdLed(TRUE, 0xff); // light on LED
}
else
{
VfdLed(FALSE, 0xff); // LED off
} /* SI_A_CODE_MODE */
}
#endif /* VFD_HDCD_LED */
}
#else//in fs
if (fgIsIsoPlay())
{
vFlIpShowInfo(IP_INFO_DISC_TYPE, 0, 0);
}
#endif /* #ifndef CDDA_USE_CDFS */
#ifdef AUDIO_IN_EN
else if (fgIsAinPlay())
{
vAINShowSwitchType(bTmp1);
}
#endif /* AUDIO_IN_EN */
break;
} /* SI_A_CODE_MODE */
case bSIItemIndex(SI_A_CH_CFG):
{
/* assume audio code is valid */
bTmp1 = bSharedInfo(SI_A_CH_CFG);
bTmp2 = bSharedInfo(SI_A_CODE_MODE);
#ifdef PLAYER_GOTO
if (fgIsInGoto()) // megaa Goto
{
vDealGotoAudio(FALSE);
}
#endif
#ifdef VCD_SUPPORT
if (fgIsVcdPlay())
{
VfdShowAudioCh(bTmp1);
vVCDShowAudioLR(FALSE);
}
break;
#endif
} /* SI_A_CH_CFG */
#ifdef AUDIO_IN_EN
case bSIItemIndex(SI_DSP_CH_CFG):
{
if (fgIsAinPlay())
{
vAINUpdateChInfo();
VfdShowAudioCh(bSharedInfo(SI_DSP_CH_CFG));
}
break;
}
#endif /* AUDIO_IN_EN */
case bSIItemIndex(SI_A_APPL_MODE):
{
bTmp1 = bSharedInfo(SI_A_APPL_MODE);
if (fgIsDvdPlay())
{
vShowAudioAppl(bTmp1);
}
#ifdef AUDIO_IN_EN
else if (fgIsAinPlay())
{
vAINShowKaraFlag(bTmp1);
}
#endif /* AUDIO_IN_EN */
break;
} /* SI_A_APPL_MODE */
case bSIItemIndex(SI_ISO_ITEM_TYPE): /* SI_VCD_ITEM_TYPE */
{
bTmp1 = bSharedInfo(SI_ISO_ITEM_TYPE);
if (fgIsVcdPlay())
{
/* not impletement yet! */
}
#ifdef SUPPORT_DATA_DISC
else if (fgIsIsoPlay())
{
if ((fgIsIsoItemAOnly(bTmp1) && fgFlCheckStatus(FL_STATUS_IN_MENU)) ||
(fgIsIsoItemStill(bTmp1) && fgFlCheckStatus(FL_STATUS_IN_JPEG)) ||
(fgIsIsoItemAV(bTmp1) && fgFlCheckStatus(FL_STATUS_IN_MPEG)))
vISOShowItemType(bTmp1);
}
#endif
break;
} /* SI_ISO_ITEM_TYPE */
case bSIItemIndex(SI_V_FRAMERATE):
case bSIItemIndex(SI_V_HSIZE_L):
case bSIItemIndex(SI_V_HSIZE_H):
case bSIItemIndex(SI_V_VSIZE_L):
case bSIItemIndex(SI_V_VSIZE_H):
{
vShowVideoFormat();
break;
} /* SI_V_FRAMERATE SI_V_HSIZE, SI_V_VSIZE */
#ifdef PLAYER_GOTO
case bSIItemIndex(SI_V_BITRATE0):
case bSIItemIndex(SI_V_BITRATE1):
{
vShowVideoBitrate();
break;
} /* SI_V_BITRATE */
#endif
case bSIItemIndex(SI_NTSC_PAL):
{
bTmp1 = bSharedInfo(SI_PBC_STATE);
#ifdef SUPPORT_DATA_DISC
#ifdef SUPPORT_PCD
if (fgIsPcdPlay())
{
//if (fgIsInDigest(bTmp1))
if (fgFlCheckStatus(FL_STATUS_IN_JPGDGST))
{
#ifdef PLAYER_FLMENU
vFlRecover();
#else
vFsMenuRecoverMenus();
#endif
}
}
else
#endif
if (fgIsIsoPlay())
{
if (bSharedInfo(SI_ISO_ITEM_TYPE) == SV_ISO_JPG)
{
//if (fgIsInDigest(bTmp1))
if (fgFlCheckStatus(FL_STATUS_IN_JPGDGST))
{
#ifdef PLAYER_FLMENU
vFlRecover();
#else
vFsMenuRecoverMenus();
#endif
}
}
}
#endif
break;
} /* SI_NTSC_PAL */
//make sure mpv already pause
case bSIItemIndex(SI_MPV_PAUSE):
vShowMenuAfterPause();
break;
default:
break;
}
}
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupAudioStatusUpdate(BYTE bItem) large
{
switch (bItem)
{
case bSIItemIndex(SI_A_FREQ):
break;
case bSIItemIndex(SI_A_SRC_FREQ):
case bSIItemIndex(SI_A_BITLEN):
{
vShowAudioFreqBitLen();
}
case bSIItemIndex(SI_A_UPSAMPLING):
{
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vAINUpdateUpsmapling();
}
#endif /* AUDIO_IN_EN */
break;
}
case bSIItemIndex(SI_A_BITRATE0):
case bSIItemIndex(SI_A_BITRATE1):
{
vShowAudioBitrate();
break;
} /* SI_A_BITRATE */
case bSIItemIndex(SI_A_EFFECT_0):
case bSIItemIndex(SI_A_EFFECT_1):
case bSIItemIndex(SI_A_EFFECT_2):
case bSIItemIndex(SI_A_EFFECT_3):
{
#ifdef AUDIO_IN_EN
if (fgIsAinPlay())
{
vAINShow3DMark();
}
#endif /* AUDIO_IN_EN */
break;
} /* SI_A_EFFECT_0 */
default:
break;
}
}
#if (defined(PLAYER_PROGRAM) || defined(PLAYER_DIGEST))
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupUsrCtrlUpdate(BYTE bItem) large
{
switch (bItem)
{
#ifdef PLAYER_PROGRAM
case bSIItemIndex(SI_USR_PROGRAM_NO):
break;
#endif
#ifdef PLAYER_DIGEST
case bSIItemIndex(SI_USR_DIGEST_NO):
if (fgIsInputStateValid(INPUT_STATE_DIGEST))
{
vDigestHandleUpdate(DGST_UPD_NO, bSharedInfo(SI_USR_DIGEST_NO));
}
break;
#endif
default:
break;
}
}
#endif
#if (defined(LAST_MEM_SUPPORT) || defined(MEMORY_SUPPORT))
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vGroupMemoryUpdate(BYTE bItem) large
{
BYTE bTmp1;
switch (bItem)
{
#ifdef LAST_MEM_SUPPORT
case bSIItemIndex(SI_LASTMEM_NS):
/* the SI_LASTMEM_NS contain the valid slot no. */
#if (defined(VCD_LAST_MEM) || defined(DVD_LAST_MEM) || defined(CDDA_LAST_MEM))
if ((bSharedInfo(SI_LASTMEM_NS) > 0) && (bSharedInfo(SI_LAST_MEM) == EV_ON))
{
if (fgIsIsoPlay())
{
vOsdPosShow(OSD_POS_DISC_TYPE, OSD_MSG_LAST_MEMORY, OSD_TIMEOUT);
}
#ifdef AUDIO_IN_EN
else if (fgIsAinPlay())
{
/* do nothing */
}
#endif /* AUDIO_IN_EN */
else /* if (fgIsNonPlay() == FALSE) */
{
vOsdPosShow(OSD_POS_LAST_MEM, OSD_MSG_LAST_MEMORY, OSD_TIMEOUT);
}
}
#endif
break;
#endif /* end of LAST_MEM_SUPPORT */
#ifndef LAST_MEM_FOR_POWER_CUT //zhuweihua
#ifdef MEMORY_SUPPORT
case bSIItemIndex(SI_MEMORY_RES):
{
bTmp1 = bSharedInfo(SI_MEMORY_RES);
switch (bTmp1)
{
case SV_MEM_STORE:
vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MEMORY_STORE, OSD_TIMEOUT_SHORT);
break;
case SV_MEM_PLAY:
vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MEMORY_PLAY, OSD_TIMEOUT_SHORT);
break;
case SV_MEM_ERR:
default:
break;
}
break;
}
#endif
#endif
#ifdef EN_DISC_ID_CHK
case bSIItemIndex(SI_DISC_ID):
vSetDiscInitFlag(DISC_INIT_DISC_ID);
if (fgIsDiscInitFinished())
{
vSendPeriCmd(MISC_CMD_EEPROM_SVC, EEPROM_CMD_CHK_DISC_ID, 0);
}
break;
#endif /* EN_DISC_ID_CHK */
default:
break;
}
}
#endif // (defined(LAST_MEM_SUPPORT) || defined(MEMORY_SUPPORT))
/************************************************************************
Function :
Description :
Parameter :
Return :
************************************************************************/
void vHandleInfoUpdate(BYTE bGroup, BYTE *pbItem) large
{
BYTE i;
void (code *pfUpdate)(BYTE) large;
pfUpdate = 0;
switch (bGroup)
{
case SI_PBC_GRP:
/* the play type check is in the vGroupPbcUpdate() */
pfUpdate = vGroupPbcUpdate;
break;
case SI_NV_GRP:
if (!fgIsNonPlay())
{
pfUpdate = vGroupNvUpdate;
}
break;
case SI_GENERAL_SETUP_GRP:
pfUpdate = vGroupSetUpdate;
break;
case SI_STREAM_STATUS_GRP:
if (!fgIsNonPlay())
{
pfUpdate = vGroupStreamUpdate;
}
#ifdef HDCD_EN
else
{
pfUpdate = vGroupDiscTypeUpdate;
}
#endif
break;
case SI_AUDIO_STATUS_GRP:
if (!fgIsNonPlay())
{
pfUpdate = vGroupAudioStatusUpdate;
}
break;
#if (defined(PLAYER_PROGRAM) || defined(PLAYER_DIGEST))
case SI_USR_CTRL_GRP:
if (!fgIsNonPlay())
{
pfUpdate = vGroupUsrCtrlUpdate;
}
break;
#endif
case SI_TIME_INFO_GRP:
if (!fgIsNonPlay())
{
pfUpdate = vGroupTimeUpdate;
}
break;
#ifdef LOAD_USR_PWD_FILE
case SI_PWD_FILENAME_GRP:
break;
#endif
#if (defined(LAST_MEM_SUPPORT) || defined(MEMORY_SUPPORT))
case SI_MEMORY_GRP:
pfUpdate = vGroupMemoryUpdate;
break;
#endif
default:
return;
}
if (pfUpdate != 0)
{
for (i = 0; i < 3; i++)
{
if (pbItem[i] == 0xff)
{
continue;
}
else
{
pfUpdate(pbItem[i]);
/* check update info count */
#ifdef ACCEL_SI_PROC
if (_bShmUpdCnt > 0)
{
_bShmUpdCnt--;
}
#endif
}
}
} /* if (pfUpdate != 0) */
}
/**
* Update the DFI information from the shared info provided by RISC.
*
* NOTE: We handle the information for data range only.
* 1. update start offset from 0x30000
* 2. update max lb_addr and end position of layer 0
* 3. update end position of layer 1 if necessary
*
* UPDATE GLOBAL:
* _dEndPSN0, _dEndPSN1, _dMaxLBA, _fgTwoLayer, _fgPTP
*/
#ifdef SUPPORT_SACD
static void vUpdateDfi(void) large
{
/* access the external variables defined in channel decoding module */
extern DWRD xdata _dwDataAreaOfst;
extern DWRD xdata _dEndPSN0, _dEndPSN1;
extern DWRD idata _dMaxLBA;
extern BIT _fgTwoLayer, _fgPTP;
BYTE bDs; /* disc structur */
/* update data area offset */
bHiByte(wHiWord(_dwDataAreaOfst)) = bSharedInfo(SI_UPDATE_DFI_START + 4);
bLoByte(wHiWord(_dwDataAreaOfst)) = bSharedInfo(SI_UPDATE_DFI_START + 5);
bHiByte(wLoWord(_dwDataAreaOfst)) = bSharedInfo(SI_UPDATE_DFI_START + 6);
bLoByte(wLoWord(_dwDataAreaOfst)) = bSharedInfo(SI_UPDATE_DFI_START + 7);
_dwDataAreaOfst -= 0x030000L;
/* update the max lb_addr */
bHiByte(wHiWord(_dMaxLBA)) = bSharedInfo(SI_UPDATE_DFI_START + 8);
bLoByte(wHiWord(_dMaxLBA)) = bSharedInfo(SI_UPDATE_DFI_START + 9);
bHiByte(wLoWord(_dMaxLBA)) = bSharedInfo(SI_UPDATE_DFI_START + 10);
bLoByte(wLoWord(_dMaxLBA)) = bSharedInfo(SI_UPDATE_DFI_START + 11);
/* assign the max lb_addr to layer 0 end */
_dEndPSN0 = _dMaxLBA;
bDs = bSharedInfo(SI_UPDATE_DFI_START + 2);
_fgTwoLayer = (bDs & 0x60) ? TRUE : FALSE;
_fgPTP = (bDs & 0x10) ? FALSE : TRUE;
if (_fgTwoLayer) {
/* case for DL */
if (!_fgPTP) {
/* not PTP, then OTP */
_dEndPSN1 = _dEndPSN0;
bHiByte(wHiWord(_dEndPSN0)) = bSharedInfo(SI_UPDATE_DFI_START + 12);
bLoByte(wHiWord(_dEndPSN0)) = bSharedInfo(SI_UPDATE_DFI_START + 13);
bHiByte(wLoWord(_dEndPSN0)) = bSharedInfo(SI_UPDATE_DFI_START + 14);
bLoByte(wLoWord(_dEndPSN0)) = bSharedInfo(SI_UPDATE_DFI_START + 15);
/* calculate the MAX lb_addr from layer 0 end */
bHiByte(wHiWord(_dMaxLBA)) = 0xff;
_dMaxLBA = _dEndPSN0 + _dEndPSN0 - (~_dMaxLBA) + 1;
}
else {
/* PTP, don't care now */
}
}
else {
/* case for SL and HL, do nothing here */
}
return;
}
#endif /* SUPPORT_SACD */
/************************************************************************
Function :
Description : Dispatch share info update
Parameter :
Return :
************************************************************************/
void vSmUpdate(BYTE *pbInfo) large
{
BYTE bResult = UOP_UPDATE;
_dwIrDoneParm = 0x0;
_rOsdStateCtx.fgUopUpdate = ((pbInfo[0] & 0x80) != 0);
#ifdef SUPPORT_SACD
/* Jacob: for data area range update */
if (pbInfo[0] == SI_DFI_GRP) {
vUpdateDfi();
}
#endif /* SUPPORT_SACD */
#ifndef PLAYER_BASIC
if (fgIsFsMenuUpdate(pbInfo[0]))
{
_bIRKey = IR_CMD_DONE;
_dwIrDoneParm = (*(WORD *)pbInfo);
_dwIrDoneParm = _dwIrDoneParm << 16;
_dwIrDoneParm |= ((WORD)pbInfo[2] << 8);
_dwIrDoneParm |= pbInfo[3];
// - enter state machine.
if (fgFsMenuState())
{
_bIRKey = IR_NONE; // - clear the IR key.
}
/* don't continue to update info */
vClearShmUpdCnt();
}
else
#endif /* PLAYER_BASIC */
{
if (pbInfo[0] & 0x80)
{
#if defined(NO_SM_NOTIFY)
_rOsdStateCtx.bUopRetId = bSharedInfo(SI_UOP_FIFO_START + _bShmRp * 4);
_rOsdStateCtx.bUopRetVal = bSharedInfo(SI_UOP_FIFO_START + _bShmRp * 4 + 1);
#else
_rOsdStateCtx.bUopRetId = bSharedInfo(SI_UOP_ID);
_rOsdStateCtx.bUopRetVal = bSharedInfo(SI_UOP_RET_VAL);
#endif
bResult = bHandleUopRet(_rOsdStateCtx.bUopRetId, _rOsdStateCtx.bUopRetVal);
/* don't continue to update info */
vClearShmUpdCnt();
}
else if (pbInfo[0] == SI_UOP_ERR_RET_GRP)
{
#if defined(NO_SM_NOTIFY)
_rOsdStateCtx.bUopRetId = bSharedInfo(SI_UOP_FIFO_START + _bShmRp * 4);
_rOsdStateCtx.bUopRetVal = bSharedInfo(SI_UOP_FIFO_START + _bShmRp * 4 + 1);
#else
_rOsdStateCtx.bUopRetId = bSharedInfo(SI_UOP_ID);
_rOsdStateCtx.bUopRetVal = bSharedInfo(SI_UOP_RET_VAL);
#endif
bResult = bHandleErrRet(pbInfo[1]);
/* don't continue to update info */
vClearShmUpdCnt();
}
if (bResult == UOP_UPDATE)
{
vHandleInfoUpdate(pbInfo[0] & ~0x80, pbInfo + 1);
}
}
_rOsdStateCtx.fgUopUpdate = FALSE;
_rOsdStateCtx.bUopRetId = UOP_NONE;
_rOsdStateCtx.bUopRetVal = SV_NO_ERROR;
}
/************************************************************************
Function :
Description : recall all displayed information
Parameter :
Return :
************************************************************************/
void vStatusDispRecall(void) large
{
BYTE bTmp;
BOOL fgRet;
/* recall display mode and info */
vOsdDisplayChange(DISP_RECALL, 0);
/* recall repeat mode and user PBC state */
vGroupPbcUpdateUsrCtrl(bSIItemIndex(SI_USR_AUX_CTRL));
/* recall zoom mode */
vOsdShowZoom(bSharedInfo(SI_ZOOM_SWITCH));
#ifdef PLAYER_ZOOMIN_INDICATOR
if (fgIsZoomBrShow())
{
vZoomBrUpdate();
}
#endif /* PLAYER_ZOOMIN_INDICATOR */
/* recall angle mark */
vGroupNvUpdateAngle(bSharedInfo(SI_AGL_NO), bSharedInfo(SI_AGL_NS));
/* recall audio stream status */
//vGroupStreamUpdate(bSIItemIndex(SI_A_CODE_MODE));
vGroupStreamUpdate(bSIItemIndex(SI_A_CH_CFG));
}
// *********************************************************************
// Player display mode
// *********************************************************************
static code const strucDisplayState prDisplayState[TOTAL_PLAY_TYPE] =
{
/* PLAY_TYPE_NONE */
{
vResetOsdState,
0,
0,
0,
0,
0,
0,
0,
0
},
/* PLAY_TYPE_DVD */
{
#ifndef NEW_SHOW
vDVDShowInit,
vDVDShowTimeMark,
#else
vShowInit,
vShowTimeMark,
#endif
vDVDShowRemainMsg,
vDVDShowPlayInfo,
#ifndef NEW_SHOW
vDVDShowTrick,
vDVDShowStopResumeState,
vDVDShowStopState,
#else
vShowTrick,
vShowStopResumeState,
vShowStopState,
#endif
vDVDStatusDispRecall,
vDVDChangeRemainType
},
#ifdef VCD_SUPPORT
/* PLAY_TYPE_VCD */
{
#ifndef NEW_SHOW
vVCDShowInit,
vVCDShowTimeMark,
#else
vShowInit,
vShowTimeMark,
#endif
vVCDShowRemainMsg,
vVCDShowPlayInfo,
#ifndef NEW_SHOW
vVCDShowTrick,
vVCDShowStopResumeState,
vVCDShowStopState,
#else
vShowTrick,
vShowStopResumeState,
vShowStopState,
#endif
vVCDStatusDispRecall,
vVCDChangeRemainType
},
#else
{
0,
0,
0,
0,
0,
0,
0,
0,
0
},
#endif /* #ifdef VCD_SUPPORT */
/* PLAY_TYPE_ISO */
#ifdef SUPPORT_DATA_DISC
{
#ifndef NEW_SHOW
vISOShowInit,
vISOShowTimeMark,
#else
vShowInit,
vShowTimeMark,
#endif
vISOShowRemainMsg,
vISOShowPlayInfo,
#ifndef NEW_SHOW
vISOShowTrick,
#else
vShowTrick,
#endif
0,
vISOShowStopState,
vISOStatusDispRecall,
vISOChangeRemainType
},
#else
{
0,
0,
0,
0,
0,
0,
0,
0,
0
},
#endif
#if 0//(defined(SUPPORT_DATA_DISC) && defined(DDISC_FTYPE_JPEG_SUPPORT))
//remove PCD for show_pcd.c
/* PLAY_TYPE_PCD */
{
vPCDShowInit,
0,
0,
vPCDShowPlayInfo,
0,
0,
vPCDShowStopState,
0,
0
},
#else
{
0,
0,
0,
0,
0,
0,
0,
0,
0
},
#endif
#ifndef CDDA_USE_CDFS
/* PLAY_TYPE_CDDA */
{
vCDDAShowInit,
vVCDShowTimeMark,
vVCDShowRemainMsg,
vCDDAShowPlayInfo,
vCDDAShowTrick,
vCDDAShowStopResumeState,
vCDDAShowStopState,
vCDDAStatusDispRecall,
vVCDChangeRemainType
},
#else
{
0,
0,
0,
0,
0,
0,
0,
0,
0
},
#endif
/* PLAY_TYPE_AIN */
{
vAINShowInit,
0,
0,
0,
0,
0,
0,
0,
0
}
};
void vOsdDisplayChange(BYTE bIndex, BYTE bOption) large
{
/* check error condition */
if (_bPlayType >= TOTAL_PLAY_TYPE)
{
return;
}
switch (bIndex)
{
case DISP_INIT:
if ((prDisplayState[_bPlayType]).vShowInit != 0)
{
(prDisplayState[_bPlayType]).vShowInit();
}
break;
case DISP_TIME_MARK:
#ifdef PLAYER_GOTO
// megaa Goto
if (fgIsInGoto())
{
vUpdateGotoShow(GOTO_SHOW_PANEL_ALL);
}
#endif
if ((prDisplayState[_bPlayType]).vShowTimeMark != 0)
{
(prDisplayState[_bPlayType]).vShowTimeMark(FALSE);
}
break;
case DISP_REMAIN_MSG:
if ((prDisplayState[_bPlayType]).vShowRemainMsg != 0)
{
(prDisplayState[_bPlayType]).vShowRemainMsg(bOption);
}
break;
case DISP_PLAY_INFO:
if ((prDisplayState[_bPlayType]).vShowPlayInfo != 0)
{
(prDisplayState[_bPlayType]).vShowPlayInfo(bOption);
}
break;
case DISP_TRICK:
if ((prDisplayState[_bPlayType]).vShowTrick != 0)
{
(prDisplayState[_bPlayType]).vShowTrick(bOption);
}
break;
case DISP_STOP_RESUME:
if ((prDisplayState[_bPlayType]).vShowStopResumeState != 0)
{
(prDisplayState[_bPlayType]).vShowStopResumeState();
}
break;
case DISP_STOP:
if ((prDisplayState[_bPlayType]).vShowStopState != 0)
{
(prDisplayState[_bPlayType]).vShowStopState();
}
break;
case DISP_RECALL:
if ((prDisplayState[_bPlayType]).vStatusDispRecall != 0)
{
(prDisplayState[_bPlayType]).vStatusDispRecall();
}
break;
case DISP_REMAIN_CHG:
if ((prDisplayState[_bPlayType]).vChangeRemainType != 0)
{
_rOsdStateCtx.bTimeType = bOption;
(prDisplayState[_bPlayType]).vChangeRemainType(bOption);
}
break;
case DISP_REMAIN_CHG_INIT:
if ((prDisplayState[_bPlayType]).vChangeRemainType != 0)
{
_rOsdStateCtx.bTimeType = bOption;
(prDisplayState[_bPlayType]).vChangeRemainType(OSD_SHOW_DISP_CHG_INIT);
}
break;
case DISP_REMAIN_CHG_EXIT:
if ((prDisplayState[_bPlayType]).vChangeRemainType != 0)
{
(prDisplayState[_bPlayType]).vChangeRemainType(OSD_SHOW_DISP_CHG_EXIT);
}
break;
default:
return;
}
}