📄 adjust.c
字号:
CScalerSetByte(_GAMMA_CTRL_67, 0x90 | (ucGammaTableType % 2));
pvldarray = (pGammaTableArrayG + 16);
}
else
{
CScalerSetByte(_GAMMA_CTRL_67, 0xa0 | (ucGammaTableType % 2));
pvldarray = (pGammaTableArrayB + 16);
}
for(temp=0;temp<16;temp++)
pData[temp] = *(pvldarray + temp - 16);
for(cnt=0;cnt<((ucGammaTableType == _COMPACT_GAMMA_COMPRESS_TABLE) ? 256 : 384);cnt++)
{
temp = CScalerGetVLD() << 4;
temp |= CScalerGetVLD();
CScalerSetByte(_GAMMA_PORT_66, temp);
}
}
CScalerSetByte(_GAMMA_CTRL_67, 0x40);
}
}
#if(_GAMMA_TYPE == _FULL_GAMMA_COMPRESS_TABLE2)
void CRtdWriteGamma(UINT8 *array)
{
int i,k=0,m=0;
int tmp;
int diff0;
int d2;
int k0;
int outA;
k0=outA=*array++; // //2x+0
diff0=*(array++);
for (i=0;i<256;i+=2)
{
tmp=*(array++);
//---even----------------------
d2=(tmp>>4)-8;
if (d2==-8)
d2=(char)*(array++);
// dump k0
CScalerSetByte(_GAMMA_PORT_66,(k0>>2));
outA=outA+diff0; // 2x+1
// dump d0,
CScalerSetByte(_GAMMA_PORT_66,(((k0&3)<<6)|diff0));
diff0=diff0+d2; // d[2x+1]
// dump d1
if (i==254)
diff0=0; // Last item :: without d2;
CScalerSetByte(_GAMMA_PORT_66,(diff0));
m++;
k++;
//---odd-----------------------
d2=(tmp&0xf)-8;
if(d2 == -8)
d2 = (char)*array++;
k0 = outA = outA + diff0;
diff0 = diff0 + d2; // d[2x+1];
m++;
k++;
}
}
#endif
//--------------------------------------------------
// Description : Set dithering
// Input Value : Dithering tables
// Output Value : None
//--------------------------------------------------
void CAdjustDither(BYTE *pDitherSeqTable, BYTE * pDitherTable)
{
CScalerSetBit(_DITHERING_CTRL_6A, ~(_BIT7 | _BIT6), _BIT6);
CScalerWrite(_DITHERING_DATA_ACCESS_69, 24, pDitherSeqTable, _NON_AUTOINC);
CScalerSetBit(_DITHERING_CTRL_6A, ~(_BIT7 | _BIT6), _BIT7);
CScalerWrite(_DITHERING_DATA_ACCESS_69, 24, pDitherTable, _NON_AUTOINC);
CScalerSetByte(_DITHERING_CTRL_6A, 0x38);
}
//--------------------------------------------------
// Description : Adjust sharpness for scale up
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSharpnessForScaleUp(void)
{
CAdjustSetSharpnessTable(_SCALE_UP,tSU_COEF_TABLE[stSystemData.Sharpness & 0x0f], tSU_COEF_TABLE[stSystemData.Sharpness & 0x0f]);
}
//--------------------------------------------------
// Description : Adjust sharpness for scale down
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSharpnessForScaleDown(void)
{
CAdjustSetSharpnessTable(_SCALE_DOWN, tSCALE_DOWN_COEF_TABLE[stSystemData.Sharpness & 0x0f], tSCALE_DOWN_COEF_TABLE[stSystemData.Sharpness & 0x0f]);
}
//--------------------------------------------------
// Description : Set Sharpness Table
// Input Value : 1: Scale-Up
// 0: Scale-Down
// Output Value : None
//--------------------------------------------------
void CAdjustSetSharpnessTable(bit scaling, BYTE code *pArray0, BYTE code *pArray1)
{
if(scaling)
{
CScalerSetByte(_FILTER_CTRL_35, 0xb0);
CScalerWrite(_FILTER_ACCESS_PORT_36, 128, pArray0, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_35, 0xc0);
CScalerWrite(_FILTER_ACCESS_PORT_36, 128, pArray1, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_35, 0x00);
CScalerSetByte(_FILTER_CTRL_35, 0x0b);
CScalerWrite(_FILTER_ACCESS_PORT_36, 128, pArray0, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_35, 0x0c);
CScalerWrite(_FILTER_ACCESS_PORT_36, 128, pArray1, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_35, 0x00);
}
else
{
CScalerPageSelect(_PAGE6);
CScalerSetByte(_P6_UZD_FIR_COEF_INDEX_F3, 0x00);
CScalerWrite(_P6_UZD_FIR_COEF_PORT_F4, 64, pArray0, _NON_AUTOINC);
CScalerSetByte(_P6_UZD_FIR_COEF_INDEX_F3, 0x80);
CScalerWrite(_P6_UZD_FIR_COEF_PORT_F4, 64, pArray1, _NON_AUTOINC);
CScalerSetByte(_P6_UZD_FIR_COEF_INDEX_F3, 0x00);
}
}
//--------------------------------------------------
// Description : Adjust color precessing brightness
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSetBrightness(void)
{
CScalerSetByte(_CB_ACCESS_PORT_64, 0x80);
CScalerWrite(_CB_DATA_PORT_65, 3, pData, _NON_AUTOINC);
CScalerSetByte(_CB_ACCESS_PORT_64, 0x00);
}
//--------------------------------------------------
// Description : Adjust color processing contrast
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSetContrast(void)
{
CScalerSetByte(_CB_ACCESS_PORT_64, 0x83);
CScalerWrite(_CB_DATA_PORT_65, 3, pData, _NON_AUTOINC);
CScalerSetByte(_CB_ACCESS_PORT_64, 0x00);
}
//--------------------------------------------------
// Description : Adjust ADC gain
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustAdcGain(void)
{
if(_GET_INPUT_SOURCE() == _SOURCE_VGA)
{
#if(_ADC0_INPUT_SWAP_RG == _ON)
pData[1] = stAdcData.AdcGain[_RED];
pData[0] = stAdcData.AdcGain[_GREEN];
pData[2] = stAdcData.AdcGain[_BLUE];
#elif(_ADC0_INPUT_SWAP_RB == _ON)
pData[2] = stAdcData.AdcGain[_RED];
pData[1] = stAdcData.AdcGain[_GREEN];
pData[0] = stAdcData.AdcGain[_BLUE];
#elif(_ADC0_INPUT_SWAP_GB == _ON)
pData[0] = stAdcData.AdcGain[_RED];
pData[2] = stAdcData.AdcGain[_GREEN];
pData[1] = stAdcData.AdcGain[_BLUE];
#else
pData[0] = stAdcData.AdcGain[_RED];
pData[1] = stAdcData.AdcGain[_GREEN];
pData[2] = stAdcData.AdcGain[_BLUE];
#endif//(_ADC_INPUT_SWAP_RG == _ON)
}
else// if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
{
#if(_ADC1_INPUT_SWAP_RG == _ON)
pData[1] = stYPbPrData.YPbPrGain[_RED];
pData[0] = stYPbPrData.YPbPrGain[_GREEN];
pData[2] = stYPbPrData.YPbPrGain[_BLUE];
#elif(_ADC1_INPUT_SWAP_RB == _ON)
pData[2] = stYPbPrData.YPbPrGain[_RED];
pData[1] = stYPbPrData.YPbPrGain[_GREEN];
pData[0] = stYPbPrData.YPbPrGain[_BLUE];
#elif(_ADC1_INPUT_SWAP_GB == _ON)
pData[0] = stYPbPrData.YPbPrGain[_RED];
pData[2] = stYPbPrData.YPbPrGain[_GREEN];
pData[1] = stYPbPrData.YPbPrGain[_BLUE];
#else
pData[0] = stYPbPrData.YPbPrGain[_RED];
pData[1] = stYPbPrData.YPbPrGain[_GREEN];
pData[2] = stYPbPrData.YPbPrGain[_BLUE];
#endif
}
{
CScalerPageSelect(_PAGE0);
CScalerWrite(_P0_RED_GAIN_C0, 3, pData, _AUTOINC);
}
}
//--------------------------------------------------
// Description : Adjust ADC offset
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustAdcOffset(void)
{
if(_GET_INPUT_SOURCE() == _SOURCE_VGA)
{
#if(_ADC0_INPUT_SWAP_RG == _ON)
pData[4] = stAdcData.AdcOffset[_RED];
pData[3] = stAdcData.AdcOffset[_GREEN];
pData[5] = stAdcData.AdcOffset[_BLUE];
#elif(_ADC0_INPUT_SWAP_RB == _ON)
pData[5] = stAdcData.AdcOffset[_RED];
pData[4] = stAdcData.AdcOffset[_GREEN];
pData[3] = stAdcData.AdcOffset[_BLUE];
#elif(_ADC0_INPUT_SWAP_GB == _ON)
pData[3] = stAdcData.AdcOffset[_RED];
pData[5] = stAdcData.AdcOffset[_GREEN];
pData[4] = stAdcData.AdcOffset[_BLUE];
#else
pData[3] = stAdcData.AdcOffset[_RED];
pData[4] = stAdcData.AdcOffset[_GREEN];
pData[5] = stAdcData.AdcOffset[_BLUE];
#endif
}
else
{
#if(_ADC1_INPUT_SWAP_RG == _ON)
pData[4] = stYPbPrData.YPbPrOffset[_RED];
pData[3] = stYPbPrData.YPbPrOffset[_GREEN];
pData[5] = stYPbPrData.YPbPrOffset[_BLUE];
#elif(_ADC1_INPUT_SWAP_RB == _ON)
pData[5] = stYPbPrData.YPbPrOffset[_RED];
pData[4] = stYPbPrData.YPbPrOffset[_GREEN];
pData[3] = stYPbPrData.YPbPrOffset[_BLUE];
#elif(_ADC1_INPUT_SWAP_GB == _ON)
pData[3] = stYPbPrData.YPbPrOffset[_RED];
pData[5] = stYPbPrData.YPbPrOffset[_GREEN];
pData[4] = stYPbPrData.YPbPrOffset[_BLUE];
#else
pData[3] = stYPbPrData.YPbPrOffset[_RED];
pData[4] = stYPbPrData.YPbPrOffset[_GREEN];
pData[5] = stYPbPrData.YPbPrOffset[_BLUE];
#endif
}
{
CScalerPageSelect(_PAGE0);
//pData[3] = pData[4] = pData[5] = 0x80; //provisional 既﹚
CScalerWrite(_P0_RED_OFFSET_C3, 3, &pData[3], _AUTOINC);
}
}
//--------------------------------------------------
// Description : Adjust ADC gain and offset
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustAdcGainOffset(void)
{
CAdjustAdcGain();
CAdjustAdcOffset();
}
//--------------------------------------------------
// Description : Adjust background color
// Input Value : Red, green and blue color settings
// Output Value : None
//--------------------------------------------------
void CAdjustBackgroundColor(BYTE ucRed, BYTE ucGreen, BYTE ucBlue)
{
CScalerSetBit(_OVERLAY_CTRL_6C, ~_BIT5, 0x00);
CScalerSetBit(_OVERLAY_CTRL_6C, ~_BIT5, _BIT5);
CScalerSetByte(_BGND_COLOR_CTRL_6D, ucRed);
CScalerSetByte(_BGND_COLOR_CTRL_6D, ucGreen);
CScalerSetByte(_BGND_COLOR_CTRL_6D, ucBlue);
CScalerSetBit(_OVERLAY_CTRL_6C, ~_BIT5, 0x00);
}
bit CheckInterLace(void)
{
CTimerDelayXms(200);
CScalerRead(_IPV_ACT_LEN_H_1A, 1, pData, _NON_AUTOINC);
if(pData[0] & 0x20)
return 1;
return 0;
}
//----------------------------------------------------------------------
void CAdjustInterlaceIVS2DVSDelay(void)
{
UINT16 usTemp;
if(CTimerPollingEventProc(5, CheckInterLace))
//CScalerRead(_IPV_ACT_LEN_H_1A, 1, pData, _NON_AUTOINC);
//if(pData[0] & 0x20)
{
CScalerSetBit(_SCALE_CTRL_32, ~(_BIT7 | _BIT6), _BIT7);
CScalerRead(_IPV_ACT_LEN_H_1A, 2, pData, _AUTOINC);
usTemp = (((WORD) pData[0] & 0x07) << 8) | (WORD) pData[1];
if(usTemp <= 288) //480i 576i
CScalerSetBit(_VGIP_SIGINV_11, ~_BIT4, 0);
else
CScalerSetBit(_VGIP_SIGINV_11, ~_BIT4, _BIT4);
CScalerRead(_IV_DV_DELAY_CLK_ODD_41, LENGTH(1), pData, _NON_AUTOINC);
usTemp = (WORD)pData[0] * 16 + 16;
usTemp += stModeInfo.IHTotal/2;
CScalerSetByte(_IV_DV_DELAY_CLK_ODD_41, ((usTemp - 16) / 16));
usTemp -= stModeInfo.IHTotal / 2;
//usTemp += stModeInfo.IHTotal / 2;
CScalerSetByte(_IV_DV_DELAY_CLK_EVEN_42, ((usTemp - 16) / 16));
CScalerSetBit(_FS_DELAY_FINE_TUNING_43, ~_BIT1, _BIT1);
CScalerSetBit(_IPV_ACT_LEN_H_1A, 0xff, 0x20); //forster modified 061123 to fix the frame sync problem
}
}
//--------------------------------------------------
// Description : Calculate the suitable IVS to DVS delay
// CR[38] : IVS to DVS delay in IHS lines
// CR[1E] : IVS to DVS delay in ICLK * 16
// Input Value : Scaling setting
// Output Value : IV to DV delay lines
//--------------------------------------------------
BYTE CAdjustIVS2DVSDelay(BYTE ucOption)
{
// ((DWORD *)pData)[0] = ((DWORD)stDisplayInfo.DHTotal * stDisplayInfo.DVStartPos) + Panel[ucPanelSelect]->DHStartPos;
((DWORD *)pData)[0] = ((DWORD)stDisplayInfo.DHTotal * Panel[ucPanelSelect]->DVStartPos) + Panel[ucPanelSelect]->DHStartPos;
((DWORD *)pData)[0] = ((DWORD *)pData)[0] * stModeInfo.IVHeight / stDisplayInfo.DVHeight * stModeInfo.IHTotal / stDisplayInfo.DHTotal;
((DWORD *)pData)[1] = ((DWORD)stModeInfo.IHTotal * (stModeInfo.IVStartPos - (ucVStartBias + _PROGRAM_VDELAY))) + stModeInfo.IHStartPos - (ucHStartBias + _PROGRAM_HDELAY);
if(ucOption & _BIT0)
{
// V scale-up. Target 2.50 IHS delay
// Reg[40] = 0 ==> Delay 1 line
//((DWORD *)pData)[1] += (stModeInfo.IHTotal * 1) + 640;
//eric 20070620
CScalerPageSelect(_PAGE6);
//if((CScalerGetBit(_P6_UZD_CTRL0_E3, _BIT1 | _BIT0)) && (~(bit)(CScalerGetBit(_P6_UZD_CTRL0_E3, _BIT4))))
if((~(bit)(CScalerGetBit(_P6_UZD_CTRL0_E3, _BIT4))) &&(CScalerGetBit(_P6_UZD_CTRL0_E3, _BIT1))&&(CScalerGetBit(_P6_UZD_CTRL0_E3, _BIT0)))
((DWORD *)pData)[1] += (stModeInfo.IHTotal * 2) + 640;
else
((DWORD *)pData)[1] += (stModeInfo.IHTotal * 1) + 640;
}
else
{
if (ucOption & _BIT1)
{
// V scale-down. Target 1.75 IHS delay
((DWORD *)pData)[1] += stModeInfo.IHTotal + ((DWORD)640 * stModeInfo.IVHeight / stDisplayInfo.DVHeight);
}
else
{
// V no scaling. Target 1.50 IHS delay
((DWORD *)pData)[1] += stModeInfo.IHTotal + 640;
}
// Turn on full-line buffer
((DWORD *)pData)[1] += stModeInfo.IHTotal;
CScalerSetBit(_SCALE_CTRL_32, ~_BIT4, _BIT4);
}
if (((DWORD *)pData)[0] > ((DWORD *)pData)[1])
{
// You should never get into this code ....
}
((DWORD *)pData)[0] = ((DWORD *)pData)[1] - ((DWORD *)pData)[0];
pData[14] = ((DWORD *)pData)[0] / stModeInfo.IHTotal;
pData[15] = (((DWORD *)pData)[0] - ((DWORD)stModeInfo.IHTotal * pData[14])) / 16;
CScalerSetBit(_FS_DELAY_FINE_TUNING_43, ~_BIT1, 0x00);
CScalerSetByte(_IVS2DVS_DELAY_LINES_40, pData[14]);
CScalerSetByte(_IV_DV_DELAY_CLK_ODD_41, pData[15]);
return pData[14];
}
//--------------------------------------------------
// Description : Set display clock (Dclk) frequency in kHz
// Input Value : ulFreq --> Target Dclk frequency
// Output Value : None
//--------------------------------------------------
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -