drvvop.c

mstar 776 开发的车载dvd

            u16strip = pparam->u16StripSize;
        }

        // set dc_strip[7:0]
        if ( pparam->bDramRdContd == 0 ) {
            //u16strip = ( ( (U32)u16strip*32/8 ) >> 5);
            u16strip = u16strip/8;
        }
        else {
            if ( pparam->b422pack ) {
                //u16strip = ( (U32)u16strip*2/8 );
                if (u16strip < 1024)
                {
                    u16strip = u16strip/4;
                    // dont extend strip len
                    XBYTE[0x147E] &= 0xfe;
                    XBYTE[0x147F] = XBYTE[0x147F];
                }
                else
                {
                    u16strip = u16strip/8;
                    // extend strip len to 2048
                    XBYTE[0x147E] |= 1;
                    XBYTE[0x147F] = XBYTE[0x147F];
                }
            }
            else
            {
                //u16strip = ( (U32)u16strip/8 );
                u16strip = u16strip/8;
            }
        }
        #ifdef DBG_VOP
        if ( u16strip >= 256 ) {
            printf("[Drvvop.c : MDrv_VOP_Input_Mode_Ext()] strip overflow\n");
        }
        #endif
        regval = u16strip;
        XBYTE[VOP_MPG_JPG_SWITCH + 1] = regval;

        // Y offset
        u32tmp.u32Num = pparam->u32YOffset >> 3;
        XBYTE[VOP_JPG_YSTR0_L    ] = u32tmp.u8Num[3];
        XBYTE[VOP_JPG_YSTR0_L + 1] = u32tmp.u8Num[2];
        XBYTE[VOP_JPG_YSTR0_H    ] = u32tmp.u8Num[1];

        if (pparam->b422pack)
        {
            pparam->u32UVOffset = pparam->u32YOffset + 8;
        }
        // UV offset
        u32tmp.u32Num = pparam->u32UVOffset >> 3;
        XBYTE[VOP_JPG_UVSTR0_L    ] = u32tmp.u8Num[3];
        XBYTE[VOP_JPG_UVSTR0_L + 1] = u32tmp.u8Num[2];
        XBYTE[VOP_JPG_UVSTR0_H    ] = u32tmp.u8Num[1];

        // HSize, VSize
        XBYTE[VOP_JPG_HSIZE    ] = LOWBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_HSIZE + 1] = HIGHBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_VSIZE    ] = LOWBYTE( pparam->u16VSize );
        XBYTE[VOP_JPG_VSIZE + 1] = HIGHBYTE( pparam->u16VSize );
    }

    XBYTE[VOP_REG_WR] = 1;
    XBYTE[VOP_REG_WR] = 0;
}

#if 0
/******************************************************************************/
/// Set VOP input mode extension
/// @param mode \b IN \copydoc VOPINPUTMODE
/// @param pparam \b IN \copydoc VOPINPUTPARAM members should be set for
///   - #VOPINPUT_HARDWIRE     N/A
///   - #VOPINPUT_HARDWIRECLIP HSize and VSize
///   - #VOPINPUT_MCUCTRL      Y Offset, UV offset, HSize adn VSize
/******************************************************************************/
void MDrv_VOP_Input_Mode_Ext ( VOPINPUTMODE mode, VOPINPUTPARAM *pparam )
{
    LONG32_BYTE u32tmp;
    U8 regval;
    U16 u16strip;

    #ifdef DBG_VOP
    printf ( "[Drvvop.c::MDrv_VOP_Input_Mode_Ext()]\r\n" );
    #endif

    //set VOP test pattern to black
    MDrv_VOP_EnableBlackBG();

    //regval = XBYTE[VOP_MPG_JPG_SWITCH];
    regval = 0;
    regval |= ( mode & 0x3 );

    if ( mode == VOPINPUT_HARDWIRE )
    {
        XBYTE[VOP_MPG_JPG_SWITCH] = regval;
    }
    else if ( mode == VOPINPUT_HARDWIRECLIP )
    {
        XBYTE[VOP_MPG_JPG_SWITCH] = regval;

        // HSize, VSize
        XBYTE[VOP_JPG_HSIZE    ] = LOWBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_HSIZE + 1] = HIGHBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_VSIZE    ] = LOWBYTE( pparam->u16VSize );
        XBYTE[VOP_JPG_VSIZE + 1] = HIGHBYTE( pparam->u16VSize );
    }
    else if ( mode == VOPINPUT_MCUCTRL )
    {
        if ( pparam->bProgressive )
            regval |= 0x4;
        else
            regval &= ~0x4;

        if ( pparam->bYUV422 )
            regval |= 0x10;
        else
            regval &= ~0x10;

        // [3] UV-7bit mode
        if ( pparam->bUV7bit )
            regval |= 0x8;
        else
            regval &= ~0x8;

        // [5] dram_rd_md
        if ( pparam->bDramRdContd )
            regval |= 0x20;
        else
            regval &= ~0x20;

        // [6] Fld
        if ( pparam->bField )
            regval |= 0x40;
        else
            regval &= ~0x40;

        // [7] 422pack
        if ( pparam->b422pack )
            regval |= 0x80;
        else
            regval &= ~0x80;

        XBYTE[VOP_MPG_JPG_SWITCH] = regval;

        // set dc_strip[7:0]
        if ( pparam->bDramRdContd == 0 ) {
            //u16strip = ( ( (U32)pparam->u16HSize*32/8 ) >> 5);
            u16strip = (pparam->u16HSize+7)/8;
        }
        else {
            if ( pparam->b422pack ) {
                //u16strip = ( (U32)pparam->u16HSize*2/8 );
                u16strip = (pparam->u16HSize+3)/4;
            }
            else {
                //u16strip = ( (U32)pparam->u16HSize/8 );
                u16strip = (pparam->u16HSize+7)/8;
            }
        }
        #ifdef DBG_VOP
        if ( u16strip >= 256 ) {
            printf("[Drvvop.c : MDrv_VOP_Input_Mode_Ext()] strip overflow\n");
        }
        #endif
        regval = u16strip;
        XBYTE[VOP_MPG_JPG_SWITCH + 1] = regval;

        // Y offset
        u32tmp.u32Num = pparam->u32YOffset >> 3;
        XBYTE[VOP_JPG_YSTR0_L    ] = u32tmp.u8Num[3];
        XBYTE[VOP_JPG_YSTR0_L + 1] = u32tmp.u8Num[2];
        XBYTE[VOP_JPG_YSTR0_H    ] = u32tmp.u8Num[1];

        // UV offset
        u32tmp.u32Num = pparam->u32UVOffset >> 3;
        XBYTE[VOP_JPG_UVSTR0_L    ] = u32tmp.u8Num[3];
        XBYTE[VOP_JPG_UVSTR0_L + 1] = u32tmp.u8Num[2];
        XBYTE[VOP_JPG_UVSTR0_H    ] = u32tmp.u8Num[1];

        // HSize, VSize
        XBYTE[VOP_JPG_HSIZE    ] = LOWBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_HSIZE + 1] = HIGHBYTE( pparam->u16HSize );
        XBYTE[VOP_JPG_VSIZE    ] = LOWBYTE( pparam->u16VSize );
        XBYTE[VOP_JPG_VSIZE + 1] = HIGHBYTE( pparam->u16VSize );
    }

    XBYTE[VOP_REG_WR] = 1;
    XBYTE[VOP_REG_WR] = 0;
}

/******************************************************************************/
/// Set horizontal pixel duplication (must be set when CCIR656 out)
/// @param bEnable \b IN
///   - # TRUE  Enable horizontal pixel duplication
///   - # FALSE Dsiable horizontal pixel duplication
/******************************************************************************/
void MDrv_VOP_Output_EnableHDup ( BOOLEAN bEnable )
{
    U8 regval;

    #ifdef DBG_VOP
    printf ( "[Drvvop.c::MDrv_VOP_Output_EnableHDup()]\r\n" );
    #endif

    regval = XBYTE[VOP_CTRL0];

    if ( bEnable )
    {
        regval |= 0x4;
    }
    else
    {
        regval &= ~0x4;
    }

    XBYTE[VOP_CTRL0] = regval;
}

/******************************************************************************/
/// Set vertical line duplication
/// @param bEnable \b IN
///   - # TRUE  Enable vertical line duplication
///   - # FALSE Disable vertical line duplication
/******************************************************************************/
void MDrv_VOP_Output_EnableVDup ( BOOLEAN bEnable )
{
    U8 regval;

    #ifdef DBG_VOP
    printf ( "[Drvvop.c::MDrv_VOP_Output_EnableVDup()]\r\n" );
    #endif

    regval = XBYTE[VOP_CTRL0];

    if ( bEnable )
    {
        regval |= 0x8;
    }
    else
    {
        regval &= ~0x8;
    }

    XBYTE[VOP_CTRL0] = regval;
}

#endif
/******************************************************************************/
/// Set VOP output mode (Progressive / Interlaced)
/// @param bEnable \b IN
///   - # TRUE  Fleid mode (interlaced)
///   - # FALSE Frame mode (progressive)
/******************************************************************************/
void MDrv_VOP_Output_EnableInterlace ( BOOLEAN bEnable )
{
    U8 regval;

    #ifdef DBG_VOP
    printf ( "[Drvvop.c::MDrv_VOP_Output_EnableInterlace()]\r\n" );
    #endif

    regval = XBYTE[VOP_CTRL0];

    if ( bEnable )
    {
        regval |= 0x80;
    }
    else
    {
        regval &= ~0x80;
    }

    #ifdef DBG_VOP
    printf( "regval =%bx \r\n", regval );
    #endif
    XBYTE[VOP_CTRL0] = regval;
}

#if 0
/******************************************************************************/
/// Set VOP CCIR656 encode
/// @param bEnable \b IN
///   - # TRUE  Enable CCIR656 out
///   - # FALSE Disable CCIR656 out
/******************************************************************************/
void MDrv_VOP_Output_EnableCCIR656 ( BOOLEAN bEnable )
{
    U8 regval;

    #ifdef DBG_VOP
    printf ( "[Drvvop.c::MDrv_VOP_Output_EnableCCIR656()]\r\n" );
    #endif

    regval = XBYTE[VOP_CTRL0];

    if ( bEnable )
    {
        regval |= 0x2;
    }
    else
    {
        regval &= ~0x2;
    }

    XBYTE[VOP_CTRL0] = regval;
}

#endif
/******************************************************************************/
/// Set enable black background
/******************************************************************************/
void MDrv_VOP_EnableBlackBG ( void )
{