msapi_iframe.c

mstar 776 开发的车载dvd

#define MSAPI_IFRAME_C
///////////////////////////////////////////////////////////////////////////////
//
//  File name: msAPI_IFrame.c
//  Version: 1.0
//  Date: 2006/3/25
//
//  Company: MStarSemi Inc.
//
//  Description: IFrame API
//  [Doxygen]
/// @file msAPI_IFrame.h
/// @brief Video IFrame API
/// @author MStarSemi Inc.
///
///////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
/*                    Header Files                                            */
/* ****************************************************************************/

#include <stdio.h>
#include <mreg51.h>
#include <intrins.h>
#include "drvmvd.h"
#include "drvmiu.h"
#include "drvtimer.h"
#include "drvScaler.h"
#include "drvvop.h"
#include "msAPI_Video.h"
#include "msAPI_Scaler.h"
#include "msAPI_IFrame.h"

/* Variables and functions defined in MApp */
#define MVD_DEBUGINFO(x)
extern BOOLEAN fEnableSignalCheck;
extern BOOLEAN fEnableMvdTimingMonitor;
extern BOOLEAN bMVDTimingChange;
extern BOOLEAN bPrepareChange;
extern MMSAPI_VID_STATUS stVidStatus;
extern MS_VOP_TIMING stVOPTiming;
extern void MApp_Scaler_SetTimingAndWindow(EN_ASPECT_RATIO_TYPE enVideoScreen);
extern void MApp_MVD_PrepareTimingChange();
/******************************************************************************/
/// API for process I frame decoding mailbox msg from Aeon
/// U32 u32StreamBufAddr: start address of the loaded I frame bitstream
/******************************************************************************/
void msAPI_IFrame_ProcessMailbox(U8 *u8MailBox)
{
    U32 u32StreamBufAddr;

    // Command Index
    switch (u8MailBox[1])
    {
        case MSAPI_IFRAME_MBCMD_DECODE:
            u32StreamBufAddr = ((U32)u8MailBox[2])          |
                               (((U32)u8MailBox[3]) << 8)   |
                               (((U32)u8MailBox[4]) << 16)  |
                               (((U32)u8MailBox[5]) << 24);
            MVD_DEBUGINFO(printf("u32StreamBufAddr = 0x%08LX\n", u32StreamBufAddr));

            MDrv_Mvd_MVDReset();

            if (msAPI_IFrame_Decode( MVD_FRAMEBUFFER_ADR, u32StreamBufAddr ) == FALSE)
            {
                printf("decode I-frame fail\n");
            }

            break;

        case MSAPI_IFRAME_MBCMD_ENABLE:
            if (u8MailBox[2])
                msAPI_IFrame_Show();
            else
                msAPI_IFrame_Hide();
            break;

        default:
            break;
    }
}


/******************************************************************************/
/// API for load I frame from flash with ID:0x28 to ram:
/// U32 u32StreamBufAddr: start address of the loaded I frame bitstream
/******************************************************************************/
void msAPI_IFrame_Load(U32 u32StreamBufAddr)
{
    U16 CODE_SIZE;
    U32 i=0;
    BINFORMAT BinInfo;

    ///-Get MVD binary information
    BinInfo.B_ID = 0x28;
    //printf("I-frame id=0x%04X\n", BinInfo.B_ID) ;

    if (MDrv_MIU_Get_BinInfo(&BinInfo) != PASS)
    {
        MVD_DEBUGINFO(printf( "could not find I-frame binary on flash.\r\n" )) ;
        return ;
    }

    CODE_SIZE = BinInfo.B_Len;
    CODE_SIZE = ((CODE_SIZE+7) >> 3) << 3;

    //printf( "MVD code address:0x%8lx, length=0x%4x\n", u32StreamBufAddr, CODE_SIZE) ;

    ///-Copy firmware code from flash to SDRAM
    MDrv_MIU_XCopy( MCPY_LOADMVDFW, BinInfo.B_FAddr, u32StreamBufAddr, CODE_SIZE );
    MVD_DEBUGINFO(printf("copy done\n"));
}


/******************************************************************************/
/// API for hide I frame
/// U32 u32FrameBufAddr: start address of frame buffer to which I frame is decoded
/// U32 u32StreamBufAddr: start address of the I frame bitstream
/******************************************************************************/
void msAPI_IFrame_Hide( void )
{
    MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_BLACK);
    MDrv_Scaler_SetBlackScreen(ENABLE);
    msAPI_IFrame_ReturnFromDispIFrame();
}

/******************************************************************************/
/// API for decode I frame
/// U32 u32FrameBufAddr: start address of frame buffer to which I frame is decoded
/// U32 u32StreamBufAddr: start address of the I frame bitstream
/******************************************************************************/
BOOLEAN msAPI_IFrame_Decode( U32 u32FrameBufAddr, U32 u32StreamBufAddr )
{
    U8 tmpWindowStatus;
    VOPINPUTPARAM dc_param;
    MS_SYS_INFO enMsSysInfo;

    // Enable Blue Screen
    MDrv_Scaler_SetBlueScreen(ENABLE, FREE_RUN_COLOR_BLACK);
    MDrv_Scaler_SetBlackScreen(ENABLE);

    // set Scaler input source
    SYS_INPUT_SOURCE_TYPE = INPUT_SOURCE_DTV;
    enMsSysInfo.enDataInputSourceType = DATA_INPUT_SOURCE_DTV;
    enMsSysInfo.enInputSourceType = INPUT_SOURCE_DTV;
    enMsSysInfo.enInputPortType = INPUT_PORT_MS_DTV;
    enMsSysInfo.enAspectRatio = VIDEOSCREEN_NORMAL;
    msAPI_Scaler_SetSourceType(&enMsSysInfo);

    // set MHEG I-frame buffer & bitstream buffer and then decode I-frame
    if (MDrv_Mvd_DecodeIFrame(u32FrameBufAddr, u32StreamBufAddr) == FALSE)
    {
        MVD_DEBUGINFO(printf("decode I-frame hang\n"));
        return FALSE;
    }
    MVD_DEBUGINFO(printf("decode I-frame done\n"));


    // get frame information
    if( FALSE == msAPI_VID_GetVidInfo(&stVidStatus) ) {
        MVD_DEBUGINFO(printf( "invalid mpeg or video info\n"));
    }
    MVD_DEBUGINFO(printf("hsize,vsize=%u,%u\n", stVidStatus.u16HorSize, stVidStatus.u16VerSize));
    MVD_DEBUGINFO(printf("frame rate=%u\n", stVidStatus.u16FrameRate));
    MVD_DEBUGINFO(printf("i/p=%bx\n", stVidStatus.u8Interlace));

    // set mvop parameters
    MDrv_VOP_EnableBlackBG();
    MDrv_VOP_Enable( FALSE );

    dc_param.u16HSize = stVidStatus.u16HorSize;
    dc_param.u16VSize = stVidStatus.u16VerSize;
    dc_param.u32YOffset = u32FrameBufAddr;
#if VIDEO_FIRMWARE_CODE >= VIDEO_FIRMWARE_CODE_HD
    dc_param.u32UVOffset = u32FrameBufAddr + 1920UL*1088UL;
    dc_param.bSD = 0;
#else
    dc_param.u32UVOffset = u32FrameBufAddr + 720UL*576UL;
    dc_param.bSD = 1;
#endif
    dc_param.bYUV422 = 0;
    dc_param.bProgressive = (stVidStatus.u8Interlace) ? 0:1;
    dc_param.bUV7bit = 0;
    dc_param.bDramRdContd = 0;
    dc_param.bField = 0;
    dc_param.b422pack = 0;
    dc_param.u16StripSize = 0;
    MDrv_VOP_Input_Mode(VOPINPUT_MCUCTRL, &dc_param);

    MDrv_VOP_AutoGenMPEGTiming(&stVOPTiming, &stVidStatus);
    MDrv_VOP_Output_EnableInterlace( stVOPTiming.bInterlace );
    MDrv_VOP_SetOutputTiming( &stVOPTiming );
    MDrv_VOP_SetVOPSynClk( &stVOPTiming );

    // set scaler timings
    tmpWindowStatus=msAPI_Scaler_GetDisplayWindowStatus();
    msAPI_Scaler_SetDisplayWindowStatus(tmpWindowStatus|= DISPLAYWINDOW_SKIP_OVERSCAN);
    MApp_Scaler_SetTimingAndWindow(stSystemInfo.enAspectRatio);
      tmpWindowStatus=msAPI_Scaler_GetDisplayWindowStatus();
    msAPI_Scaler_SetDisplayWindowStatus(tmpWindowStatus &= ~DISPLAYWINDOW_SKIP_OVERSCAN);
	MDrv_VOP_Enable( TRUE );

    fEnableSignalCheck = FALSE;
    fEnableMvdTimingMonitor = FALSE;

    return TRUE;
}


/******************************************************************************/
/// API for display I frame
/// U32 u32FrameBufAddr: start address of frame buffer to which I frame is decoded
/******************************************************************************/
void msAPI_IFrame_Show( void )
{
    MDrv_Scaler_SetBlueScreen(DISABLE, FREE_RUN_COLOR_BLACK);
    MDrv_Timer_Delayms(100);
    MDrv_Scaler_SetBlackScreen(DISABLE);
}


/******************************************************************************/
/// API for return from I frame mode to normal video mode
/******************************************************************************/
void msAPI_IFrame_ReturnFromDispIFrame()
{
    fEnableSignalCheck = TRUE;
    fEnableMvdTimingMonitor = TRUE;

    {// reset MVD_TimingMonitor to get hsize,vsize and set mvop/scaler
        bMVDTimingChange = FALSE;
        bPrepareChange = TRUE;
        MApp_MVD_PrepareTimingChange();
    }
    MDrv_VOP_Input_Mode(VOPINPUT_HARDWIRE, 0);
    msAPI_VID_MVDCommand(MSAPI_VID_PLAY);
}

#undef MSAPI_IFRAME_C