📄 auto.c
字号:
void HistWrite_RTD2547D_SmartFit(UINT16 *Window, UINT8 HistCh)
{
UINT16 HStartPos_HB,HStartPos_LB;
UINT16 HEndPos_HB,HEndPos_LB;
UINT16 VStartPos_HB,VStartPos_LB;
UINT16 VEndPos_HB,VEndPos_LB;
//CScalerPageSelect(_PAGE0);
//Image Auto Function boundary Begin
HStartPos_HB = (Window[0] >> 8) & (0x07);
HStartPos_LB = Window[0] & (0xff);
HEndPos_HB = (Window[1] >> 8) & (0x0f);
HEndPos_LB = Window[1] & (0xff);
VStartPos_HB = (Window[2] >> 8) & (0x07);
VStartPos_LB = Window[2] & (0xff);
VEndPos_HB = (Window[3] >> 8) & (0x0f);
VEndPos_LB = Window[3] & (0xff);
CScalerSetByte( _H_BOUNDARY_H_70, ((HStartPos_HB<<4) + HEndPos_HB));
CScalerSetByte( _H_BOUNDARY_STA_L_71, HStartPos_LB);
CScalerSetByte( _H_BOUNDARY_END_L_72, HEndPos_LB);
CScalerSetByte( _V_BOUNDARY_H_73, ((VStartPos_HB<<4) + VEndPos_HB));
CScalerSetByte( _V_BOUNDARY_STA_L_74, VStartPos_LB);
CScalerSetByte( _V_BOUNDARY_END_L_75, VEndPos_LB);
//Image Auto Function boundary End
//Color Source Select for Detection
if(HistCh==0)
CScalerSetByte( _AUTO_ADJ_CTRL0_7A, 0x01);
else if(HistCh==1)
CScalerSetByte( _AUTO_ADJ_CTRL0_7A, 0x00);
else if(HistCh==2)
CScalerSetByte( _AUTO_ADJ_CTRL0_7A, 0x02);
//MIN color measured, Accumulation Mode, Start Auto-Function Tracking Function
CScalerSetByte( _AUTO_ADJ_CTRL1_7D, 0x31);
}
BYTE FindDominant_RTD2547D_SmartFit( UINT16 *Window, UINT8 HistCh)
{
UINT32 SUM=0;
UINT32 PxlNum=0;
UINT32 PEAK=0;
CScalerSetByte( _DIFF_THRESHOLD_79, 0);//Threshold = 0
HistWrite_RTD2547D_SmartFit( &Window[0], HistCh);
do{
CScalerRead(_AUTO_ADJ_CTRL1_7D, 1, pData, _AUTOINC);
if(pData[0]==0x30) //check "Hiswirte" finished
{
CScalerRead(_AUTO_PHASE_3_84, 4, pData, _AUTOINC);
SUM = ((UINT32)(pData[0])<<24) + ((UINT32)(pData[1])<<16) + ((UINT16)pData[2]<<8) + pData[3];
PxlNum = (Window[1]-Window[0]+1)*(Window[3]-Window[2]+1);
PEAK = (SUM)/PxlNum;
/* DebugPrintf("Window[0]>>8=%x\n", Window[0]>>8);
DebugPrintf("Window[0]=%x\n", Window[0]);
DebugPrintf("Window[0]>>8=%x\n", Window[1]>>8);
DebugPrintf("Window[0]=%x\n", Window[1]);
DebugPrintf("Window[0]>>8=%x\n", Window[2]>>8);
DebugPrintf("Window[0]=%x\n", Window[2]);
DebugPrintf("Window[0]>>8=%x\n", Window[3]>>8);
DebugPrintf("Window[0]=%x\n", Window[3]);
DebugPrintf("PxlNum>>24=%x\n",PxlNum>>24);
DebugPrintf("PxlNum>>16=%x\n",PxlNum>>16);
DebugPrintf("PxlNum>>8=%x\n",PxlNum>>8);
DebugPrintf("PxlNum=%x\n",PxlNum);
DebugPrintf("_AUTO_PHASE_3_84=%x\n",YPbPr_ReadByte( _AUTO_PHASE_3_84) );
DebugPrintf("_AUTO_PHASE_2_85=%x\n",YPbPr_ReadByte( _AUTO_PHASE_2_85) );
DebugPrintf("_AUTO_PHASE_1_86=%x\n",YPbPr_ReadByte( _AUTO_PHASE_1_86) );
DebugPrintf("_AUTO_PHASE_0_87=%x\n",YPbPr_ReadByte( _AUTO_PHASE_0_87) );
*/
break;
}
}while(1);
return(PEAK);
}
BYTE ADC_adjust_RTD2547D(UINT16 *HistWindow, UINT8 Target, UINT8 ADC_Adds, UINT8 ADC_Data, UINT8 HistCh)
{
UINT8 counter = 0;
UINT16 max = 0;
UINT16 min = 255;
UINT8 PEAK_Level = 0;
UINT8 diff = 0;
CScalerPageSelect(_PAGE0);
CScalerSetByte(ADC_Adds, ADC_Data);
do
{
PEAK_Level = FindDominant_RTD2547D_SmartFit( &HistWindow[0], HistCh);
diff = YPbPr_ABS(Target, PEAK_Level);
if(diff == 0)
{
break;
}
else if(diff != 0 && counter == 9)
{
break;
}
else if (PEAK_Level >Target)
{
max = ADC_Data;
ADC_Data = (max + min )*(0.5);
//Write ADC Reg
CScalerPageSelect(_PAGE0);
CScalerSetByte( ADC_Adds, ADC_Data);
}
else if (PEAK_Level < Target)
{
min = ADC_Data;
ADC_Data = (max + min)*(0.5);
//Write ADC Reg
CScalerPageSelect(_PAGE0);
CScalerSetByte( ADC_Adds, ADC_Data);
}
//DebugPrintf("\nmax_min: ADC_Data = %x", ADC_Data);
counter++;
}while(1);
return (ADC_Data);
}
BYTE Adjust_Loop(UINT16 *OffsetPos, UINT16 *GainPos, UINT8 OffsetData, UINT8 GainData, UINT8 ADCOffsetAdds, UINT8 ADCGainAdds, UINT8 Channel, UINT8 OffsetTarget, UINT8 GainTarget)
{
UINT8 Gain_Check;
UINT8 Offset_Check;
UINT8 Check_idx = 0;
do{
//Offset adjustment Begin
OffsetData = ADC_adjust_RTD2547D( &OffsetPos[0], OffsetTarget, ADCOffsetAdds, OffsetData, Channel);
//Gain adjustment Begin
GainData = ADC_adjust_RTD2547D( &GainPos[0], GainTarget, ADCGainAdds, GainData, Channel);
Offset_Check = FindDominant_RTD2547D_SmartFit( &OffsetPos[0], Channel);
Gain_Check = FindDominant_RTD2547D_SmartFit( &GainPos[0], Channel);
Check_idx++;
if(Check_idx>9)
break;
}while((YPbPr_ABS(Offset_Check, OffsetTarget)>1 || YPbPr_ABS(Gain_Check, GainTarget)>1));
//DebugPrintf("Offset_Check=%x\n",Offset_Check);
//DebugPrintf("Gain_Check=%x\n",Gain_Check);
if(Channel_Y == Channel){
stYPbPrData.YPbPrGain[_GREEN] = GainData;
stYPbPrData.YPbPrOffset[_GREEN] = OffsetData;
}
else if(Channel_U == Channel){
stYPbPrData.YPbPrGain[_BLUE] = GainData;
stYPbPrData.YPbPrOffset[_BLUE] = OffsetData;
}
else{// if(Channel_V == Channel)
stYPbPrData.YPbPrGain[_RED] = GainData;
stYPbPrData.YPbPrOffset[_RED] = OffsetData;
}
return(0);
}
/*
//chroma2330
#define Y_Target_Offset_SD 16
#define U_Target_Offset_SD 128
#define V_Target_Offset_SD 128
#define Y_Target_Gain_SD 235
#define U_Target_Gain_SD 202
#define V_Target_Gain_SD 222
//
#define Y_Target_Offset_HD 16
#define U_Target_Offset_HD 128
#define V_Target_Offset_HD 128
#define Y_Target_Gain_HD 235
#define U_Target_Gain_HD 214
#define V_Target_Gain_HD 230
*/
//VideoBook-ColorBar#2
#define Y_Target_Offset_SD 16
#define U_Target_Offset_SD 128
#define V_Target_Offset_SD 128
#define Y_Target_Gain_SD 235
#define U_Target_Gain_SD 187
#define V_Target_Gain_SD 200
//
#define Y_Target_Offset_HD 16
#define U_Target_Offset_HD 128
#define V_Target_Offset_HD 128
#define Y_Target_Gain_HD 235
#define U_Target_Gain_HD 187
#define V_Target_Gain_HD 200
#if 0
void ADC_Swap_Check_2547D(ADCRGBYUV_2547D *Swap)
{
UINT8 ii;
UINT8 jj;
UINT8 swap_type;
UINT8 Result[3][2];
UINT8 ADC_Swap_Condition[6][3][2] = {
{//Rin->R, Gin->G, Bin->B
{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4},{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5},{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3}
},
{//Gin->R, Rin->G, Bin->B
{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3},{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5},{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4}
},
{//Bin->R, Rin->G, Gin->B
{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3},{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4},{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5}
},
{//Rin->R, Bin->G, Gin->B
{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5},{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4},{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3}
},
{//Gin->R, Bin->G, Rin->B
{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5},{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3},{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4}
},
{//Bin->R, Gin->G, Rin->B
{ _P0_GRN_GAIN_C1, _P0_GRN_OFFSET_C4},{ _P0_RED_GAIN_C0, _P0_RED_OFFSET_C3},{ _P0_BLU_GAIN_C2, _P0_BLU_OFFSET_C5}
}
};
CScalerRead(_IPH_ACT_WID_H_16, 1, pData, _NON_AUTOINC);
swap_type=((pData[0]>>4) & 0x07);
//swap_type = (YPbPr_ReadByte( _IPH_ACT_WID_H_16)>>4)&&(0x07);
switch(swap_type)//Check Whether ADC Swap
{
case 0://Rin->R, Gin->G, Bin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[0][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[0],sizeof(UINT16)*3*6);
break;
case 1://Gin->R, Rin->G, Bin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[1][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[1],sizeof(UINT16)*3*6);
break;
case 3://Bin->R, Rin->G, Gin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[2][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[2],sizeof(UINT16)*3*6);
break;
case 4://Rin->R, Bin->G, Gin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[3][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[3],sizeof(UINT16)*3*6);
break;
case 5://Gin->R, Bin->G, Rin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[4][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[4],sizeof(UINT16)*3*6);
break;
default://Bin->R, Gin->G, Rin->B
for(ii=0;ii<3;ii++){
for(jj=0;jj<2;jj++)
Result[ii][jj] = ADC_Swap_Condition[5][ii][jj];
}
//memcpy(Result,&ADC_Swap_Condition[5],sizeof(UINT16)*3*6);
}
Swap->Y_ADC_GAIN = Result[0][0];
Swap->Y_ADC_OFFSET = Result[0][1];
Swap->U_ADC_GAIN = Result[1][0];
Swap->U_ADC_OFFSET = Result[1][1];
Swap->V_ADC_GAIN = Result[2][0];
Swap->V_ADC_OFFSET = Result[2][1];
}
#endif
BYTE CAutoTuneBalanceNew(void)
{
UINT16 Active_Region[4],Black_Pos[4],White_Pos[4],Magenta_Pos[4];
UINT8 Y_Target_Offset,U_Target_Offset,V_Target_Offset;
UINT8 Y_Target_Gain,U_Target_Gain,V_Target_Gain;
ADCRGBYUV_2547D ADC_2547D;
if(stModeInfo.ModeCurr >=4){//HD
Y_Target_Offset = Y_Target_Offset_HD;
U_Target_Offset = U_Target_Offset_HD;
V_Target_Offset = V_Target_Offset_HD;
Y_Target_Gain = Y_Target_Gain_HD;
U_Target_Gain = U_Target_Gain_HD;
V_Target_Gain = V_Target_Gain_HD;
}
else{//SD
Y_Target_Offset = Y_Target_Offset_SD;
U_Target_Offset = U_Target_Offset_SD;
V_Target_Offset = V_Target_Offset_SD;
Y_Target_Gain = Y_Target_Gain_SD;
U_Target_Gain = U_Target_Gain_SD;
V_Target_Gain = V_Target_Gain_SD;
}
ActiveRegion_2547D(&Active_Region[0]);
#if 1//eric 200706011 reduce size
#if(_ADC1_INPUT_SWAP_RG)
ADC_2547D.Y_ADC_GAIN = _P0_RED_GAIN_C0;
ADC_2547D.Y_ADC_OFFSET = _P0_RED_OFFSET_C3;
ADC_2547D.U_ADC_GAIN = _P0_BLU_GAIN_C2;
ADC_2547D.U_ADC_OFFSET = _P0_BLU_OFFSET_C5;
ADC_2547D.V_ADC_GAIN = _P0_GRN_GAIN_C1;
ADC_2547D.V_ADC_OFFSET = _P0_GRN_OFFSET_C4;
#elif(_ADC1_INPUT_SWAP_RB)
ADC_2547D.Y_ADC_GAIN = _P0_GRN_GAIN_C1;
ADC_2547D.Y_ADC_OFFSET = _P0_GRN_OFFSET_C4;
ADC_2547D.U_ADC_GAIN = _P0_RED_GAIN_C0;
ADC_2547D.U_ADC_OFFSET = _P0_RED_OFFSET_C3;
ADC_2547D.V_ADC_GAIN = _P0_BLU_GAIN_C2;
ADC_2547D.V_ADC_OFFSET = _P0_BLU_OFFSET_C5;
#elif(_ADC1_INPUT_SWAP_GB)
ADC_2547D.Y_ADC_GAIN = _P0_BLU_GAIN_C2;
ADC_2547D.Y_ADC_OFFSET = _P0_BLU_OFFSET_C5;
ADC_2547D.U_ADC_GAIN = _P0_GRN_GAIN_C1;
ADC_2547D.U_ADC_OFFSET = _P0_GRN_OFFSET_C4;
ADC_2547D.V_ADC_GAIN = _P0_RED_GAIN_C0;
ADC_2547D.V_ADC_OFFSET = _P0_RED_OFFSET_C3;
#else //non-swap
ADC_2547D.Y_ADC_GAIN =_P0_GRN_GAIN_C1;
ADC_2547D.Y_ADC_OFFSET = _P0_GRN_OFFSET_C4;
ADC_2547D.U_ADC_GAIN = _P0_BLU_GAIN_C2;
ADC_2547D.U_ADC_OFFSET = _P0_BLU_OFFSET_C5;
ADC_2547D.V_ADC_GAIN = _P0_RED_GAIN_C0;
ADC_2547D.V_ADC_OFFSET = _P0_RED_OFFSET_C3;
#endif
#else
ADC_Swap_Check_2547D(&ADC_2547D);
#endif
//Get Black, White, Magenta Position on the screen
HistPos( Active_Region[0], Active_Region[1], Active_Region[2], Active_Region[3], &Black_Pos[0], &White_Pos[0], &Magenta_Pos[0]);
Adjust_Loop(&Black_Pos[0], &White_Pos[0], 128, 128, ADC_2547D.Y_ADC_OFFSET, ADC_2547D.Y_ADC_GAIN, Channel_Y, Y_Target_Offset, Y_Target_Gain);
Adjust_Loop(&Black_Pos[0], &Magenta_Pos[0], 128, 128, ADC_2547D.U_ADC_OFFSET, ADC_2547D.U_ADC_GAIN, Channel_U, U_Target_Offset, U_Target_Gain);
Adjust_Loop(&Black_Pos[0], &Magenta_Pos[0], 128, 128, ADC_2547D.V_ADC_OFFSET, ADC_2547D.V_ADC_GAIN, Channel_V, V_Target_Offset, V_Target_Gain);
//Adjust_Loop(&Black_Pos[0], &White_Pos[0], 128, 128, _P0_GRN_OFFSET_C4, _P0_GRN_GAIN_C1, Channel_Y, Y_Target_Offset, Y_Target_Gain);
//Adjust_Loop(&Black_Pos[0], &Magenta_Pos[0], 128, 128, _P0_BLU_OFFSET_C5, _P0_BLU_GAIN_C2, Channel_U, U_Target_Offset, U_Target_Gain);
//Adjust_Loop(&Black_Pos[0], &Magenta_Pos[0], 128, 128, _P0_RED_OFFSET_C3, _P0_RED_GAIN_C0, Channel_V, V_Target_Offset, V_Target_Gain);
return (1);
}
void CYPbPrPorch_LevelCheck(void)
{
UINT16 Pos_Porch[4];
// UINT8 ucTemp;
CScalerSetByte(_VGIP_HV_DELAY_1E, 0x00);
#if 0
UINT16 lbound, rbound;
rbound = stModeUserData.Clock; // Totol Clock Number
lbound = (UINT32)rbound * stModeInfo.IHSyncPulseCount / stModeInfo.IHCount; // Clock number in HSYNC pulse
lbound = lbound+10;
rbound = lbound+10;
Pos_Porch[0] = lbound; // H Porch Start
Pos_Porch[1] = rbound; // H Porch End
// pData[0] = ((lbound >> 4) & 0x70) | (HIBYTE(rbound) & 0x0f);
// pData[1] = (LOBYTE(lbound)+0);
// pData[2] = (LOBYTE(rbound)+0);
lbound = stModeInfo.IVTotal/2;
rbound = lbound+10;
Pos_Porch[2] = lbound; // V
Pos_Porch[3] = rbound; // V
// pData[3] = ((lbound >> 4) & 0x70) | (HIBYTE(rbound) & 0x0f);
// pData[4] = (LOBYTE(lbound)+0);
// pData[5] = (LOBYTE(rbound )+0);
#else
ActiveRegion_2547D(&Pos_Porch[0]);
switch(stModeInfo.ModeCurr)
{
case _MODE_480I:
// Pos_Porch[0] = Pos_Porch[0] -38;//21;
// Pos_Porch[1] = Pos_Porch[0] + 3;
// Pos_Porch[2] = Pos_Porch[2] +10;
// Pos_Porch[3] = Pos_Porch[2] +10;
// break;
case _MODE_576I:
case _MODE_576P:
case _MODE_480P:
Pos_Porch[0] = 112;//92;
Pos_Porch[1] = 115;//97;
//Pos_Porch[0] = Pos_Porch[0] -18;
//Pos_Porch[1] = Pos_Porch[0] + 5;
Pos_Porch[2] = Pos_Porch[2] +10;
Pos_Porch[3] = Pos_Porch[2] +10;
break;
default: //HD(>720p)
Pos_Porch[0] = 170;
Pos_Porch[1] = 173;
//Pos_Porch[0] = Pos_Porch[0] -100;
//Pos_Porch[1] = Pos_Porch[0] + 8;
Pos_Porch[2] = Pos_Porch[2] +10;
Pos_Porch[3] = Pos_Porch[2] +10;
break;
}
#endif
if((FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 0) -16) != 0 || (FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 1) -128) != 0 || (FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 2)-128) != 0 ){
/*
ROSPrintf("ADC_Offset=(%d,%d,%d)\n",stYPbPrData.YPbPrOffset[_RED],stYPbPrData.YPbPrOffset[_GREEN] ,stYPbPrData.YPbPrOffset[_BLUE]);
ROSPrintf("ADC_Gain=(%d,%d,%d)\n",stYPbPrData.YPbPrGain[_RED],stYPbPrData.YPbPrGain[_GREEN] ,stYPbPrData.YPbPrGain[_BLUE]);
ROSPrintf("Porch Level mismatch:diff_Y=%d,diff_U=%d, diff_V=%d\n",(FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 0)-16), (FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 1)-128),(FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 2)-128));
ROSPrintf("after adjustment -->\n");
*/
#if(_ADC1_INPUT_SWAP_RG)
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_BLU_OFFSET_C5, stYPbPrData.YPbPrOffset[_BLUE], Channel_U);
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_GRN_OFFSET_C4, stYPbPrData.YPbPrOffset[_GREEN], Channel_V);
ADC_adjust_RTD2547D(&Pos_Porch[0], 16, _P0_RED_OFFSET_C3, stYPbPrData.YPbPrOffset[_RED], Channel_Y);
#elif(_ADC1_INPUT_SWAP_RB)
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_RED_OFFSET_C3, stYPbPrData.YPbPrOffset[_RED], Channel_U);
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_BLU_OFFSET_C5, stYPbPrData.YPbPrOffset[_BLUE], Channel_V);
ADC_adjust_RTD2547D(&Pos_Porch[0], 16, _P0_GRN_OFFSET_C4, stYPbPrData.YPbPrOffset[_GREEN], Channel_Y);
#elif(_ADC1_INPUT_SWAP_GB)
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_GRN_OFFSET_C4, stYPbPrData.YPbPrOffset[_GREEN], Channel_U);
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_RED_OFFSET_C3, stYPbPrData.YPbPrOffset[_RED], Channel_V);
ADC_adjust_RTD2547D(&Pos_Porch[0], 16, _P0_BLU_OFFSET_C5, stYPbPrData.YPbPrOffset[_BLUE], Channel_Y);
#else//non-swap
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_BLU_OFFSET_C5, stYPbPrData.YPbPrOffset[_BLUE], Channel_U);
ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_RED_OFFSET_C3, stYPbPrData.YPbPrOffset[_RED], Channel_V);
ADC_adjust_RTD2547D(&Pos_Porch[0], 16, _P0_GRN_OFFSET_C4, stYPbPrData.YPbPrOffset[_GREEN], Channel_Y);
#endif
//ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_BLU_OFFSET_AA, stYPbPrData.YPbPrOffset[_BLUE], 1);
//ADC_adjust_RTD2547D(&Pos_Porch[0], 128, _P0_RED_OFFSET_A8, stYPbPrData.YPbPrOffset[_RED], 2);
//ADC_adjust_RTD2547D(&Pos_Porch[0], 16, _P0_GRN_OFFSET_A9, stYPbPrData.YPbPrOffset[_GREEN], 0);
/*
ROSPrintf("Porch_LevelCheck: Y_Level=%d\n", FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 0));
ROSPrintf("Porch_LevelCheck: U_Level=%d\n", FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 1));
ROSPrintf("Porch_LevelCheck: V_Level=%d\n", FindDominant_RTD2547D_SmartFit(&Pos_Porch[0], 2));
*/
}
//else
// DebugPrintf("\n Porch Level match %c",0x20);
}
#endif
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -