INT32 UIFlowWndPlay_OnKeyPlayback(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    switch(g_PlbData.State)
    {
        case PLB_ST_FULL:
            // Set mask key
            Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
            Input_SetKeyMask(KEY_PRESS, PLAY_KEY_PRESS_MASK);
            Input_SetKeyMask(KEY_RELEASE, PLAY_KEY_RELEASE_MASK);
            Input_SetKeyMask(KEY_CONTINUE, PLAY_KEY_CONTINUE_MASK);

            Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_NEXT);
            break;

        case PLB_ST_PLAY_MOV:
        case PLB_ST_PAUSE_MOV:
        case PLB_ST_FWD_MOV:
        case PLB_ST_BWD_MOV:
            g_PlbData.State        = PLB_ST_FULL;
            g_PlbData.VideoPBSpeed = PLB_FWD_MOV_1x;
            UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
            g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

            Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
            Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_CLOSE_PLAY_MOVIE, 0);

            //#NT#2012/10/23#Philex Lin - begin
            // enable auto power off/USB detect timer
            // enable key tone flag
            KeyScan_EnableMisc(TRUE);
            //#NT#2012/10/23#Philex Lin - end

            if (gphUIFlowMovPlay_Filehdl)
            {
                FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
                gphUIFlowMovPlay_Filehdl = NULL;
            }
            FlowPB_UpdateIcons(1);
            break;

    }

    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnClose(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    UINT32  uiSoundMask;

    switch(g_PlbData.State)
    {
        case PLB_ST_FULL:
            break;

        case PLB_ST_PLAY_MOV:
        case PLB_ST_PAUSE_MOV:
        case PLB_ST_FWD_MOV:
        case PLB_ST_BWD_MOV:
            g_PlbData.State        = PLB_ST_FULL;
            g_PlbData.VideoPBSpeed = PLB_FWD_MOV_1x;
            UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
            g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

            Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
            Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_CLOSE_PLAY_MOVIE, 0);

            if (gphUIFlowMovPlay_Filehdl)
            {
                FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
                gphUIFlowMovPlay_Filehdl = NULL;
            }
            break;
    }

    // disable shutter2 sound
    uiSoundMask = Input_GetKeySoundMask(KEY_PRESS);
    uiSoundMask &= ~FLGKEY_SHUTTER2;
    Input_SetKeySoundMask(KEY_PRESS, uiSoundMask);

    //#NT#2012/10/23#Philex Lin - begin
    // enable auto power off/USB detect timer
    // enable sound key tone
    KeyScan_EnableMisc(TRUE);
    //#NT#2012/10/23#Philex Lin - end
    //g_PlbData.VideoPBSpeed=PLB_FWD_MOV_1x;
    Ux_DefaultEvent(pCtrl,NVTEVT_CLOSE_WINDOW,paramNum,paramArray);
    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnMovieFinish(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    //#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
    g_PlbData.State        = PLB_ST_FULL;
    g_PlbData.VideoPBSpeed = PLB_FWD_MOV_1x;
    UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
    g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

    Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
    Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_CLOSE_PLAY_MOVIE, 0);

    //#NT#2012/10/23#Philex Lin - begin
    // enable auto power off/USB detect timer
    // enable key tone flag
    KeyScan_EnableMisc(TRUE);
    //#NT#2012/10/23#Philex Lin - end

    // stop scan
    //if (SxTimer_GetFuncActive(SX_TIMER_DET_STRG_ID)==0)
//        SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, TRUE);

    if (SxTimer_GetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID)==0)
        SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, TRUE);


    if (gphUIFlowMovPlay_Filehdl)
    {
        FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
        gphUIFlowMovPlay_Filehdl = NULL;
    }

    // Play 1st video frame image
    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 1, PB_SINGLE_CURR);
    //#NT#2012/08/31#Calvin Chang -end

    FlowPB_UpdateIcons(1);

    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyEnter(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    //#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
    //UINT32 uiCurindex;
    UINT32 uiPoolAddr;
    char   pFilePath[FULL_FILE_PATH_LEN];
    UINT32 fileType = DCF_FILE_TYPE_JPG;
    UINT32 uiPBFileFmt;

    switch(g_PlbData.State)
    {
        case PLB_ST_PLAY_MOV:
        case PLB_ST_FWD_MOV:
        case PLB_ST_BWD_MOV:
            Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
            FlowPB_IconDrawMovPlay(TRUE);
            g_PlbData.State = PLB_ST_PAUSE_MOV;
            //#NT#2012/10/23#Philex Lin - begin
            // enable auto power off/USB detect timer
            // enable sound key tone flag
            KeyScan_EnableMisc(TRUE);
            //#NT#2012/10/23#Philex Lin - end
            break;

        case PLB_ST_PAUSE_MOV:
            //#NT#2012/10/23#Philex Lin - begin
            // disable auto power off/USB detect timer
            // disable key tone flag
            KeyScan_EnableMisc(FALSE);
            //#NT#2012/10/23#Philex Lin - end
            // Start to Play
            Ux_SendEvent(&UIMoviePlayObjCtrl,
                         NVTEVT_PLAY_PLAY_MOVIE,
                         2,
                         g_uiUIFlowWndPlayCurrenSpeed,
                         g_uiUIFlowWndPlayCurrenDirection);
            FlowPB_IconDrawMovPlay(TRUE);
            g_PlbData.State = PLB_ST_PLAY_MOV;
            break;

        default:
        case PLB_ST_FULL:
            uiPBFileFmt = AppPlay_GetData(PLAY_FILEFMT);
            if (uiPBFileFmt & PBFMT_AVI ||
                uiPBFileFmt & PBFMT_MOVMJPG ||
                uiPBFileFmt & PBFMT_MP4)
            {
                // Open Video File
                if (gphUIFlowMovPlay_Filehdl)
                {
                    FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
                    gphUIFlowMovPlay_Filehdl = NULL;
                }
                if (uiPBFileFmt & PBFMT_AVI)
                  fileType = DCF_FILE_TYPE_AVI;
                else if (uiPBFileFmt & PBFMT_MOVMJPG)
                  fileType = DCF_FILE_TYPE_MOV;
                else if (uiPBFileFmt & PBFMT_MP4)
                  fileType = DCF_FILE_TYPE_MOV;
                else
                {
                    debug_msg("Wrong video file format!! \r\n");
                    break;
                }

                // Get Current index
                PB_GetParam(PBPRMID_CURR_FILEPATH, (UINT32 *)pFilePath);
#if 0
                uiCurindex = DCF_GetCurIndex();
                DCF_GetObjPath(uiCurindex,fileType,pFilePath);
#endif
                // Open Test Media File
                gphUIFlowMovPlay_Filehdl = FileSys_OpenFile(pFilePath, FST_OPEN_READ);

                if (!gphUIFlowMovPlay_Filehdl)
                {
                    debug_msg("UIFlowWndPlay_OnKeyEnter: Can't open Video file!\r\n");
                    break;
                }
                //#NT#2012/10/23#Philex Lin - begin
                // disable auto power off/USB detect timer
                // disable key tone flag
                KeyScan_EnableMisc(FALSE);
                //#NT#2012/10/23#Philex Lin - end

                // Buffer Allocation
                get_blf((VP*)&(uiPoolAddr), POOL_ID_APP);
                rel_blf(POOL_ID_APP, (VP)uiPoolAddr);

                g_UIPlayMediaObj.hActMediafilehdl = gphUIFlowMovPlay_Filehdl;
                g_UIPlayMediaObj.CallBackFunc     = Play_MovieCB;
//                g_UIPlayMediaObj.uiMemAddr        = uiPoolAddr;
                g_UIPlayMediaObj.uiMemAddr        = (UINT32)OS_GetMempoolAddr(POOL_ID_APP);
                g_UIPlayMediaObj.uiMemSize        = POOL_SIZE_APP;
                //g_UIPlayMediaObj.iAudioType       = AUDIO_OUTPUT_HP;
                g_UIPlayMediaObj.bDisableAudio    = FALSE;

                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

                //flush event first
                Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);

                //stop scan
                //SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, FALSE);
                SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, FALSE);

                Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_INIT_PLAY_MOVIE, 1, &g_UIPlayMediaObj);

                // Start to Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);

                if (KeyScan_GetPlugDev()!=PLUG_HDMI)
                {
                    //FlowPB_IconDrawMovPlayVolumn(g_uiUIFlowWndPlayCurrentVolume);
                }
                FlowPB_IconDrawMovPlay(TRUE);
                g_PlbData.State = PLB_ST_PLAY_MOV;

            }
            break;
    }
    //#NT#2012/08/31#Calvin Chang -end

    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyMenu(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    switch(g_PlbData.State)
    {
    case PLB_ST_FULL:
        g_PlbData.State = PLB_ST_MENU;
        Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
        // Reset specific menu items
        SysSetFlag(FL_PROTECT, PROTECT_ONE);
        // Set Tab menu to Playback menu
        TM_SetMenu(&gPlaybackMenu);
        // Open common item menu
        Ux_OpenWindow(&MenuCommonItemCtrl, 0);
        break;
#if(_MODEL_DSC_== _MODEL_DUAL_NAZHIDA_)
    case PLB_ST_PLAY_MOV:
    case PLB_ST_FWD_MOV:
    case PLB_ST_BWD_MOV:
	//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
	g_PlbData.State        = PLB_ST_FULL;
	g_PlbData.VideoPBSpeed = PLB_FWD_MOV_1x;
	UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
	g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

	Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
	Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_CLOSE_PLAY_MOVIE, 0);

	//#NT#2012/10/23#Philex Lin - begin
	// enable auto power off/USB detect timer
	// enable key tone flag
	KeyScan_EnableMisc(TRUE);
	//#NT#2012/10/23#Philex Lin - end

	// stop scan
	//if (SxTimer_GetFuncActive(SX_TIMER_DET_STRG_ID)==0)
	//        SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, TRUE);

	if (SxTimer_GetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID)==0)
	SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, TRUE);


	if (gphUIFlowMovPlay_Filehdl)
	{
	FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
	gphUIFlowMovPlay_Filehdl = NULL;
	}

	// Play 1st video frame image
	Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 1, PB_SINGLE_CURR);
	//#NT#2012/08/31#Calvin Chang -end
	g_PlbData.State = PLB_ST_MENU;
	Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
	// Reset specific menu items
	SysSetFlag(FL_PROTECT, PROTECT_ONE);
	// Set Tab menu to Playback menu
	TM_SetMenu(&gPlaybackMenu);
	// Open common item menu
	Ux_OpenWindow(&MenuCommonItemCtrl, 0);			
       break;		
#endif		
    }
    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyRight(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    switch(g_PlbData.State)
    {
        case PLB_ST_FULL:
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
            Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_NEXT, 1);
            FlowPB_UpdateIcons(1);
            UIFlowWndPlay_CheckStatus();
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
            break;
        case PLB_ST_PLAY_MOV:
        case PLB_ST_FWD_MOV:
        case PLB_ST_BWD_MOV:
#if(_MODEL_DSC_== _MODEL_DUAL_NAZHIDA_)		
        //#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
        if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_8x)
        {
            g_PlbData.VideoPBSpeed --;

            Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);


            if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
            {
                g_PlbData.State = PLB_ST_FWD_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);
            }
            else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
            {
                g_PlbData.State = PLB_ST_BWD_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;

                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);

            }
            else   //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
            {
                g_PlbData.State = PLB_ST_PLAY_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);
            }

            FlowPB_IconDrawMovSpeed();
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
        }
            break;		
#else		
            //#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
            if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
            {
                g_PlbData.VideoPBSpeed ++;

                Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
                Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);

                if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
                {
                    g_PlbData.State = PLB_ST_FWD_MOV;
                    UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                    g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

                    // Play
                    Ux_SendEvent(&UIMoviePlayObjCtrl,
                                 NVTEVT_PLAY_PLAY_MOVIE,
                                 2,
                                 g_uiUIFlowWndPlayCurrenSpeed,
                                 g_uiUIFlowWndPlayCurrenDirection);
                }
                else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
                {
                    g_PlbData.State = PLB_ST_BWD_MOV;
                    UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                    g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;

                    // Play
                    Ux_SendEvent(&UIMoviePlayObjCtrl,
                                 NVTEVT_PLAY_PLAY_MOVIE,
                                 2,
                                 g_uiUIFlowWndPlayCurrenSpeed,
                                 g_uiUIFlowWndPlayCurrenDirection);

                }
                else   //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
                {
                    g_PlbData.State = PLB_ST_PLAY_MOV;
                    UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                    g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;

                    // Play
                    Ux_SendEvent(&UIMoviePlayObjCtrl,
                                 NVTEVT_PLAY_PLAY_MOVIE,
                                 2,
                                 g_uiUIFlowWndPlayCurrenSpeed,
                                 g_uiUIFlowWndPlayCurrenDirection);
                }
                FlowPB_IconDrawMovSpeed();
                Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
            }
            break;
            //#NT#2012/08/31#Calvin Chang -end
#endif            
//#NT#2012/7/6#Philex mark temp
#if 0
        if (KeyScan_IsHDMIPlugIn()==FALSE) {
            if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
            {
                g_PlbData.VideoPBSpeed ++;

                Ux_FlushEvent();
                KeyScan_SetKeyMask(KEYSCAN_KEYMODE_PRESS, FLGKEY_KEY_MASK_NULL);

                if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWD,1,g_PlbData.VideoPBSpeed);
                    g_PlbData.State = PLB_ST_FWD_MOV;
                    // set mute in FWD playing
                    hdmitx_setAudMute(TRUE);
                }
                else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVBWD,1,g_PlbData.VideoPBSpeed);
                    g_PlbData.State = PLB_ST_BWD_MOV;
                    // set mute in BWD playing
                    hdmitx_setAudMute(TRUE);
                }
                else   //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWDSTOP,0);
                    g_PlbData.State = PLB_ST_PLAY_MOV;
                    /* Since Media FWD/BWD will set volume mute, we should restore current volume. */
                    hdmitx_setAudMute(FALSE);
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_AUD_VOLUME,1,g_uiUIFlowWndPlayCurrentVolume);
                }

                FlowPB_IconDrawMovSpeed();
                KeyScan_SetKeyMask(KEYSCAN_KEYMODE_PRESS, FLGKEY_KEY_MASK_DEFAULT);
            }
        }
        break;
#endif

    }
    return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyLeft(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
    switch(g_PlbData.State)
    {
    case PLB_ST_FULL:
        Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
        Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_PREV, 1);
        FlowPB_UpdateIcons(1);
        UIFlowWndPlay_CheckStatus();
        Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
        break;
    case PLB_ST_PLAY_MOV:
    case PLB_ST_FWD_MOV:
    case PLB_ST_BWD_MOV:
        //#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
        //if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_8x)
        if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_4x)
        {
            g_PlbData.VideoPBSpeed --;

            Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);


            if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
            {
                g_PlbData.State = PLB_ST_FWD_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
				
                UxState_SetData(&UIFlowWndPlay_StatusICN_MovFwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovFwd_ICON_FF_RIGHT_BLUE);
                UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovFwdCtrl, TRUE);
                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);
            }
            else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
            {
                g_PlbData.State = PLB_ST_BWD_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;

                 UxState_SetData(&UIFlowWndPlay_StatusICN_MovBwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovBwd_ICON_FB_LEFT_BLUE);
                UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovBwdCtrl, TRUE);
				
                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);

            }
            else   //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
            {
                g_PlbData.State = PLB_ST_PLAY_MOV;
                UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
                g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
                 UxState_SetData(&UIFlowWndPlay_StatusICN_MovBwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovBwd_ICON_FB_LEFT);
                UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovBwdCtrl, TRUE);

                UxState_SetData(&UIFlowWndPlay_StatusICN_MovFwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovFwd_ICON_FF_RIGHT);
                UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovFwdCtrl, TRUE);
                // Play
                Ux_SendEvent(&UIMoviePlayObjCtrl,
                             NVTEVT_PLAY_PLAY_MOVIE,
                             2,
                             g_uiUIFlowWndPlayCurrenSpeed,
                             g_uiUIFlowWndPlayCurrenDirection);
            }

            FlowPB_IconDrawMovSpeed();
            Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
        }
        //#NT#2012/08/31#Calvin Chang -end
#if 0
        if (KeyScan_IsHDMIPlugIn()==FALSE) {
            if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
            {
                g_PlbData.VideoPBSpeed ++;

                Ux_FlushEvent();
                Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);

                if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWD,1,g_PlbData.VideoPBSpeed);
                    g_PlbData.State = PLB_ST_FWD_MOV;
                    // set mute in FWD playing
                    hdmitx_setAudMute(TRUE);
                }
                else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVBWD,1,g_PlbData.VideoPBSpeed);
                    g_PlbData.State = PLB_ST_BWD_MOV;
                    // set mute in BWD playing
                    hdmitx_setAudMute(TRUE);
                }
                else   //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
                {
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWDSTOP,0);
                    g_PlbData.State = PLB_ST_PLAY_MOV;
                    /* Since Media FWD/BWD will set volume mute, we should restore current volume. */
                    hdmitx_setAudMute(FALSE);
                    Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_AUD_VOLUME,1,g_uiUIFlowWndPlayCurrentVolume);
                }

                FlowPB_IconDrawMovSpeed();
                Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
            }
        }
#endif
        break;
    }
    return NVTEVT_CONSUME;
}