57xx_adjust.c

GM5621原代码

	msgx("SetYUVFormat", 0);
	ChangeToPort(5);
}

void SetYUVFormatInDVIPort()
{
	msgx("SetYUVFormat", 0);
	ChangeToPort(6);
}

//to select overlapped mode
void SetOverlappedMode(void)
{
	// pdr#5836.
	if (gmvw_InputFlagsMain & gmd_OVERLAPPED_MASK)
	{
		// swap 640 and 720 mode.
		if (gmvw_InputWidthMain == 640)
			UserPrefOverlappedMode = DOS;
		else
			UserPrefOverlappedMode = Graphics;

		#if NVRAM_DIRTY_BITS_CHECK
		SetAdjustedBitFlags(OverlappedMode_offset, 1);
		#endif // NVRAM_DIRTY_BITS_CHECK

		// HideOsd() to remove OSD quickly, this fixes OSD
		// 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();
      #endif

      		// Louis 0816
		#if Enable_AOC
			EnableAOCMain();
		#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 ;

#if defined(FLASH_RELIABILITY_TEST)
//	if (!pre_delay_down)
//	{
//		decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(6000L)); //Checking for 6 sec
//		if(decTimer)
//			{
//				pre_delay_down=1;
//				prevOnTime = CurrentOnTime ;
//			}
//	}
//	else
//	{
		if (!test_err)
		{
		decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(1000L)); //Checking for 1 sec

		if(decTimer)
		{
			testcounter++;
			gm_Print("Flash Reliability Testing...",0);
			gm_Print("Test Counter HighByte=0x%x",testcounter>>16);		
			gm_Print("              LowByte=0x%x",testcounter);
			gm_Print("Data size=0x%x",sizeof(ModeIndependentUserPreferences)); 
			if (UserPrefBrightness==255)
				UserPrefBrightness=0;
			else
				UserPrefBrightness++;
			gm_Print(">>>UserPrefBrightness=%d",UserPrefBrightness);
			prevOnTime = CurrentOnTime ;
			memcpy(&ModeIndependentUserPreferences_temp,&ModeIndependentUserPreferences,sizeof(ModeIndependentUserPreferences));
			SaveModeIndependentSettings();
			memcpy(&ModeIndependentUserPreferences,0x00,sizeof(ModeIndependentUserPreferences));
			ReadModeIndependentSettings();
//			UserPrefBrightness++;
//			if(testcounter>=0x37)
//				test_err=1;
			if (memcmp(&ModeIndependentUserPreferences_temp,&ModeIndependentUserPreferences,sizeof(ModeIndependentUserPreferences)))
			{
				gm_Print("***Compare error!***",0);
				test_err=1;
			}
		 }
		 }
//	}		
#elif defined(POWER_CYCLE_TEST_MASTER)
	if (Initial_1st)
	{
		gm_SetRegBitsByte(GPO_OUTPUT, GPO2_OUT);						
		Initial_1st=0;
		prevOnTime=CurrentOnTime;
	}
	else
	{
		if (!Check_feedback)
			decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(6000L)); //Checking for 6 sec
		if(decTimer)
			Check_feedback=1;
		if(Check_feedback)
			{
				gm_ClearRegBitsByte(GPIO_DIRCTRL3, GPIO30_IO);
				if (gm_ReadRegByte(GPINPUT3)& GPIO30_IN)
				{
					gm_ClearRegBitsByte(GPO_OUTPUT, GPO2_OUT);			
					gm_Print("Power OnOff Test....",0);
					gm_Print("Test Counter HighByte=0x%x",testcounter>>16);		
					gm_Print("              LowByte=0x%x",testcounter);
					testcounter++;
					gm_Delay100ms(10);
					gm_SetRegBitsByte(GPO_OUTPUT, GPO2_OUT);												
					prevOnTime=CurrentOnTime;
					Check_feedback=0;
				}
			}

		
	}
		
		
#elif defined(POWER_CYCLE_TEST_TARGET)
	if (!pre_delay_down)
	{
		decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(2000L)); //Checking for 2 sec
		if(decTimer)
			{
				pre_delay_down=1;
				prevOnTime = CurrentOnTime ;
				gm_SetRegBitsByte(GPO_OUTPUT, GPO2_OUT);
			}
	}
	else
	{	
		decTimer = (BYTE)((DWORD)(CurrentOnTime - prevOnTime)/(DWORD)(100L)); //Checking for 0.1 sec

		if(1) //decTimer)
		{

			prevOnTime = CurrentOnTime ;
			if (UserPrefBrightness==128)
				{
					gm_Print("################################ModeIndependent load default",0);
				}
			else if (UserPrefBrightness==255)
				UserPrefBrightness=0;
			else if (UserPrefBrightness==127)
				UserPrefBrightness=128;

			UserPrefBrightness++;
			gm_Print("Flash Writing...",0);
			gm_Print("Data size=0x%x",sizeof(ModeIndependentUserPreferences)); 
			gm_Print(">>>UserPrefBrightness=%d",UserPrefBrightness);
			SaveModeIndependentSettings();

		 }
	}
	
#else
	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	
#endif
}



// Louis 1103 ... 5221 3x3 method
#if defined(Action_AdjustColor_WB_Used) | defined(Action_AdjustContrast_WB_Used)

// Look-up table for sin cos functions
//This table is using enhanced coefficient.
short code sincos_lut[65] = {
    0x0000, 0x0064, 0x00C8, 0x012D, 0x0191, 0x01F5, 0x0259, 0x02BC,
    0x031F, 0x0381, 0x03E3, 0x0444, 0x04A5, 0x0504, 0x0563, 0x05C2,
    0x061F, 0x067B, 0x06D7, 0x0731, 0x078A, 0x07E2, 0x0839, 0x088F,
    0x08E3, 0x0936, 0x0987, 0x09D7, 0x0A26, 0x0A73, 0x0ABE, 0x0B08,
    0x0B50, 0x0B96, 0x0BDA, 0x0C1D, 0x0C5E, 0x0C9D, 0x0CD9, 0x0D14,
    0x0D4D, 0x0D84, 0x0DB9, 0x0DEB, 0x0E1C, 0x0E4A, 0x0E76, 0x0EA0,
    0x0EC8, 0x0EED, 0x0F10, 0x0F31, 0x0F4F, 0x0F6B, 0x0F85, 0x0F9C,
    0x0FB1, 0x0FC3, 0x0FD3, 0x0FE1, 0x0FEC, 0x0FF4, 0x0FFB, 0x0FFE,
    0x0FFF
};
//******************************************************************
// DESCRIPTION 	:	Matrix multiply.  Multiplies 3x3 matrix A with
//					3x3 matrix B, storing the results back in A.
// PARAMETERS	:
// RETURN		:   result stored in matrix A.
//******************************************************************
static void __near matrix_MxM(SDWORD *A, SDWORD *B)
{
	BYTE row,col;
	SDWORD M[3][3];
	SDWORD a,b,c;

    for(row=0;row<3;row++)
    {
		for(col=0;col<3;col++)
      {
			a = A[row * 3 + 0] * B[0 * 3 + col];
			b = A[row * 3 + 1] * B[1 * 3 + col];
        	c = A[row * 3 + 2] * B[2 * 3 + col];
			M[row][col] = (a + b + c) >> 8;
		}
	}
	memcpy(A,M,sizeof(M));
}

//******************************************************************
// FUNCTION     :   matrix_MxA
// USAGE        :   Adjusts contrast, saturation
//                  in YUV space.
// INPUT        :   A[]
//
//
// OUTPUT       :   A[]
//                  A[] = Adjust[]
//
// GLOBALS      :   UserPrefContrast, UserPrefUVSaturation, UserPrefUVFleshTone
//                  - contrast is a one byte unsigned word that can
//                  take values between 0x00 and 0xFF in 0x01
//                  steps.
//