26xx_adjust.c

GM5621原代码

		// garbage that may display when mode changes while OSD is up.
		HideOsd();
		gm_ForceModeSwitching();
	}

}

//factory
#ifdef Action_AdjustFactoryADCGain_WB_Used
   void far AdjustFactoryADCGain(void)
   {
		UserPrefAdcRedGain = UserPrefFactoryGainRed ;
		UserPrefAdcGreenGain = UserPrefFactoryGainGreen ;
		UserPrefAdcBlueGain = UserPrefFactoryGainBlue ;

		gm_SetAdcGainMain(UserPrefAdcRedGain,UserPrefAdcGreenGain,UserPrefAdcBlueGain);
   }
#endif

#ifdef Action_AdjustFactoryBlendValue_WB_Used

	//this function is called everytime the factory Osd menu is displayed.
   void far AdjustFactoryBlendValueFromOsdDisplay(void)
   {
			AdjustFactoryBlendValue();
   }

   void far AdjustFactoryBlendValue(void)
   {
		BYTE i;

		msgx("Val =%d ", UserPrefFactoryBlendValue);

		for (i = 0; i < 4; i++)
		{
			gm_WriteRegByte( OSD_BLEND_TABLE0 + i,
				(UserPrefFactoryBlendValue << 4) | UserPrefFactoryBlendValue);
		}
		gm_WriteRegByte(HOST_CONTROL, DPSYNC_UPDATE);
   }
#endif

	void far AdjustFactoryBrightness(void)
	{
#ifdef Action_AdjustFactoryBrightness_WB_Used
		UserPrefBrightness = UserPrefFactorysRGBBrightnessValue ;
		AdjustBrightness();
#endif
	}

	void far AdjustFactorysRGBContrast(void)
	{
#ifdef Action_AdjustFactorysRGBContrast_WB_Used
		UserPrefContrast = UserPrefFactorysRGBContrastValue;

		// adjust color based on contrast and user color setting
		AdjustColor();
#endif
	}

	void far AdjustFactoryUserColor(void)
   {
#ifdef Action_AdjustFactoryUserColor_WB_Used
		UserPrefRedColor = UserPrefFactoryColorTempAdjRed ;
      UserPrefGreenColor= UserPrefFactoryColorTempAdjGreen ;
      UserPrefBlueColor = UserPrefFactoryColorTempAdjBlue ;

		// adjust color based on contrast and user color setting
//      #ifdef Action_AdjustColor_WB_Used
      AdjustColor();
//      #endif

#endif
   }

  
	void far SetFactoryBlendValue(void){;}

  	void far FactoryMenuGmRead(void)
   {
		#ifdef UserPrefFactoryGmRegAddress
		UserPrefFactoryGmRegValue = gm_ReadRegByte((0x8000+UserPrefFactoryGmRegAddress));
      msgx("UserPrefFactoryGmRegValue = %d ", UserPrefFactoryGmRegValue);
      #endif
   }

	void far FactoryMenuGmWrite(void)
   {
		#ifdef UserPrefFactoryGmRegAddress
		gm_WriteRegByte((0x8000+UserPrefFactoryGmRegAddress), UserPrefFactoryGmRegValue);
		msgx("UserPrefFactoryGmRegValue = %d ", UserPrefFactoryGmRegValue);
      #endif
   }

	void far ResetFactoryDependentSettings(void)
	{
		#ifdef Action_AdjustFactoryBrightness_WB_Used
		UserPrefAdcRedGain = UserPrefFactoryGainRed ;
		UserPrefAdcGreenGain = UserPrefFactoryGainGreen;
		UserPrefAdcBlueGain = UserPrefFactoryGainBlue;

		LoadFactoryColorTempSettings();

		UserPrefBrightness = UserPrefFactorysRGBBrightnessValue ;
		UserPrefContrast = UserPrefFactorysRGBContrastValue;
		SaveFactorySettings();
      #endif
	}

	void far LoadFactoryColorTempSettings(void)
	{
		#ifdef Action_AdjustFactoryColorTemp_WB_Used
		ColorTempType S_ColorTemp;
		//get the rgb values from nvram
		LoadColorTemp(UserPrefColor, (BYTE *) &S_ColorTemp);

		UserPrefFactoryColorTempAdjRed = S_ColorTemp.R;
		UserPrefFactoryColorTempAdjGreen = S_ColorTemp.G;
		UserPrefFactoryColorTempAdjBlue = S_ColorTemp.B;
		#endif
	}

	void far SaveFactoryColorTempSettings (void)
	{
		#ifdef Action_AdjustFactoryColorTemp_WB_Used
		ColorTempType S_ColorTemp;

		S_ColorTemp.R = UserPrefFactoryColorTempAdjRed;
		S_ColorTemp.G = UserPrefFactoryColorTempAdjGreen;
		S_ColorTemp.B = UserPrefFactoryColorTempAdjBlue;

		SaveColorTemp (UserPrefColor, (BYTE *) &S_ColorTemp);
		#endif
	}

	void far RefreshFactoryGlobals(BYTE value)
   {
	#ifdef Action_AdjustFactoryBrightness_WB_Used
		if(value == 0)
			AdjustFactoryBrightness();
		else if(value == 1)
			AdjustFactorysRGBContrast();
		else if(value == 2)
			AdjustFactoryUserColor();
	#else
			value = value;
	#endif
   }

   void far DoAutoColor(void)
	{
		#ifdef Action_AdjustFactoryColorTemp_WB_Used
		
		// Louis 0816
		#if Enable_AOC
			DisableAOCMain();
		#endif
			
      StopADCCalibrationISR();
      gm_AutoColorBalanceMain();
      InitCalValues(); // phyang 09/08/05: Need to update calibration reference values.
      ADCQuickCalibrate();
      StartADCCalibrationISR();

		// Louis 0816
		#if Enable_AOC
			EnableAOCMain();
		#endif
      #endif
	}


//******************************************************************
// FUNCTION       :  InitFactoryDependentSettings
// DESCRIPTION 	:	Sets UserPrefFactory settings from FactoryDefaultsInROM
//******************************************************************
void far InitFactoryDependentSettings(void)
{
	#ifdef Action_AdjustFactoryBrightness_WB_Used
	UserPrefFactoryGainRed = 	FactoryDefaultInROM.AdcRedGain;
	UserPrefFactoryGainGreen = 	FactoryDefaultInROM.AdcGreenGain;
	UserPrefFactoryGainBlue = 	FactoryDefaultInROM.AdcBlueGain;

	UserPrefFactorysRGBBrightnessValue = FactoryDefaultInROM.Brightness;
	UserPrefFactorysRGBContrastValue = FactoryDefaultInROM.Contrast;

	UserPrefFactoryBrightnessMaxSetting = 255;
	UserPrefFactoryContrastMaxSetting = 255;
	UserPrefFactoryBrightnessMinSetting = 1;
	UserPrefFactoryContrastMinSetting  = 1;
	UserPrefFactoryBlendValue = 0;
	UserPrefMonitorOnTime = 0 ;
	UserPrefBacklightOnTime = 0;
	UserPrefFactoryBurnInMode = 0;
	UserPrefPowerOnTimes = 0;


	InitColorTempSettings(gmd_FALSE);
	LoadFactoryColorTempSettings();
	#endif
}


	void far SaveFactorySettings(void)
	{
		#ifdef Action_FactoryReset_WB_Used
			SaveFactoryDependentSettings();
      #endif
   }

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
void OnTimeKeeper(void)
{
#ifdef UserPrefMonitorOnTime
	 //Take timeStamp

	DWORD CurrentOnTime = gm_ReadSystemTime();
   BYTE decTimer ;

	decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(3600000L)); //??Checking for 1 hrs

	if(decTimer)
	{
		prevOnTime = CurrentOnTime ;
	 	//SystemOnTime
		if (UserPrefMonitorOnTime <= 0xFFFE)
			UserPrefMonitorOnTime++ ;

		//BacklightOnTime
		if ((PowerUpFlag.SoftPowerOnState) || (PowerUpFlag.SyncPowerOnState))
		{
			if (UserPrefBacklightOnTime <= 0xFFFE)
				UserPrefBacklightOnTime++ ;
		}
		SaveFactoryDependentSettings();
	 }
#endif
}

#if defined(Action_AdjustColor_WB_Used) | defined(Action_AdjustContrast_WB_Used)

//******************************************************************
// DESCRIPTION 	:	Color adjuster function using RGB
// SYNTEX		:	void AdjustColor(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
void far AdjustColor()
{
	WORD contrast;
	WORD red,grn,blu;
	ColorTempType S_ColorTemp;
	DWORD startTime;


	if (UserPrefColor == CTEMP_USER )
	{
		msg("CTEMP_USER %d", (WORD)UserPrefColor);
		red = UserPrefRedColor;
		grn = UserPrefGreenColor;
		blu = UserPrefBlueColor;
	}
	else
	{
		//get the rgb values from nvram
	#ifdef	NVRAM_BLOCK_ColorTemp_WB_Used
   	#if NVRAM_USE_FLASH
         LoadColorTemp(UserPrefColor, (BYTE *) &S_ColorTemp);
         red = S_ColorTemp.R;
         grn = S_ColorTemp.G;
         blu = S_ColorTemp.B;
		#else
         // if Color temp not stored in NVRAM, use sRGB settings.
         red = ColorTempConst[UserPrefColor][0];
         grn = ColorTempConst[UserPrefColor][1];
         blu = ColorTempConst[UserPrefColor][2];
      #endif
	#else
		// if Color temp not stored in NVRAM, use sRGB settings.
		red = ColorTempConst[UserPrefColor][0];
		grn = ColorTempConst[UserPrefColor][1];
		blu = ColorTempConst[UserPrefColor][2];
	#endif //NVRAM_BLOCK_ColorTemp_WB_Used
	 }


	msgx("***************************************", 0);
	msgx("UserPrefColor %d", (WORD)UserPrefColor);
	msgx("red = %d", (WORD) red);
	msgx("grn = %d", (WORD) grn);
	msgx("blu = %d", (WORD) blu);

	//only reset contrast for SRGB color space
	if(UserPrefColor == CTEMP_SRGB)
#ifdef UserPrefFactorysRGBContrastValue
		UserPrefContrast = UserPrefFactorysRGBContrastValue;
#else
		UserPrefContrast = 128;
#endif
	else
	{
		B_PreUserPrefColor = UserPrefColor;    //Implementation 2 of AdjustContrast ()
	}

	contrast = UserPrefContrast;// *  2; //allow contrast to go from 0->2.00 instead of 0->1.00

	msgx("contrast %d",(WORD)contrast);
	msgx("_",0);

	red = ((red + 1) * contrast)>>6;
	grn = ((grn + 1) * contrast)>>6;
	blu = ((blu + 1) * contrast)>>6;

	msgx("R %d",(WORD)red);
	msgx("G %d",(WORD)grn);
	msgx("B %d",(WORD)blu);

	// Color adjustment
	gm_WriteRegWord(RED_CONTRAST,   red);
	gm_WriteRegWord(GREEN_CONTRAST, grn);
	gm_WriteRegWord(BLUE_CONTRAST,  blu);

	gm_SyncUpdate();
}

#endif // Action_AdjustColor_WB_Used

#ifdef	Action_AdjustVideoWindowHue_WB_Used 
void far AdjustVideoWindowHue(void)
{
	//gm_CallDriver(DEV_VPC3230,VID_SET_HUE,(void*)((BYTE)UserPrefSaturation),NULL_PTR);
   AdjustColor();
}
#endif // Action_AdjustVideoWindowHue_WB_Used 


#ifdef	Action_AdjustVideoWindowSaturation_WB_Used
void far AdjustVideoWindowSaturation(void)
{
	//gm_CallDriver(DEV_VPC3230,VID_SET_SATURATION,(void*)((BYTE)UserPrefSaturation),NULL_PTR);
   AdjustColor();
}
#endif // Action_AdjustVideoWindowSaturation_WB_Used 


void far AdjustFactoryColorTempAction(void)
{
#ifdef Action_AdjustFactoryColorTemp_WB_Used
	AdjustFactoryColorTemp();
#endif
}

	void far AdjustFactoryColorTemp(void)
{
#ifdef Action_AdjustFactoryColorTemp_WB_Used
	BYTE saveUPC = UserPrefColor;
	UserPrefRedColor = UserPrefFactoryColorTempAdjRed;
	UserPrefGreenColor = UserPrefFactoryColorTempAdjGreen;
	UserPrefBlueColor = UserPrefFactoryColorTempAdjBlue;

	//adjust color according to pre-defined red/green/blue
	//Set UserPrefColor to CTEMP_USER so AdjustColor() will use UserPrefXColor
	//instead of reading value from NVRAM.
	UserPrefColor = CTEMP_USER;
	AdjustColor();
	UserPrefColor = saveUPC;
#endif
}
//******************************************************************
// FUNCTION       :  EnterFactoryMenu
// DESCRIPTION 	:	Copies UserPref values with UserPrefFactory
//                   values to be used in the factory menu.
//******************************************************************
void EnterFactoryMenu(void)
{
	msgx("*** enter factory menu ***",0);
}
//******************************************************************
// FUNCTION       :  ExitFactoryMenu
// DESCRIPTION 	:	Restores the UserPref values back to normal
//******************************************************************
void ExitFactoryMenu(void)
{
	msgx("*** exit factory menu ***",0);
#ifdef Action_RestoreModeIndepSettings_WB_Used
	RestoreModeIndepSettings();
#endif	
}

void EnterDefaultState(void)
{
	msg("** OSD: EnterDefaultState",0);
}
void EnterValidModeState(void)
{
	msg("** OSD: EnterValidModeState",0);
}
void EnterNoSignalState(void)
{
	msg("** OSD: EnterNoSignalState",0);
}
void EnterNoCableState(void)
{
	msg("** OSD: EnterNoCableState",0);
}
void EnterOutOfRangeState(void)
{
	msg("** OSD: EnterOutOfRangeState",0);
}
void EnterSleepState(void)
{
	msg("** OSD: EnterSleepState",0);
}
//******************************************************************
// FUNCTION       :  StartFloating/StopFloating
// DESCRIPTION 	:	Functions set up an interrupt and chain it to
//		the system timer which already gives us a 1ms tick.  Upon the
//    FLOATING_TIME_MS time in the ISR, OsdFloating() is called to
//    position the OSD dialog.
//******************************************************************
#include "system\mcu186.h"
#ifdef Action_StartFloating_WB_Used

void far interrupt (*TimerIsr)(void);
#define FLOATING_TIME_MS	50
void far interrupt FloatingISR(void)
{
	static WORD i=0;
	if(i++ > FLOATING_TIME_MS)
	{
		OsdFloating();
		i = 0;
	}
	TimerIsr();
}
void StartFloating(void)
{
	msg("** start floating **",0);
	gm_DisableInterrupts();
	TimerIsr = (void far interrupt (*)(void))GET_VECTOR(TIMER2_VECTOR);
	SET_VECTOR(TIMER2_VECTOR, FloatingISR);
	asm{ STI };
}
void StopFloating(void)
{
	msg("** stop floating **",0);
	gm_DisableInterrupts();
	SET_VECTOR(TIMER2_VECTOR,TimerIsr);
	asm{ STI };
}
#endif //Action_StartFloating_WB_Used

// Louis 0622, For AOC control
#if Enable_AOC
void EnableAOCMain(void)
{
//   gm_WriteRegByte(AOC_CTRL0, 0x30);
//   gm_WriteRegByte(AOC_CTRL1, 0x01);
//   gm_WriteRegByte(AOC_SAMPLE_PER_LINE, 0x08);
   gm_WriteRegByte(AOC_CTRL0, 0xFC);
   gm_WriteRegByte(AOC_CTRL1, 0x40);
   gm_WriteRegByte(AOC_SAMPLE_PER_LINE, 0x08);
   gm_WriteRegByte(AOC_CTRL0, gm_ReadRegByte(AOC_CTRL0) | 0x01);
}

void DisableAOCMain(void)
{
	gm_WriteRegByte(AOC_CTRL0, 0xFC);
	//gm_WriteRegByte(AOC_CTRL1, 0x0);
	//gm_WriteRegByte(AOC_SAMPLE_PER_LINE, 0x0);	
}

void EnableDontUpdateAOCMain(void)
{
	gm_SetRegBitsByte(AOC_CTRL0, AOC_DONT_UPDATE);
}

void DisableDontUpdateAOCMain(void)
{
	gm_ClearRegBitsByte(AOC_CTRL0, AOC_DONT_UPDATE);
}
#endif