📄 adjust.c
字号:
// Description : Adjust gamma
// Input Value : Gamma table type and gamma tables
// Output Value : None
//--------------------------------------------------
void CAdjustGamma(BYTE ucGammaTableType, BYTE *pGammaTableArrayR, BYTE *pGammaTableArrayG, BYTE *pGammaTableArrayB)
{
WORD cnt;
BYTE i, temp;
if((ucGammaTableType == _COMPACT_GAMMA_NORMAL_TABLE) || (ucGammaTableType == _FULL_GAMMA_NORMAL_TABLE))
{
CScalerSetByte(_GAMMA_CTRL_67, 0x80 | ucGammaTableType);
CScalerWrite(_GAMMA_PORT_66, ((ucGammaTableType == _COMPACT_GAMMA_NORMAL_TABLE) ? 256 : 384), pGammaTableArrayR, _NON_AUTOINC);
CScalerSetByte(_GAMMA_CTRL_67, 0x90 | ucGammaTableType);
CScalerWrite(_GAMMA_PORT_66, ((ucGammaTableType == _COMPACT_GAMMA_NORMAL_TABLE) ? 256 : 384), pGammaTableArrayG, _NON_AUTOINC);
CScalerSetByte(_GAMMA_CTRL_67, 0xa0 | ucGammaTableType);
CScalerWrite(_GAMMA_PORT_66, ((ucGammaTableType == _COMPACT_GAMMA_NORMAL_TABLE) ? 256 : 384), pGammaTableArrayB, _NON_AUTOINC);
CScalerSetByte(_GAMMA_CTRL_67, 0x40);
}
else if((ucGammaTableType == _COMPACT_GAMMA_COMPRESS_TABLE) || (ucGammaTableType == _FULL_GAMMA_COMPRESS_TABLE))
{
for(i=0;i<3;i++)
{
ucVLDCnt = 0;
ucVLDTemp = 0;
if(i == 0)
{
CScalerSetByte(_GAMMA_CTRL_67, 0x80 | (ucGammaTableType % 2));
pvldarray = (pGammaTableArrayR + 16);
}
else if(i == 1)
{
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);
}
}
//--------------------------------------------------
// Description : Set dithering
// Input Value : Dithering tables
// Output Value : None
//--------------------------------------------------
void CAdjustDither(BYTE *pDitherSeqTable, BYTE * pDitherTable)
{
CScalerSetBit(_DITHERING_CTRL_6B, ~(_BIT7 | _BIT6), _BIT7);
CScalerWrite(_DITHERING_SEQUENCE_TABLE_69, 24, pDitherSeqTable, _NON_AUTOINC);
CScalerSetBit(_DITHERING_CTRL_6B, ~(_BIT7 | _BIT6), _BIT6);
CScalerWrite(_DITHERING_TABLE_ACCESS_PORT_6A, 24, pDitherTable, _NON_AUTOINC);
CScalerSetByte(_DITHERING_CTRL_6B, 0x38);
}
//--------------------------------------------------
// Description : Adjust sharpness
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSharpness(void)
{
CAdjustSetSharpnessTable(tSU_COEF_TABLE[stSystemData.Sharpness & 0x0f], tSU_COEF_TABLE[stSystemData.Sharpness & 0x0f]);
}
//--------------------------------------------------
// Description : Set Sharpness Table
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustSetSharpnessTable(BYTE code *pArray0, BYTE code *pArray1)
{
CScalerSetByte(_FILTER_CTRL_1C, 0xb0); //Update by Realtek at 20050617
CScalerWrite(_FILTER_PORT_1D, 128, pArray0, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_1C, 0xc0);
CScalerWrite(_FILTER_PORT_1D, 128, pArray1, _NON_AUTOINC);
CScalerSetByte(_FILTER_CTRL_1C, 0x00);
}
//--------------------------------------------------
// Description : Adjust color precessing brightness
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustBrightness(void)
{
if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
pData[0] = pData[1] = pData[2] = ((stConBriData.Brightness > 2)? (stConBriData.Brightness - 2) : stConBriData.Brightness);
else
pData[0] = pData[1] = pData[2] = stConBriData.Brightness;
CScalerWrite(_BRI_RED_COE_60, 3, pData, _AUTOINC);
}
//--------------------------------------------------
// Description : Adjust color processing contrast
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustContrast(void)
{
BYTE cnt;
for(cnt=0;cnt<3;cnt++)
pData[cnt] = (((WORD)stColorTempData.ColorTemp[cnt] * stConBriData.Contrast / 128) > 255) ? 255 : (BYTE)((WORD)stColorTempData.ColorTemp[cnt] * stConBriData.Contrast / 128);
CScalerWrite(_CTS_RED_COE_63, 3, pData, _AUTOINC);
}
//--------------------------------------------------
// Description : Adjust backlight
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustBacklight(void)
{
// evan 0508511
#if (_BACKLIGHT_PWM_INVERSE == _ENABLE)
BL_BRIGHT_PORT = _BACKLIGHT_MAX - stSystemData.BackLight;
#else
BL_BRIGHT_PORT = stSystemData.BackLight;
/*
BL_BRIGHT_PORT = stSystemData.BackLight>>2;
CTimerDelayXms(3);
BL_BRIGHT_PORT = stSystemData.BackLight>>1;
CTimerDelayXms(3);
BL_BRIGHT_PORT = stSystemData.BackLight>>1+stSystemData.BackLight>>2;
CTimerDelayXms(3);
BL_BRIGHT_PORT = stSystemData.BackLight;
*/
#endif
/*
pData[0] = 0x00 | (_BACKLIGHT_PWM << 6);
pData[1] = 0x01;
#if(_BACKLIGHT_PWM_INVERSE == _ENABLE)
pData[2] = _BACKLIGHT_MAX - stSystemData.BackLight;
#else
pData[2] = stSystemData.BackLight;
#endif
CScalerWrite(_OSD_ADDR_MSB_90, 3, pData, _AUTOINC);
*/
}
//--------------------------------------------------
// Description : Adjust ADC gain
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustAdcGain(void) //This function updated by Realtek at 20050617
{
#if(_ADC_INPUT_SWAP_RG == _ON)
CScalerSetByte(_GRN_GAIN_E1, stAdcData.AdcGain[_RED]);
CScalerSetByte(_RED_GAIN_E0, stAdcData.AdcGain[_GREEN]);
CScalerSetByte(_BLU_GAIN_E2, stAdcData.AdcGain[_BLUE]);
#elif(_ADC_INPUT_SWAP_RB == _ON)
CScalerSetByte(_BLU_GAIN_E2, stAdcData.AdcGain[_RED]);
CScalerSetByte(_GRN_GAIN_E1, stAdcData.AdcGain[_GREEN]);
CScalerSetByte(_RED_GAIN_E0, stAdcData.AdcGain[_BLUE]);
#elif(_ADC_INPUT_SWAP_GB == _ON)
CScalerSetByte(_RED_GAIN_E0, stAdcData.AdcGain[_RED]);
CScalerSetByte(_BLU_GAIN_E2, stAdcData.AdcGain[_GREEN]);
CScalerSetByte(_GRN_GAIN_E1, stAdcData.AdcGain[_BLUE]);
#else
CScalerSetByte(_RED_GAIN_E0, stAdcData.AdcGain[_RED]);
CScalerSetByte(_GRN_GAIN_E1, stAdcData.AdcGain[_GREEN]);
CScalerSetByte(_BLU_GAIN_E2, stAdcData.AdcGain[_BLUE]);
#endif
}
//--------------------------------------------------
// Description : Adjust ADC offset
// Input Value : None
// Output Value : None
//--------------------------------------------------
void CAdjustAdcOffset(void) //This function updated by Realtek at 20050617
{
#if(_ADC_INPUT_SWAP_RG == _ON)
CScalerSetByte(_GRN_OFFSET_E4, stAdcData.AdcOffset[_RED]);
CScalerSetByte(_RED_OFFSET_E3, stAdcData.AdcOffset[_GREEN]);
CScalerSetByte(_BLU_OFFSET_E5, stAdcData.AdcOffset[_BLUE]);
#elif(_ADC_INPUT_SWAP_RB == _ON)
CScalerSetByte(_BLU_OFFSET_E5, stAdcData.AdcOffset[_RED]);
CScalerSetByte(_GRN_OFFSET_E4, stAdcData.AdcOffset[_GREEN]);
CScalerSetByte(_RED_OFFSET_E3, stAdcData.AdcOffset[_BLUE]);
#elif(_ADC_INPUT_SWAP_GB == _ON)
CScalerSetByte(_RED_OFFSET_E3, stAdcData.AdcOffset[_RED]);
CScalerSetByte(_BLU_OFFSET_E5, stAdcData.AdcOffset[_GREEN]);
CScalerSetByte(_GRN_OFFSET_E4, stAdcData.AdcOffset[_BLUE]);
#else
CScalerSetByte(_RED_OFFSET_E3, stAdcData.AdcOffset[_RED]);
CScalerSetByte(_GRN_OFFSET_E4, stAdcData.AdcOffset[_GREEN]);
CScalerSetByte(_BLU_OFFSET_E5, stAdcData.AdcOffset[_BLUE]);
#endif
}
//--------------------------------------------------
// 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);
}
//--------------------------------------------------
// Description : Apply color palette setting
// Input Value : Color palette table
// Output Value : None
//--------------------------------------------------
void CAdjustColorPalette(BYTE *pColorPaletteArray)
{
CScalerSetByte(_OVERLAY_LUT_ADDR_6E, 0x80);
CScalerWrite(_COLOR_LUT_PORT_6F, 48, pColorPaletteArray, _NON_AUTOINC);
CScalerSetByte(_OVERLAY_LUT_ADDR_6E, 0x00);
}
//--------------------------------------------------
// 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)
{
/*
((LWORD *)pData)[0] = ((LWORD)stDisplayInfo.DHTotal * Panel.DVStartPos) + Panel.DHStartPos;
((LWORD *)pData)[0] = ((LWORD *)pData)[0] * stModeInfo.IVHeight / stDisplayInfo.DVHeight * stModeInfo.IHTotal / stDisplayInfo.DHTotal;
((LWORD *)pData)[1] = ((LWORD)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
((LWORD *)pData)[1] += (stModeInfo.IHTotal * 1) + 640;
}
else
{
if (ucOption & _BIT1)
{
// V scale-down. Target 1.75 IHS delay
((LWORD *)pData)[1] += stModeInfo.IHTotal + ((LWORD)640 * stModeInfo.IVHeight / stDisplayInfo.DVHeight);
}
else
{
// V no scaling. Target 1.50 IHS delay
((LWORD *)pData)[1] += stModeInfo.IHTotal + 640;
}
// Turn on full-line buffer
((LWORD *)pData)[1] += stModeInfo.IHTotal;
CScalerSetBit(_SCALE_CTRL_19, ~_BIT4, _BIT4);
}
if (((LWORD *)pData)[0] > ((LWORD *)pData)[1])
{
// You should never get into this code ....
}
((LWORD *)pData)[0] = ((LWORD *)pData)[1] - ((LWORD *)pData)[0];
pData[14] = ((LWORD *)pData)[0] / stModeInfo.IHTotal;
pData[15] = (((LWORD *)pData)[0] - ((LWORD)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];
*/
// version 200D
((LWORD *)pData)[0] = ((LWORD)stDisplayInfo.DHTotal * stDisplayInfo.DVStartPos) + Panel.DHStartPos;
((LWORD *)pData)[0] = ((LWORD *)pData)[0] * stModeInfo.IVHeight / stDisplayInfo.DVHeight * stModeInfo.IHTotal / stDisplayInfo.DHTotal;
((LWORD *)pData)[1] = ((LWORD)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
((LWORD *)pData)[1] += (stModeInfo.IHTotal * 1) + 640;
}
else
{
if (ucOption & _BIT1)
{
// V scale-down. Target 1.75 IHS delay
((LWORD *)pData)[1] += stModeInfo.IHTotal + ((LWORD)640 * stModeInfo.IVHeight / stDisplayInfo.DVHeight);
}
else
{
// V no scaling. Target 1.50 IHS delay
((LWORD *)pData)[1] += stModeInfo.IHTotal + 640;
}
// Turn on full-line buffer
((LWORD *)pData)[1] += stModeInfo.IHTotal;
CScalerSetBit(_SCALE_CTRL_19, ~_BIT4, _BIT4);
}
if (((LWORD *)pData)[0] > ((LWORD *)pData)[1])
{
// You should never get into this code ....
}
((LWORD *)pData)[0] = ((LWORD *)pData)[1] - ((LWORD *)pData)[0];
pData[14] = ((LWORD *)pData)[0] / stModeInfo.IHTotal;
pData[15] = (((LWORD *)pData)[0] - ((LWORD)stModeInfo.IHTotal * pData[14])) / 16;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -