monitor.c

ct952 source code use for Digital Frame Photo

                SMAN_PushStateInfo (STATE_PG, STATUS_READY);
        }
    }
#endif
#endif // !CT950_STYLE
#endif //
#endif //

/*<<<
    // wyc2.15-909S, support watch dog.
#ifdef ERROR_CONCEAL
#ifdef SUPPORT_WATCH_DOG
    if (HAL_WatchDog_Status())
        HAL_WatchDog_Reset();
#endif //
#endif //
>>>*/
}

#ifdef CT950_STYLE
void MONITOR_ResetAV(DWORD dwStreamId)
{
    DWORD dwTimer;

    switch (dwStreamId)
    {
    case 0:
        HALJPEG_Reset();
        break;
    case 1:
        HAL_Reset(HAL_RESET_AUDIO);
        HAL_WriteAM(HAL_AM_PLAY_COMMAND, 0);
        PARSER_BufferReset(PARSER_ES_AUDIO);
        break;
    }

    PARSER_Command(dwStreamId, PARSER_CMD_STOP, 0);

    dwTimer = OS_GetSysTimer();
    while((OS_GetSysTimer() - dwTimer) < COUNT_50_MSEC)
    {
        if (PARSER_QueryEvent(dwStreamId, PARSER_EVENT_COMPLETED, FALSE))
            break;

        OS_YieldThread();
    }

    SrcFilter_Stop(dwStreamId);

    return;
}
#endif

//  *************************************************************************
//  Function    :   MONITOR_RecoverSystem
//  Description :   This function is called by CC and purpose is to recover 
//                  system to normal state. There are several stages to recover  
//                  system in this function. 
//  Arguments   :   None
//  Return      :   None
//  Side Effect :
//  *************************************************************************
void MONITOR_RecoverSystem(void)
{
#ifdef ERROR_CONCEAL

    extern void _MM_JPEGChangeToNext(void);
    extern void MM_PhotoMusicErrorConcealment(void);

    if (__btPlaying)
    {
#ifdef SUPPORT_STB
        if( __bChooseMedia == MEDIA_SELECT_STB)
        {
            _MONITOR_DVBRecover();
        }
        else
#endif
        {
#ifdef CT950_STYLE
            if (_bAudioReset)
            {
                PRINTF("Recovering Audio ...\n");
                _bAudioReset = FALSE;

                if (__bMMJPEGAudioMode)
                {
                    MONITOR_ResetAV(1);
                }
                else
                {
                    HAL_Reset(HAL_RESET_AUDIO);
                    __bFWKey = KEY_NEXT;
                }
                OS_REORDER_BARRIER();
                _bAudioResetOK = TRUE;
            }

            if (_bVideoReset)
            {
                PRINTF("Recovering Video ...\n");
                _bVideoReset = FALSE;

                if (__bMMJPEGAudioMode)
                    MONITOR_ResetAV(0);
                else
                    _MM_JPEGChangeToNext();

                OS_REORDER_BARRIER();
                _bVideoResetOK = TRUE;
            }

            if (_bAllReset)
            {
                PRINTF("Recovering System ...\n");
                _bAllReset = FALSE;
                MM_PhotoMusicErrorConcealment();
                OS_REORDER_BARRIER();
                _bAllResetOK = TRUE;
            }


#else // !CT950_STYLE
            if (__bModePlay == MODE_PLAYAUDIO)
                _MONITOR_AudioRecover();
            else if (__bModePlay == MODE_PLAYVIDEO)
                _MONITOR_ImageRecover();
            else
                _MONITOR_MotionRecover();
#endif // CT950_STYLE
        }
    }
#endif 
    // elmer2.32
#ifdef SUPPORT_NO_AUDIO_IO_MUTE
    if ((OS_GetSysTimer() - _dwMONChkTime) >= COUNT_100_MSEC)
    {
        MONITOR_CheckMute();
        _dwMONChkTime = OS_GetSysTimer();
    }
#endif
}

#ifdef SUPPORT_STB
void _MONITOR_DVBRecover(void)
{
#ifdef ERROR_CONCEAL
    DWORD dwTimeStart;
    DWORD dwVRem, dwARem;
    if( _dwInterFailCnt > 0 && ((OS_GetSysTimer() - _dwDVBMONChkTime) >= COUNT_1_SEC) )
    {
        _dwDVBMONChkTime = OS_GetSysTimer();
        if ( _dwInterFailCnt > 12 )
        {
            __bTVHang = TRUE;
        }
        _dwInterFailCnt = 0;
    }

    if(__bTVHang || __bRadioHang)
    {
        DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nTV or Radio Recover!");        
        HAL_WriteAM(HAL_AM_PLAY_COMMAND, 0);
        HAL_ResetAudioDecoder();
        if(__bTVHang)
        {
            {
            extern BYTE    _Wait_Decoder_Stop_CMD_ACK(void);
            COMDEC_Command(MODE_STOP, 0);
            _Wait_Decoder_Stop_CMD_ACK();            
            }
        }
        
        DVB_AVDemuxDisable();
        DVB_AVDemuxEnable();
        dwTimeStart = OS_GetSysTimer();
        while( (OS_GetSysTimer() - dwTimeStart) < COUNT_100_MSEC)
        {
            HAL_ReadInfo(HAL_INFO_VIDEO_REMAIN, &dwVRem);
            HAL_ReadInfo(HAL_INFO_AUDIO_REMAIN, &dwARem);
            if(dwVRem!=0 || dwARem!=0)
            {
                DVB_AudioVideoPlay();        
                break;
            }     
            OS_YieldThread();
        }

        __bTVHang = FALSE;
        __bRadioHang = FALSE;    
        _dwInterFailCnt = 0;
    }
    
#endif
}
#endif

void _MONITOR_AudioRecover(void)
{
#ifdef ERROR_CONCEAL
    switch (__dwMONRecoverStage)
    {
        case    RECOVER_STAGE_PREPARE:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S Prepare!");
            _dwMONFailCounter = 0;
            _dwMONOKCounter = 0;
            _dwMONParTotCnt = 0;
            _dwMONRecoverCnt = MONITOR_RETRY_COUNT;
            _dwMONGoNextStage = FALSE;
            _MONITOR_ReadAudioRem(&_dwMONPreARemain);
            _dwMONParReadSec = __SF_SourceGBL[__dwSFStreamID].dwReadSector;
            //HAL_ReadAM(HAL_AM_FRAME_SAMPLE_SEC_CNT, &_dwMONPreAFrmCnt);
            _dwMONNextStage = RECOVER_STAGE_SW_RESET;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_IDLE:
            if (_dwMONGoNextStage == TRUE)
            {
                __dwMONRecoverStage = _dwMONNextStage;
                _dwMONGoNextStage = FALSE;
                _dwMONFailCounter = 0;
                _dwMONOKCounter = 0;
            }
            break;
        case    RECOVER_STAGE_SW_RESET:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S S/W Reset Audio!");
            HAL_Reset(HAL_RESET_AUDIO);
            HAL_WriteAM(HAL_AM_PLAY_COMMAND, 1);
            _dwMONRecoverCnt--;
            if (_dwMONRecoverCnt == 0)
            {
                _dwMONRecoverCnt = MONITOR_RETRY_COUNT;
                // When read / write sector is same and not reach end sector, mean SERVO don't read data any more and just issue JUMP sector to read another position data.
                if (1)//(__SF_SourceGBL[0].dwWriteSector == __SF_SourceGBL[0].dwReadSector) && (__SF_SourceGBL[0].dwWriteSector <= __SF_SourceGBL[0].dwEndSector))
                    _dwMONNextStage = RECOVER_STAGE_JUMP_SECTOR;
                else
                    _dwMONNextStage = RECOVER_STAGE_HW_RESET;
            }
            else
                _dwMONNextStage = RECOVER_STAGE_SW_RESET;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_JUMP_SECTOR:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S Jump Sectors!");
            // wyc2.53-909P,
            SrcFilter_Stop(__dwSFStreamID);            
            HAL_ControlParser(HAL_PARSER_STOP, 0);
            CHIPS_SoftMute();
            
            HAL_Reset(HAL_RESET_AUDIO);              

            HAL_WriteAM(HAL_AM_PLAY_COMMAND, 1);      

            CHIPS_OpenAudio(TRUE);
            if (__wDiscType & BOOK_CDDA)
            {
                // LLY2.35, give start and end time for UTL_PlayFromTime() since the API is updated
                UTL_PlayFromTime(__dwTimeNow+20*(MONITOR_RETRY_COUNT+1-_dwMONRecoverCnt), __dwTimeEnd);
            }
            else
            {
                HAL_ReadAM(HAL_AM_BIT_RATE, &_dwMONTemp1);
                // LLY2.35, give start and end time for UTL_PlayFromTime() since the API is updated
                UTL_PlayFromTime(__dwTimeNow+(((10*_dwMONTemp1*1000)/(2048*8))*(MONITOR_RETRY_COUNT+1-_dwMONRecoverCnt)), __dwTimeEnd);
            }
            _dwMONRecoverCnt--;
            if (_dwMONRecoverCnt == 0)
            {
                _dwMONRecoverCnt = MONITOR_RETRY_COUNT;
                _dwMONNextStage = RECOVER_STAGE_HW_RESET;
            }
            else
                _dwMONNextStage = RECOVER_STAGE_JUMP_SECTOR;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_HW_RESET:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S H/W Reset!");
            _dwMONNextStage = RECOVER_STAGE_RESET_SERVO;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_RESET_SERVO:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S Reset Servo!");
            SrcFilter_Reset(TRUE);
            HAL_ControlParser(HAL_PARSER_STOP, 0);
            PARSER_Command(0, PARSER_CMD_START, 0);
            _dwMONNextStage = RECOVER_STAGE_NEXT_ITEM;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_NEXT_ITEM:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S Next Item!");
            __bFWKey = KEY_NEXT;
            // elmer2.36
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
    }
#endif //
}

void _MONITOR_ImageRecover(void)
{
#ifdef ERROR_CONCEAL

#endif //
}

void _MONITOR_MotionRecover(void)
{
#ifdef ERROR_CONCEAL
    switch (__dwMONRecoverStage)
    {
        case    RECOVER_STAGE_PREPARE:
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_MM_INFOFTR,"\nR_S Prepare!");
            _dwMONFailCounter = 0;
            _dwMONOKCounter = 0;
            _dwMONParTotCnt= 0;
            _dwMONMDecHangCnt = 0;
            _dwMONMDecChkHang = 0;
            _dwMONRecoverCnt = MONITOR_RETRY_COUNT;
            _dwMONGoNextStage = FALSE;
            __dwMONJumpTime = 0;
            __dwMONPreJumpTime = 0xFFFFFFFF;
            _dwMONJumpChkTime = 0;
            _MONITOR_ReadAudioRem(&_dwMONPreARemain);
            // _dwMONPreVRemain = ( (REG_MCU_VREM+1) &0xffffff )*2;
            _dwMONPreVRemain = MCU_VIDEO_BS_BUF_REMAINDER / 4;
            _dwMONParReadSec = __SF_SourceGBL[__dwSFStreamID].dwReadSector;
            _dwMONNextStage = RECOVER_STAGE_SW_RESET;
            __dwMONRecoverStage = RECOVER_STAGE_IDLE;
            break;
        case    RECOVER_STAGE_IDLE:
            if (_dwMONGoNextStage == TRUE)
            {
                __dwMONRecoverStage = _dwMONNextStage;
                _dwMONGoNextStage = FALSE;
                _dwMONFailCounter = 0;
                _dwMONOKCounter = 0;
            }

            break;
        case    RECOVER_STAGE_SW_RESET:
            // wyc2.60-909P, make it default printf.
            DBG_Printf(DBG_THREAD_MONITOR, DBG_INFO_ASSERTION,"\nR_S S/W Reset A/V!");
            HAL_Reset(HAL_RESET_AUDIO);
            HAL_WriteAM(HAL_AM_PLAY_COMMAND, 1);
            HAL_Reset(HAL_RESET_SPST);

            /*COMDEC_Command(MODE_STOP, 0);
            _dwMONTemp2 = UTL_GetSysTimer();