drvmvd.c

mstar 776 开发的车载dvd

        MVD_DEBUGERROR( printf( "Ctrl: MVD_I_GET_PICTURE_SIZE fail!!\r\n" ) );
        return;
    }
    pinfo->u16HorSize = COMBWORD(mvdcmd.Arg1, mvdcmd.Arg0);
    pinfo->u16VerSize = COMBWORD(mvdcmd.Arg3, mvdcmd.Arg2);


    mvdcmd.Arg0 = 0;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_ASPECT_FRAMERATE, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: MVD_I_ASPECT_FRAMERATE fail!!\r\n" ) );
        return;
    }

    pinfo->u8AspectRatio = mvdcmd.Arg0 >> 4;
    pinfo->u16FrameRate = (U16)(mvdcmd.Arg0 & 0x0F);
}

/********************************************************************************/
/// Get MVD first frame decode status
/// @return -first frame decoded ready or not
/********************************************************************************/
U8 MDrv_Mvd_GetFirstFrame ( void )
{
    MVD_CMD_ARG mvdcmd;
    mvdcmd.Arg0 = FIRST_FRAME;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: FIRST_FRAME fail!!\r\n" ) );
        return 0xFF;
    }
    return mvdcmd.Arg2;
}



/********************************************************************************/
/// Get video progressive or interlace
/// @return -video progressive or interlace
/********************************************************************************/
U8 MDrv_Mvd_GetProgInt ( void )
{
    MVD_CMD_ARG mvdcmd;
    mvdcmd.Arg0 = PROG_SEQ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: PROG_SEQ fail!!\r\n" ) );
        return 0xFF;
    }
    return mvdcmd.Arg2;
}


#ifdef MHEG_RDY

//#if ( KEEP_UNUSED_FUNC == 1 )

/********************************************************************************/
/// Reset for I-frame decoding
/// @return -none
/********************************************************************************/

void MDrv_Mvd_ResetIFrameDecode ( void )
    {
    XBYTE[MVD_COMMAND] = MVD_STOP;   // issue stop command to clear previous command
    MDrv_Mvd_MVDReset();
}

/********************************************************************************/
/// Decode I-frame
/// @param -u32FrameBufAddr \b IN : start address of frame buffer
/// @param -u32StreamBufAddr \b IN : start address of stream buffer
/// @return -return decode I-frame success or not
/********************************************************************************/

BOOLEAN MDrv_Mvd_DecodeIFrame ( U32 u32FrameBufAddr, U32 u32StreamBufAddr )
{
    U32 u32deley_ms;
    MVD_CMD_ARG mvdcmd;

    // set frame buffer address
    #if VIDEO_FIRMWARE_CODE >= VIDEO_FIRMWARE_CODE_HD
        ASSERT((u32FrameBufAddr%2048)==0);
        u32FrameBufAddr >>= ( 3 + 8 );
    #else
        ASSERT((u32FrameBufAddr%512)==0);
	    u32FrameBufAddr >>= ( 3 + 6 );
    #endif
    mvdcmd.Arg0 = L_WORD(u32FrameBufAddr);
    mvdcmd.Arg1 = H_WORD(u32FrameBufAddr);
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_MHEG_SET_FRAMEBUF, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Command: 0x%bx fail!!\r\n", MVD_I_MHEG_SET_FRAMEBUF ) );
        return FALSE;
    }

    // set stream buffer address & start decode
    ASSERT((u32StreamBufAddr%8)==0);
    u32StreamBufAddr >>= 3;
    mvdcmd.Arg0 = L_WORD(u32StreamBufAddr);
    mvdcmd.Arg1 = H_WORD(u32StreamBufAddr);
    mvdcmd.Arg2 = L_DWORD(u32StreamBufAddr);
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_MHEG_DECODE_IFRAME, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Command: 0x%bx fail!!\r\n", MVD_I_MHEG_DECODE_IFRAME ) );
        return FALSE;
    }

    // wait decode complete
    u32deley_ms = MDrv_Timer_GetTime0();
    do
    {
        mvdcmd.Arg0 = MHEG_RDY;
        mvdcmd.Arg1 = 0;
        mvdcmd.Arg2 = 0;
        mvdcmd.Arg3 = 0;

        if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
        {
            MVD_DEBUGERROR( printf( "Command: MHEG_RDY fail!!\r\n" ) );
            return FALSE;
        }

        if (MDrv_Timer_TimeDifferenceFromCurrent(u32deley_ms) > 2500) {
            MVD_DEBUGERROR( printf( "MDrv_Mvd_DecodeIFrame time out\n" ) );
            return FALSE;
        }
    }
    while(mvdcmd.Arg2 != 1);

    return TRUE;
}
#endif

//#endif

//#if ( KEEP_UNUSED_FUNC == 1 )
/********************************************************************************/
/// Set mvd play mode
/// @return -none
/********************************************************************************/
void MDrv_Mvd_SetPlayMode(U8 bFileMode, U8 bDisablePESParsing)
{
    u8MvdPlayMode = (U8)((bFileMode?1:0)<<2) | (U8)((bDisablePESParsing?1:0)<<3);
}

/********************************************************************************/
/// Set bitstream buffer overflow threshold
/// @return -none
/********************************************************************************/
void MDrv_Mvd_SetOverflowTH (U32 u32Threshold)
{
    MVD_CMD_ARG mvdcmd;
    ASSERT((u32Threshold%8)==0);
    u32Threshold >>= 3;
    mvdcmd.Arg0 = L_WORD(u32Threshold);
    mvdcmd.Arg1 = H_WORD(u32Threshold);
    mvdcmd.Arg2 = L_DWORD(u32Threshold);
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_SET_BS_OVERFLOWTH, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Command: 0x%bx fail!!\r\n", MVD_I_SET_BS_OVERFLOWTH ) );
        return;
    }
}

/********************************************************************************/
/// Set bitstream buffer underflow threshold
/// @return -none
/********************************************************************************/
void MDrv_Mvd_SetUnderflowTH (U32 u32Threshold)
{
    MVD_CMD_ARG mvdcmd;
    ASSERT((u32Threshold%8)==0);
    u32Threshold >>= 3;
    mvdcmd.Arg0 = L_WORD(u32Threshold);
    mvdcmd.Arg1 = H_WORD(u32Threshold);
    mvdcmd.Arg2 = L_DWORD(u32Threshold);
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_SET_BS_UNDERFLOWTH, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Command: 0x%bx fail!!\r\n", MVD_I_SET_BS_UNDERFLOWTH ) );
        return;
    }
}

U8 MDrv_Mvd_GetActiveFormat()
{
#ifdef ACTIVE_FORMAT
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = ACTIVE_FORMAT ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", ACTIVE_FORMAT  ) );
        return 0xff;
    }
    return mvdcmd.Arg2;
#else
    return 0xff;
#endif
}

//#endif //#if ( KEEP_UNUSED_FUNC == 1 )

/********************************************************************************/
/// Get sync status to know whether sync is complete or not
/// @return - 0        : sync complete
////        - otherwise: sync not complete
/********************************************************************************/
U8 MDrv_Mvd_GetSyncStatus ()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = SYN_INI_DONE ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", SYN_INI_DONE  ) );
        return 0xff;
    }
    MVD_DEBUGINFO(printf("SYN_INI_DONE=%bx\n", mvdcmd.Arg2));
    return mvdcmd.Arg2;
    }

U8 MDrv_Mvd_GetDispRdy()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = FIRST_PIC ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", FIRST_PIC  ) );
        return 0xff;
    }
    return mvdcmd.Arg2;
    }

void MDrv_Mvd_SetVOPDone()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = VOP_INI_DONE ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 1;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( 0x41, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", VOP_INI_DONE  ) );
        return;
    }
}

U8 MDrv_Mvd_I_PIC_Found()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = I_PIC_FOUND ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", I_PIC_FOUND  ) );
        return 0xff;
    }
    return mvdcmd.Arg2;
}

//#if ( ENABLE_DTV_FREEZE_WEAK_SIGNAL == ENABLE )
U16 MDrv_Mvd_GetDecodeErrCnt()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = VLD_ERR_CNT ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( MVD_I_COMMAND_CTRL, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", VLD_ERR_CNT  ) );
        return 0xffff;
    }
    return COMBWORD(mvdcmd.Arg3, mvdcmd.Arg2);
}

void MDrv_Mvd_ResetDecodeErrCnt()
{
    MVD_CMD_ARG mvdcmd;

    mvdcmd.Arg0 = VLD_ERR_CNT ;
    mvdcmd.Arg1 = 0;
    mvdcmd.Arg2 = 0;
    mvdcmd.Arg3 = 0;

    if (MDrv_Mvd_MVDCommand( 0x41, &mvdcmd ) == FALSE)
    {
        MVD_DEBUGERROR( printf( "Ctrl: 0x%bx fail!!\r\n", VLD_ERR_CNT  ) );
    }
}
//#endif

//#if BUILD_SYSDEBUG
/********************************************************************************/
/// MVD test function (debug use only )
/// @param -OneShot \b IN : one shot decode flag
/********************************************************************************/
void MDrv_Mvd_Polling ( U8 OneShot )
{
#ifdef SHOW_SYN
    U32 u32Diff,
    u32Pts1 = 0,
    u32Pts2,
    u32Stc1 = 0,
    u32Stc2,
    u32Time1 = 0,
    u32Time2;

    while ( 1 )
    {
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SHOW_SYN timeout0\n" ) );
        }

        XBYTE[MVD_ARG0] = SHOW_SYN;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_ARG2] = 0x01;
        XBYTE[MVD_ARG3] = 0x00;
        XBYTE[MVD_COMMAND] = 0x41;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SHOW_SYN timeout1\n" ) );
        }

        while ( 1 )
        {
            XBYTE[MVD_ARG0] = SHOW_SYN;
            XBYTE[MVD_ARG1] = 0x00;
            XBYTE[MVD_COMMAND] = 0x40;
            if ( MVD_TimeOut() )
            {
                MVD_DEBUGERROR( printf( "SHOW_SYN timeout2\n" ) );
            }
            if ( ( XBYTE[MVD_ARG2] == 0 ) && ( XBYTE[MVD_ARG3] == 0 ) )
            {
                break;
            }
            if ( kbhit() )
            {
                if ( getchar() == 'q' )
                {
                    return;
                }
            }
            MDrv_Timer_Delayms( 1 );
        }

        //diff ==============================
        XBYTE[MVD_ARG0] = SYN_DIFF1;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SYN_DIFF1 timeout\n" ) );
        }
        u32Diff = XBYTE[MVD_ARG3];
        u32Diff = u32Diff << 8;
        u32Diff |= XBYTE[MVD_ARG2];
        u32Diff = u32Diff << 8;

        XBYTE[MVD_ARG0] = SYN_DIFF0;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SYN_DIFF0 timeout\n" ) );
        }
        u32Diff |= XBYTE[MVD_ARG3];
        u32Diff = u32Diff << 8;
        u32Diff |= XBYTE[MVD_ARG2];

        MVD_DEBUGINFO( printf( "diff= 0x%08lx | ", u32Diff ) );

        //pts ==================================
        XBYTE[MVD_ARG0] = PTS1_1;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "PTS1_1 timeout\n" ) );
        }
        u32Pts2 = XBYTE[MVD_ARG3];
        u32Pts2 = u32Pts2 << 8;
        u32Pts2 |= XBYTE[MVD_ARG2];
        u32Pts2 = u32Pts2 << 8;

        XBYTE[MVD_ARG0] = PTS1_0;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "PTS1_0 timeout\n" ) );
        }
        u32Pts2 |= XBYTE[MVD_ARG3];
        u32Pts2 = u32Pts2 << 8;
        u32Pts2 |= XBYTE[MVD_ARG2];

        MVD_DEBUGINFO( printf( "pts= 0x%08lx ; diff= 0x%08lx | ",
                u32Pts2,
                u32Pts2 - u32Pts1 ) );
        u32Pts1 = u32Pts2;

        //stc ====================================
        XBYTE[MVD_ARG0] = SYN_STC1;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SYN_STC1 timeout \r\n" ) );
        }
        u32Stc2 = XBYTE[MVD_ARG3];
        u32Stc2 = u32Stc2 << 8;
        u32Stc2 |= XBYTE[MVD_ARG2];
        u32Stc2 = u32Stc2 << 8;

        XBYTE[MVD_ARG0] = SYN_STC0;
        XBYTE[MVD_ARG1] = 0x00;
        XBYTE[MVD_COMMAND] = 0x40;
        if ( MVD_TimeOut() )
        {
            MVD_DEBUGERROR( printf( "SYN_STC0 timeout\n" ) );
        }
        u32Stc2 |= XBYTE[MVD_ARG3];
        u32Stc2 = u32Stc2 << 8;
        u32Stc2 |= XBYTE[MVD_ARG2];

        MVD_DEBUGINFO( printf( "stc= 0x%08lx ; diff= 0x%08lx | ",u32Stc2,u32Stc2 - u32Stc1 ) );
        u32Stc1 = u32Stc2;

        //timer =============================
        u32Time2 = MDrv_Timer_GetTime0();
        MVD_DEBUGINFO( printf( "time= 0x%08lx ; diff= 0x%08lx | \r\n",u32Time2,u32Time2 - u32Time1 ) );
        u32Time1 = u32Time2;

        if ( OneShot )
        {
            break;
        }

        if ( kbhit() )
        {
            if ( getchar() == 'q' )
            {
                return;
            }
        }
    }
#else
    OneShot = OneShot;
#endif //SHOW_SYN
}
//#endif /* BUILD_SYSDEBUG */

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

#undef DRV_MVD_C