drvtvencoder.c

mstar 776 开发的车载dvd

    U16 u16Out_FR, u16In_FR;

    if(g_VEInfo.VideoSystem <= MS_VE_NTSC_J)
    {
        u32FrameSize = VE_NTSC_FRAME_SIZE;
        u16Out_FR = 2997;
    }
    else
    {
        u32FrameSize = VE_PAL_FRAME_SIZE;
        u16Out_FR = 2500;
    }

    u16In_FR = (g_SrcInfo.u8DisplayStatus & DISPLAYWINDOW_INTERLACE) ? (g_SrcInfo.u16InputVFreq/2*10) : (g_SrcInfo.u16InputVFreq*10);
    MSG_DRV_VE(printf("---VE: u16In_FR = %d \r\n", u16In_FR););
    if(u16In_FR > (u16Out_FR - VE_FRC_TOLERANT) && u16In_FR<(u16Out_FR + VE_FRC_TOLERANT) )
    {
        // No need to do FRC
        MDrv_WriteRegBit(BK_VE_SRC(0x20), 1, _BIT0); // disable Full drop
        MDrv_Write4Byte(BK_VE_SRC(0x21),  0x00);
        MDrv_Write4Byte(BK_VE_SRC(0x30),  0x00);

        MDrv_WriteByteMask(BK_VE_SRC(0x35), 0x00, _BIT3|_BIT2);
        //cwchen MDrv_WriteByteMask(BK_VE_SRC(0x35), _BIT2, _BIT3|_BIT2);
    }
    else if(u16In_FR < u16Out_FR)
    {
        u32FullNum  = u32FrameSize * 19 / 10 ;
        MDrv_Write4Byte(BK_VE_SRC(0x21),  u32FullNum);
        MDrv_WriteRegBit(BK_VE_SRC(0x20), 0, _BIT0); // enable Full drop

        u32EmptyNum = (U32)(u16Out_FR - u16In_FR) * u32FrameSize / (U32)u16Out_FR ;
        MDrv_Write4Byte(BK_VE_SRC(0x30),  u32EmptyNum);
        MDrv_WriteByteMask(BK_VE_SRC(0x35), _BIT2, _BIT3|_BIT2); // deinterlace mode
    }
    else
    {
        u32FullNum = u32FrameSize +
                     ((U32)u16Out_FR  * u32FrameSize / u16In_FR);

        MDrv_Write4Byte(BK_VE_SRC(0x21),  u32FullNum);
        MDrv_WriteRegBit(BK_VE_SRC(0x20), 0, _BIT0); // enable Full drop

        u32EmptyNum = u32FrameSize / 10 ;
        MDrv_Write4Byte(BK_VE_SRC(0x30),  u32EmptyNum);
        MDrv_WriteByteMask(BK_VE_SRC(0x35), _BIT2, _BIT3|_BIT2); // deinterlace mode
    }
}


//------------------------------------------------------------------------------
/// set the ipmux for VE
///
/// @param  -enInputPortType \b IN: input port type of VE
/// @return none
//------------------------------------------------------------------------------

void _MDrv_VE_Set_IPMux(EN_INPUT_PORT_TYPE enInputPortType)
{
    U8 u8Clk_Mux, u8Data_Mux;

    if(IsUseAnalogPort(enInputPortType))
    {
        u8Clk_Mux  = VE_IPMUX_ADC_A;
        u8Data_Mux = VE_IPMUX_ADC_A;
    }
    else if(IsUseHdmiPort(enInputPortType))
    {
        u8Clk_Mux = u8Data_Mux = VE_IPMUX_HDMI_DVI;
    }
    else if(IsUseDigitalPort(enInputPortType))
    {
        u8Clk_Mux = VE_IPMUX_VD;
        u8Data_Mux = VE_IPMUX_VD;
    }
    else if(IsUseExtVDPort(enInputPortType))
    {
        u8Clk_Mux = u8Data_Mux = VE_IPMUX_EXT_VD;
    }
    else if(IsUseMVDPort(enInputPortType))
    {
        u8Clk_Mux = u8Data_Mux = VE_IPMUX_MVOP;
    }
    else	//<NHK_Coverity> : Declared variable "u8Clk_Mux" and "u8Data_Mux" without initializer
    {
    	//Neet to be touched by Mstar
       u8Clk_Mux  = VE_IPMUX_VD;
       u8Data_Mux = VE_IPMUX_VD;
    }

    MDrv_WriteByte(BK_IPMUX_02_L, u8Data_Mux); // input select
    MDrv_WriteByte(BK_CHIPTOP_1C_L, u8Clk_Mux << 2); // idclk
}


//------------------------------------------------------------------------------
/// set the color convert for different video system and DAC type
///
/// @param  VideoSys \b IN: the output video system
/// @param  u8DACType  \b IN: the output DAC type
///
/// @return none
//------------------------------------------------------------------------------
void _MDrv_VE_Set_ColorConvert(MS_VE_VIDEOSYS VideoSys, U8 u8DACType)
{

    if(VideoSys == MS_VE_NTSC || VideoSys == MS_VE_NTSC_J || VideoSys == MS_VE_NTSC_443)
    { // NTSC
        switch(u8DACType)
        {
        case VE_OUT_CVBS_YCC:
            break;

        case VE_OUT_CVBS_YCbCr:
            MsWriteVEReg(BK_VE_ENC(0x43), 0x5A);
            MsWriteVEReg(BK_VE_ENC(0x46), 0x80);
            break;

        case VE_OUT_CVBS_RGB:
            MsWriteVEReg(BK_VE_ENC(0x41), 0x95);
            MsWriteVEReg(BK_VE_ENC(0x42), 0x4B);
            MsWriteVEReg(BK_VE_ENC(0x43), 0x90);
            MsWriteVEReg(BK_VE_ENC(0x44), 0x49);
            MsWriteVEReg(BK_VE_ENC(0x45), 0x32);
            MsWriteVEReg(BK_VE_ENC(0x46), 0x102);
            break;
        }
    }
    else
    { // PAL
        switch(u8DACType)
        {
        case VE_OUT_CVBS_YCC:
            break;

        case VE_OUT_CVBS_YCbCr:
            MsWriteVEReg(BK_VE_ENC(0x43), 0x55);
            MsWriteVEReg(BK_VE_ENC(0x46), 0x78);
            break;

        case VE_OUT_CVBS_RGB:
            MsWriteVEReg(BK_VE_ENC(0x41), 0x8E);
            MsWriteVEReg(BK_VE_ENC(0x42), 0x4B);
            MsWriteVEReg(BK_VE_ENC(0x43), 0x88);
            MsWriteVEReg(BK_VE_ENC(0x44), 0x45);
            MsWriteVEReg(BK_VE_ENC(0x45), 0x2F);
            MsWriteVEReg(BK_VE_ENC(0x46), 0xF3);
            break;
        }
    }
}


//------------------------------------------------------------------------------
/// Get the starting postion and size of capture window
///
/// @param  ptiming  \b IN: VOP timing information
/// @return none
//------------------------------------------------------------------------------
// Need to Refine
void _MDrv_VE_Get_Window(MS_VOP_TIMING *ptiming)
{
    MS_VIDEO_CAPTUREWINTABLE_TYPE* pCapWin;

    switch(stSystemInfo.enInputSourceType)
    {
#if (ENABLE_HDMI)
    case INPUT_SOURCE_HDMI1:
#if (INPUT_HDMI_VIDEO_COUNT >= 2)
    case INPUT_SOURCE_HDMI2:
#endif
#if (INPUT_HDMI_VIDEO_COUNT >= 3)
    case INPUT_SOURCE_HDMI3:
#endif
        g_VEInfo.TuneWin.u16H_DisStart = MDrv_Scaler_GetHorizontalDEStart();
        g_VEInfo.TuneWin.u16V_DisStart = MDrv_Scaler_GetVerticalDEStart();
        g_VEInfo.TuneWin.u16H_DisEnd = g_VEInfo.TuneWin.u16H_DisStart + MDrv_Scaler_GetHorizontalDE() - 1;
        g_VEInfo.TuneWin.u16V_DisEnd = g_VEInfo.TuneWin.u16V_DisStart + MDrv_Scaler_GetVerticalDE() - 1;
        break;
#endif

    case INPUT_SOURCE_YPBPR:
#if (INPUT_YPBPR_VIDEO_COUNT==2)
    case INPUT_SOURCE_YPBPR2:
#endif
    case INPUT_SOURCE_VGA:

        g_VEInfo.TuneWin.u16H_DisStart = g_PcadcModeSetting.u16DefaultHStart* 2 -g_PcadcModeSetting.u16HorizontalStart;
        g_VEInfo.TuneWin.u16V_DisStart = g_PcadcModeSetting.u16VerticalStart;


        if((IsSrcTypeYPbPr(SYS_INPUT_SOURCE_TYPE)) &&
           (g_PcadcModeSetting.u8ModeIndex == MD_720x480_60I ||
            g_PcadcModeSetting.u8ModeIndex == MD_720x480_60P ||
            g_PcadcModeSetting.u8ModeIndex == MD_720x576_50I ||
            g_PcadcModeSetting.u8ModeIndex == MD_720x576_50P))
        {
            g_VEInfo.TuneWin.u16H_DisEnd = g_VEInfo.TuneWin.u16H_DisStart + 848 -1;  // for better quality
        }
        else
        {
            g_VEInfo.TuneWin.u16H_DisEnd =
                    g_VEInfo.TuneWin.u16H_DisStart + MDrv_Mode_GetStdModeResH( g_PcadcModeSetting.u8ModeIndex ) - 1; // standard display width
        }



        g_VEInfo.TuneWin.u16V_DisEnd =
            g_VEInfo.TuneWin.u16V_DisStart + MDrv_Mode_GetStdModeResV( g_PcadcModeSetting.u8ModeIndex )- 1; // standard display height

        if ( MDrv_Mode_GetStdModeResV( g_PcadcModeSetting.u8ModeIndex ) == 350 ) // if IBM VGA 640x350 then use 640x400 resolution and move to middle of screen
        {
            g_VEInfo.TuneWin.u16V_DisStart -= ( ( 400 - 350 ) / 2 );
            g_VEInfo.TuneWin.u16V_DisEnd = g_VEInfo.TuneWin.u16V_DisStart + 400 -1;
        }
        MSG_DRV_VE(printf("---TVEncoder PCMode: DefaultHstart=%d, Hstart =%d, Vstart=%d, Hsize=%d, Vsize=%d, ModeIndex =%bx\n",
               g_PcadcModeSetting.u16DefaultHStart,
               g_PcadcModeSetting.u16HorizontalStart,
               g_PcadcModeSetting.u16VerticalStart,
               MDrv_Mode_GetStdModeResH( g_PcadcModeSetting.u8ModeIndex ),
               MDrv_Mode_GetStdModeResV( g_PcadcModeSetting.u8ModeIndex ),
               g_PcadcModeSetting.u8ModeIndex););

        MSG_DRV_VE(printf("---TVEncoder : Hstar =%d, Hsize=%d, Vstart =%d, Vsize = %d , modeidx = %bx\n",
           g_SrcInfo.u16H_CapStart,
           g_SrcInfo.u16H_CapSize,
           g_SrcInfo.u16V_CapStart,
           g_SrcInfo.u16V_CapSize,
           g_PcadcModeSetting.u8ModeIndex););

        break;

#if (ENABLE_SCART_VIDEO)
    case INPUT_SOURCE_SCART:
#if (INPUT_SCART_VIDEO_COUNT == 2)
    case INPUT_SOURCE_SCART2:
#endif
#endif
    case INPUT_SOURCE_CVBS:
#if (INPUT_AV_VIDEO_COUNT == 2)
    case INPUT_SOURCE_CVBS2:
#endif
    case INPUT_SOURCE_SVIDEO:
#if (INPUT_SV_VIDEO_COUNT == 2)
    case INPUT_SOURCE_SVIDEO2:
#endif
    case INPUT_SOURCE_TV:

        if(IsUseExtVDPort(stSystemInfo.enInputPortType))
        {
            pCapWin = &ExtVDVideoCapture[g_VdInfo.ucVideoSystem];
        }
        else
        {
            //pCapWin = &VideoCaptureWinTbl[g_VdInfo.ucVideoSystem];
            pCapWin = &VideoCapWinTbl[g_VdInfo.ucVideoSystem];
        }

        g_VEInfo.TuneWin.u16H_DisStart = pCapWin->u16SRHStart;
        g_VEInfo.TuneWin.u16V_DisStart = pCapWin->u16SRVStart;
        g_VEInfo.TuneWin.u16H_DisEnd = g_VEInfo.TuneWin.u16H_DisStart + pCapWin->u16HRange- 1;
        g_VEInfo.TuneWin.u16V_DisEnd = g_VEInfo.TuneWin.u16V_DisStart + pCapWin->u16VRange - 1;
        MSG_DRV_VE(printf("---VEGetHstart:%d,VEGetVstart:%d,VEGetHsize:%d,VEGetVsize:%d\n",
        pCapWin->u16SRHStart,pCapWin->u16SRVStart,pCapWin->u16HRange,pCapWin->u16VRange););
        break;


    case INPUT_SOURCE_DTV:
        g_VEInfo.TuneWin.u16H_DisStart = (ptiming->u16HActive_Start)/2;

        if(ptiming->bInterlace)
            g_VEInfo.TuneWin.u16V_DisStart = (ptiming->u16VBlank0_End-ptiming->u16VBlank0_Start-(ptiming->u8VSync_Offset*2))*2-4;
        else
            g_VEInfo.TuneWin.u16V_DisStart = (ptiming->u16VBlank0_End-ptiming->u16VBlank0_Start-(ptiming->u8VSync_Offset*2))*1-2;


        g_VEInfo.TuneWin.u16H_DisEnd = g_VEInfo.TuneWin.u16H_DisStart + ptiming->u16Width - 1;
        g_VEInfo.TuneWin.u16V_DisEnd = g_VEInfo.TuneWin.u16V_DisStart + ptiming->u16Height - 1;
        MSG_DRV_VE(printf("---VE_DTV_bypass_mode H_DisStart:%d,V_DisStart:%d,H_DisEnd:%d,V_DisEnd:%d\n",
               g_VEInfo.TuneWin.u16H_DisStart, g_VEInfo.TuneWin.u16V_DisStart, g_VEInfo.TuneWin.u16H_DisEnd, g_VEInfo.TuneWin.u16V_DisEnd););
        break;
    }
}


//------------------------------------------------------------------------------
/// Set saling ratio of VE
///
/// @param  none
/// @return none
//------------------------------------------------------------------------------
void _MDrv_VE_Set_ScalingRatio(void)
{
    U16 u16H_Ratio, u16V_Ratio;
    U16 u16Out_Vsize, u16Out_Hsize;
    U16 u16In_Vsize, u16In_Hsize;

    u16Out_Hsize = 720;
    u16Out_Vsize = (g_VEInfo.VideoSystem <= MS_VE_NTSC_J) ? 480 : 576;

    u16In_Hsize = g_VEInfo.TuneWin.u16H_DisEnd -  g_VEInfo.TuneWin.u16H_DisStart + 1;
    u16In_Vsize = g_VEInfo.TuneWin.u16V_DisEnd -  g_VEInfo.TuneWin.u16V_DisStart + 1;


    if(u16Out_Hsize != u16In_Hsize)
    {
        if(u16In_Hsize > u16Out_Hsize)
        {
            u16H_Ratio = (U16)VE_H_SCALE_DOWN_RATIO(u16In_Hsize, u16Out_Hsize);
            //MDrv_WriteRegBit(BK_VE_SRC(0x00), 0, _BIT8);
            MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 0, _BIT0);

            MsWriteVEReg(BK_VE_SRC(0x16), u16H_Ratio);
        }
        else    //VE not support upscale,just bypass it
        {
            if(u16In_Hsize ==544)//DVB DTV 544x576 needs fine tune by hand
            {
                MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 0, _BIT0);
                MsWriteVEReg(BK_VE_SRC(0x16), 0x07FF);
            }
            else
            {
                MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 1, _BIT0);
                MsWriteVEReg(BK_VE_SRC(0x16), 0x0000);
            }
        }
    }
    else
    {
        //MDrv_WriteRegBit(BK_VE_SRC(0x00), 1, _BIT8);
        MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 1, _BIT0);
        MsWriteVEReg(BK_VE_SRC(0x16), 0x0000);
    }

    if(u16Out_Vsize != u16In_Vsize)
    {
        if(u16In_Vsize > u16Out_Vsize)
        {
            u16V_Ratio = (U16)VE_V_SCALE_DOWN_RATIO(u16In_Vsize, u16Out_Vsize);
            //MDrv_WriteRegBit(BK_VE_SRC(0x00), 0, _BIT9);
            MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 0, _BIT1);
            MsWriteVEReg(BK_VE_SRC(0x17), u16V_Ratio-3);
        }
        else    //VE not support upscale,just bypass it
        {
            MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 1, _BIT1);
            MsWriteVEReg(BK_VE_SRC(0x17), 0x0000);
        }
    }
    else
    {
        //MDrv_WriteRegBit(BK_VE_SRC(0x00), 1, _BIT9);
        MDrv_WriteRegBit(H_BK_VE_SRC(0x00), 1, _BIT1);
        MsWriteVEReg(BK_VE_SRC(0x17), 0x0000);
    }
}


//------------------------------------------------------------------------------
/// set capture window of VE
///