drvauto.c

mstar 776 开发的车载dvd

    // Using SMPTE 100% or 75% depends on the definition of devAuto.h
    tempADCSetting.u8RedGain = 0x30;
    tempADCSetting.u8GreenGain = 0x30;
    tempADCSetting.u8BlueGain = 0x30;
    tempADCSetting.u8RedOffset = 0x80;
    tempADCSetting.u8GreenOffset =0x80;
    tempADCSetting.u8BlueOffset = 0x80;

    u8Bank = MDrv_ReadByte( BK_SELECT_00 );

    MDrv_ADC_SetAutoADC(DISABLE, TRUE);

    u8ATGStatus = 0;
    u8FlowFlag = 0;

    // Tune offset
    for(u8Tmp=0; u8Tmp<0xFF; u8Tmp++)
    {
        //printf("u8Tmp=0x%bx\n", u8Tmp);
        MDrv_ADC_SetGain(&tempADCSetting);
        MDrv_ADC_SetOffset(&tempADCSetting);
        MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
        MDrv_Timer_Delayms(u8VSyncTime * 3); // wait stable

        u8ResultR = _MDrv_Auto_GainReport(AUTO_MIN_R, u8VSyncTime);
        u8ResultG = _MDrv_Auto_GainReport(AUTO_MIN_G, u8VSyncTime);
        u8ResultB = _MDrv_Auto_GainReport(AUTO_MIN_B, u8VSyncTime);

        if ((u8ResultR >= PbPr_AUTO_MIN_VALUE) && (u8ResultR <= (PbPr_AUTO_MIN_VALUE+1)))    // Range (0x10~0xF0)
            u8ATGStatus |= _BIT7;
        else
            u8ATGStatus &= ~_BIT7;

        if ((u8ResultG >= (Y_AUTO_MIN_VALUE+1)) && (u8ResultG <= (Y_AUTO_MIN_VALUE+2))) // Range (0x00~0xDB)
            u8ATGStatus |= _BIT6;
        else
            u8ATGStatus &= ~_BIT6;

        if ((u8ResultB >= PbPr_AUTO_MIN_VALUE) && (u8ResultB <= (PbPr_AUTO_MIN_VALUE+1)))    // Range (0x10~0xF0)
            u8ATGStatus |= _BIT5;
        else
            u8ATGStatus &= ~_BIT5;

        // Red - Pr
        if ( !(u8FlowFlag&_BIT0) )
        {
            if (_bit7_(u8ATGStatus))
            {
                // do nothing to RedOffset
                u8FlowFlag |= _BIT0;
            }
            else
            {
                tempADCSetting.u8RedOffset += (signed)(PbPr_AUTO_MIN_VALUE - u8ResultR);
            }
        }

        // Green - Y
        if ( !(u8FlowFlag&_BIT2) )
        {
            if (_bit6_(u8ATGStatus))
            {
                // do nothing to GreenOffset
                u8FlowFlag |= _BIT2;
            }
            else
            {
                tempADCSetting.u8GreenOffset += (signed)(Y_AUTO_MIN_VALUE+1 - u8ResultG);
            }
        }

        // Blue - Pb
        if ( !(u8FlowFlag&_BIT4) )
        {
            if (_bit5_(u8ATGStatus))
            {
                // do nothing to BlueOffset
                u8FlowFlag |= _BIT4;
            }
            else
            {
                tempADCSetting.u8BlueOffset += (signed)(PbPr_AUTO_MIN_VALUE - u8ResultB);
            }
        }

        //printf("ATG=0x%bx, FF=0x%bx, Min R=0x%bx,G=0x%bx,B=0x%bx\n", u8ATGStatus, u8FlowFlag, u8ResultR, u8ResultG, u8ResultG);

        // Get Pr active value (Max. value - Min. value)
        u8ResultR = _MDrv_Auto_GainReport(AUTO_MAX_R, u8VSyncTime)-u8ResultR;
        // Get Y active value (Max. value - Min. value)
        u8ResultG = _MDrv_Auto_GainReport(AUTO_MAX_G, u8VSyncTime)-u8ResultG;
        // Get Pb active value (Max. value - Min. value)
        u8ResultB = _MDrv_Auto_GainReport(AUTO_MAX_B, u8VSyncTime)-u8ResultB;

        if((u8ResultR >= PbPr_AUTO_ACTIVE_RANGE) && (u8ResultR <= (PbPr_AUTO_ACTIVE_RANGE+1)))  // Range: 0x10~0xF0
        {
            u8ATGStatus |= _BIT4;
        }
        else
        {
            u8FlowFlag &= ~(_BIT1+_BIT0);
            u8ATGStatus &= ~_BIT4;
        }

        if((u8ResultG >= Y_AUTO_ACTIVE_RANGE) && (u8ResultG <= (Y_AUTO_ACTIVE_RANGE+1)))  // Range: 0x00~0xDB
        {
            u8ATGStatus |= _BIT3;
        }
        else
        {
            u8FlowFlag &= ~(_BIT3+_BIT2);
            u8ATGStatus &= ~_BIT3;
        }

        if((u8ResultB >= PbPr_AUTO_ACTIVE_RANGE) && (u8ResultB <= (PbPr_AUTO_ACTIVE_RANGE+1)))  // Range: 0x10~0xF0
        {
            u8ATGStatus |= _BIT2;
        }
        else
        {
            u8FlowFlag &= ~(_BIT5+_BIT4);
            u8ATGStatus &= ~_BIT2;
        }

        // Red - Pr
        if ( !(u8FlowFlag&_BIT1) )
        {
            if (_bit4_(u8ATGStatus))
            {
                u8FlowFlag |= _BIT1;
            }
            else
            {
                tempADCSetting.u8RedGain += (signed)(PbPr_AUTO_ACTIVE_RANGE - u8ResultR);
                u8FlowFlag &= ~_BIT1;
            }
        }

        // Green - Y
        if ( !(u8FlowFlag&_BIT3) )
        {
            if (_bit3_(u8ATGStatus))
            {
                u8FlowFlag |= _BIT3;
            }
            else
            {
                tempADCSetting.u8GreenGain += (signed)(Y_AUTO_ACTIVE_RANGE - u8ResultG);
                u8FlowFlag &= ~_BIT3;
            }
        }

        // Blue - Pb
        if ( !(u8FlowFlag&_BIT5) )
        {
            if (_bit2_(u8ATGStatus))
            {
                u8FlowFlag |= _BIT5;
            }
            else
            {
                tempADCSetting.u8BlueGain += (signed)(PbPr_AUTO_ACTIVE_RANGE - u8ResultB);
                u8FlowFlag &= ~_BIT5;
            }
        }

        //printf("ATG=0x%bx, FF=0x%bx, Max R=0x%bx,G=0x%bx,B=0x%bx\n", u8ATGStatus, u8FlowFlag, u8ResultR, u8ResultG, u8ResultG);

        if(u8FlowFlag == 0x3F)
            break;
    }

    MDrv_Timer_Delayms(u8VSyncTime * 2);

    MDrv_WriteByte(BK_SELECT_00, u8Bank);


    //printf("FF=0x%bx, Gain R=0x%bx,G=0x%bx,B=0x%bx\n", u8FlowFlag,
    //    ~tempADCSetting.u8RedGain, ~tempADCSetting.u8GreenGain, ~tempADCSetting.u8BlueGain);
    //printf("FF=0x%bx, Offset R=0x%bx,G=0x%bx,B=0x%bx\n", u8FlowFlag,
    //    ~tempADCSetting.u8RedOffset, ~tempADCSetting.u8GreenOffset, ~tempADCSetting.u8BlueOffset);


    if(u8FlowFlag == 0x3F)
    {
        // succssed, copy setting to user
        pstADCSetting->u8RedGain = tempADCSetting.u8RedGain;
        pstADCSetting->u8GreenGain = tempADCSetting.u8GreenGain;
        pstADCSetting->u8BlueGain = tempADCSetting.u8BlueGain;
        pstADCSetting->u8RedOffset = tempADCSetting.u8RedOffset;
        pstADCSetting->u8GreenOffset = tempADCSetting.u8GreenOffset;
        pstADCSetting->u8BlueOffset = tempADCSetting.u8BlueOffset;
    }
    else
    {
        MDrv_ADC_SetGain(pstADCSetting);
        MDrv_ADC_SetOffset(pstADCSetting);
    }

    return (u8FlowFlag == 0x3F ? TRUE : FALSE);
}
#else
BOOLEAN MDrv_Auto_ColorYUV(U8 u8VSyncTime, MS_ADC_SETTING *pstADCSetting)
{
    MS_ADC_SETTING tempADCSetting;
    U8 u8Bank; // bank buffer
    U8 u8GainDelta, u8ATGStatus;
    U8 u8FlowFlag;

    u8Bank = MDrv_ReadByte( BK_SELECT_00 );
    MDrv_WriteByte( BK_SELECT_00, REG_BANK_IP1F2 );

    tempADCSetting.u8RedGain = 0x80;
    tempADCSetting.u8GreenGain = 0x80;
    tempADCSetting.u8BlueGain = 0x80;
    tempADCSetting.u8RedOffset = 0x80;
    tempADCSetting.u8GreenOffset =0x80;
    tempADCSetting.u8BlueOffset = 0x80;
    u8GainDelta = 0x80;

    MDrv_ADC_SetOffset(&tempADCSetting);
    MDrv_ADC_SetGain(&tempADCSetting);
    MDrv_ADC_SetAutoADC(ENABLE, TRUE);

    while(1)
    {
        u8GainDelta >>= 1;
        if(u8GainDelta == 0x00)
            break;

        MDrv_ADC_SetGain(&tempADCSetting);
        MDrv_ADC_SetAutoADC(ENABLE, TRUE);

        MDrv_Timer_Delayms(u8VSyncTime * 3); // wait stable
        MDrv_Auto_WaitStatusReady(BK_SC_IP1F2_0E_L, _BIT1);
        u8ATGStatus = MDrv_ReadByte(BK_SC_IP1F2_0E_L); // get auto gain status

        // Red - Pr
        if (_bit7_(u8ATGStatus))
        {
            tempADCSetting.u8RedGain -= u8GainDelta;
            u8FlowFlag |= _BIT0;
        }
        else
        {
            tempADCSetting.u8RedGain += u8GainDelta;
            u8FlowFlag |= _BIT1;
        }

        // Green - Y
        if (_bit6_(u8ATGStatus))
        {
            tempADCSetting.u8GreenGain -= u8GainDelta;
            u8FlowFlag |= _BIT2;
        }
        else
        {
            tempADCSetting.u8GreenGain += u8GainDelta;
            u8FlowFlag |= _BIT3;
        }

        // Blue - Pb
        if (_bit5_(u8ATGStatus))
        {
            tempADCSetting.u8BlueGain -= u8GainDelta;
            u8FlowFlag |= _BIT4;
        }
        else
        {
            tempADCSetting.u8BlueGain += u8GainDelta;
            u8FlowFlag |= _BIT5;
        }
    }

    u8FlowFlag = 0;
    tempADCSetting.u8RedGain -= 10;
    tempADCSetting.u8GreenGain -= 10;
    tempADCSetting.u8BlueGain -= 10;
    for(u8GainDelta=0; u8GainDelta<0xFF; u8GainDelta++)
    {
        MDrv_ADC_SetGain(&tempADCSetting);
        MDrv_ADC_SetAutoADC(ENABLE, TRUE);

        MDrv_Timer_Delayms(u8VSyncTime * 3); // wait stable
        MDrv_Auto_WaitStatusReady(BK_SC_IP1F2_0E_L, _BIT1);
        u8ATGStatus = MDrv_ReadByte(BK_SC_IP1F2_0E_L); // get auto gain status

        // Red - Pr
        if(!(u8FlowFlag&_BIT0))
        {
            if(_bit7_(u8ATGStatus))
            {
                // No need to adjust again
                u8FlowFlag |= _BIT0;
            }
            else
            {
                tempADCSetting.u8RedGain++;
                u8FlowFlag |= _BIT1;
            }
        }

        // Green - Y
        if(!(u8FlowFlag&_BIT2))
        {
            if(_bit6_(u8ATGStatus))
            {
                // No need to adjust again
                u8FlowFlag |= _BIT2;
            }
            else
            {
                tempADCSetting.u8GreenGain++;
                u8FlowFlag |= _BIT3;
            }
        }

        // Blue - Pb
        if(!(u8FlowFlag&_BIT4))
        {
            if(_bit5_(u8ATGStatus))
            {
                // No need to adjust again
                u8FlowFlag |= _BIT4;
            }
            else
            {
                tempADCSetting.u8BlueGain++;
                u8FlowFlag |= _BIT5;
            }
        }

        if(u8FlowFlag == 0x3F)
            break;
    }

    MDrv_ADC_SetAutoADC(ENABLE, TRUE);

    MDrv_WriteByte( BK_SELECT_00, u8Bank );

    // adjust gain after auto-tune
    if (u8FlowFlag == 0x3f)
    {
        // successed
        pstADCSetting->u8RedGain = tempADCSetting.u8RedGain;
        pstADCSetting->u8GreenGain = tempADCSetting.u8GreenGain;
        pstADCSetting->u8BlueGain = tempADCSetting.u8BlueGain;
        pstADCSetting->u8RedOffset = tempADCSetting.u8RedOffset;
        pstADCSetting->u8GreenOffset = tempADCSetting.u8GreenOffset;
        pstADCSetting->u8BlueOffset = tempADCSetting.u8BlueOffset;
        return TRUE;
    }
    else
    {
        MDrv_ADC_SetGain(pstADCSetting);
        MDrv_ADC_SetAutoADC(ENABLE, TRUE);
        return FALSE;
    }
}
#endif

#undef DRV_AUTO_C