26xx_adjust.c

GM5621原代码

/*
	$Workfile:   26xx_adjust.c  $
	$Revision:   1.5  $
	$Date:   Sep 19 2005 04:14:52  $
*/

//******************************************************************
//
//          Copyright (C) 2002. GENESIS MICROCHIP INC.
//  All rights reserved.  No part of this program may be reproduced.
//
//	Genesis Microchip Corp., 2150 Gold Street
//			Alviso, CA 95002	USA
//  Genesis Microchip Inc., 165 Commerce Valley Dr. West
//          Thornhill, Ontario, Canada, L3T 7V8
//
//================================================================
//
//  MODULE: adjust.c
//
//  USAGE : This module contains adjuster function
//
//******************************************************************


//******************************************************************
//                  I N C L U D E    F I L E S
//******************************************************************
#include "inc\all.h"
#include "mem.h"
#include "math.h"
#define DEBUG_COLOR 			1
#define DEBUG_OSD    		1
#define DEBUG_OSD_EXTENDED	1

#if DEBUG_MSG && (DEBUG_COLOR | DEBUG_OSD)
	#define	msg(a,b)	gm_Print((const char far *)a,b)
#else
	#define msg(a,b)
#endif

#if DEBUG_MSG && DEBUG_OSD_EXTENDED
	#define	msgx(a,b)	gm_Print((const char far *)a,b)
#else
	#define msgx(a,b)
#endif


#pragma option -w-use        //Supress Warnings for Parameters not used.

#define FLIP_HPOS_ADJUSTER		 1 //when set, incrementing UserPrefHTotal will shift immage to the right.
//******************************************************************
//                  L O C A L   D E F E N I T I O N S
//******************************************************************

//#define HSVS_SPACE_ADJ 		0x40  // used to adjust iphs_delay 
#define	MIN_SRC_HSTART		IPHS_ActiveStart	  // minimum source hstart position for UserPrefHStart
#define	MAX_SRC_HSTART		(UserPrefHTotal/2)  // maximum source hstart position for UserPrefHStart

#define SystemReset()	((void (code*)(void))0)()

#ifdef Genesis_REF_OSD
BYTE ROM ColorTempConst[8][3] =
{
	{255, 255, 255},   //CTEMP_SRGB
	{255, 255, 255},   //CTEMP_USER
	{248, 237, 210},   //CTEMP_4200K
	{251, 237, 227},   //CTEMP_5000K
	{234, 255, 241},   //CTEMP_6500K
	{255, 255, 255},   //CTEMP_7500K
	{224, 228, 251},    //CTEMP_9300K
	{255, 255, 255},    //CTEMP_NON_SRGB, Note: the values of this array should be the same as CTEMP_SRGB
	//CTEMP_CURRENT
};
#endif

//To keep track of previous non-srgb color space for implementation 2 of AdjustContrast()
static BYTE B_PreUserPrefColor = CTEMP_NON_SRGB;

#ifdef ZERO_K_MAIN		// gives cleaner display sometimes, but adds a phase skew
extern BYTE KM0PhaseOffset;
#endif
//******************************************************************
// DESCRIPTION 	:	Brightness adjuster function
// SYNTEX		:	void AdjustBrightness(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
#ifdef Action_AdjustBrightness_WB_Used
void AdjustBrightness(void)
{
//	BYTE	B_Brightness = UserPrefBrightness + 128;
#if	PWM0_BRIGHTNESS==1
	#ifdef _CUSTOMER_D_SPECIFIC_IN_52XX_
		gm_SetBrightnessMainPWM_Customer_D(UserPrefBrightness);
	#else
		gm_SetBrightnessMainPWM(UserPrefBrightness);
	#endif
#else
	gm_SetBrightnessMain(UserPrefBrightness);
#endif
	//forceHostIPControl();

	msgx("Adjust Brightness = %d", UserPrefBrightness);
}
#endif // Action_AdjustBrightness_WB_Used

//******************************************************************
// DESCRIPTION 	:	Contrast adjuster function
// SYNTEX		:	void AdjustContrast(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
#ifdef Action_AdjustContrast_WB_Used
void AdjustContrast ()
{
	//Adjusting contrast for any non-srgb color space (CTEMP_4200K, CTEMP_USER, etc)
	//will not change color space, while adjusting contrast in srgb color space will
	//make it a non-srgb color space, and it's like a hidden non-srgb color space (not CTEMP_4200K, ... or CTEMP_USER).
	//Implementation 1: Always assume CTEMP_NON_SRGB is used. One has to be aware of no osd submenu under color main menu for this hidden non-srgb color space.
	//Implementation 2: Always assume previous non-srgb color space is used when adjusting contrast in srgb color space.
	if (UserPrefColor == CTEMP_SRGB)
	{
		UserPrefColor =  CTEMP_NON_SRGB;       //This is implementation 1.
		//by uncomment following line will enable implementation 2.
		//UserPrefColor = B_PreUserPrefColor;    //Implementation 2.
	}

	AdjustColor();
}
#endif // Action_AdjustContrast_WB_Used

void AdjustACCACM(void)
{
	msg("phoenix doesn't have ACC/ACM",0);

}

//******************************************************************
// DESCRIPTION 	:
// SYNTEX		:
// PARAMETERS	:
// RETURN		:
//******************************************************************
void AdjustAllModeIndependentSettings(void)
{
	AdjustBrightness();
	AdjustOsdHVPos();

	gm_SetAdcOffset2Main(UserPrefAdcRedOffset2,UserPrefAdcGreenOffset2,UserPrefAdcBlueOffset2);
	gm_SetAdcGainMain(UserPrefAdcRedGain,UserPrefAdcGreenGain,UserPrefAdcBlueGain);


	AdjustColor();
	AdjustSharpness();
}

//******************************************************************
// DESCRIPTION 	:	void RestoreModeIndepSettings()
// SYNTEX		:
// PARAMETERS	:
// RETURN		:
//******************************************************************
#ifdef Action_RestoreModeIndepSettings_WB_Used
void RestoreModeIndepSettings(void)
{
	ReadModeIndependentSettings();
	AdjustAllModeIndependentSettings();
}
#endif // Action_RestoreModeIndepSettings_WB_Used



void DoAutoGeometry(void) {StartAutoAdjust(); }

// PDR#5250. Updated to return gmt_RET_STAT error code to be used for OSD handler
//******************************************************************
// DESCRIPTION 	:	void RequestAutoGeometry()
// SYNTAX		:	void RequestAutoGeometry()
// PARAMETERS	:
// RETURN		:	gmt_RET_STAT
//******************************************************************
#ifdef Action_RequestAutoGeometry_WB_Used
void RequestAutoGeometry()
{

}
#endif // Action_RequestAutoGeometry_WB_Used




//******************************************************************
// DESCRIPTION 	:
// SYNTEX		:          z
// PARAMETERS	:
// RETURN		:
//******************************************************************
void AdjustAllModeDependentSettings(void)
{
	AdjustVPos();
	AdjustHPos();
	AdjustHTotal();
	AdjustHSyncPhase();
	AdjustPhaseSkew();
}



//******************************************************************
// DESCRIPTION 	:	Restore the mode dependent parameters.
//					This function is called when restore is selected
//					after the auto adjust in OSD	
// SYNTEX		:	void RestoreModeDependentSettings()
// PARAMETERS	:
// RETURN		:
//******************************************************************
#ifdef Action_RestoreModeDependentSettings_WB_Used
void RestoreModeDependentSettings()
{
	// restore from previous UserPreferences
	UpdateInputParameterSettings();
	AdjustAllModeDependentSettings();
}
#endif // Action_RestoreModeDependentSettings_WB_Used


//******************************************************************
// DESCRIPTION  :   Setup UserPreference Variables from Input parameters
//					if the input mode has not been saved in nvram. 
// SYNTEX     	:   void UpdateModeDependentSettings(void)
// INPUT        :   None
// OUTPUT       :   none.
//******************************************************************
void UpdateModeDependentSettings()
{
	// Read current setting and store it to ModeDependent structure
	UserPrefVStart = gmvw_InputVStartMain;
	UserPrefHTotal = gmvw_InputHTotalMain;
#ifdef ZERO_K_MAIN		// gives cleaner display sometimes, but adds a phase skew
	UserPrefHSyncPhase = ((gmvb_InputPhase - KM0PhaseOffset) & 0x3f);
#else
	UserPrefHSyncPhase = gmvb_InputPhase;
#endif
	#ifdef UserPrefPhaseSkew
		UserPrefPhaseSkew = gmvw_PhaseSkew;
	#endif
	#if FLIP_HPOS_ADJUSTER
		UserPrefHStart = MAX_SRC_HSTART - gmvw_InputHStartMain;
	#else
		UserPrefHStart = gmvw_InputHStartMain;
	#endif

	msgx("UpdateModeDependentSettings()",0);
	msgx("MAX_SRC_HSTART = %d", MAX_SRC_HSTART);
	msgx("gmvw_InputHStartMain = %d", gmvw_InputHStartMain);
	msgx("UserPrefHStart = %d", UserPrefHStart);
	msgx("UserPrefHSyncPhase = %x", UserPrefHSyncPhase);
	msgx("gmvw_PhaseSkew = %x", gmvw_PhaseSkew);

}

//******************************************************************
// DESCRIPTION  :   Setup Input parameters from UserPreference if the
//					input mode has been saved in nvram
// SYNTEX     	:   void UpdateInputParameterSettings(void)
// INPUT        :   None
// OUTPUT       :   none.
//******************************************************************
void UpdateInputParameterSettings(void)
{
	// check HTotal limits.
	if(UserPrefHTotal > MaximumHTotal())
		UserPrefHTotal = MaximumHTotal();
	if(UserPrefHTotal < MinimumHTotal())
		UserPrefHTotal = MinimumHTotal();

	gmvw_InputVStartMain = UserPrefVStart;
	gmvw_InputHTotalMain = UserPrefHTotal;
#ifdef ZERO_K_MAIN		// gives cleaner display sometimes, but adds a phase skew
	gmvb_InputPhase = ((UserPrefHSyncPhase + KM0PhaseOffset) & 0x3f);
#else
	gmvb_InputPhase = UserPrefHSyncPhase;
#endif
	#ifdef UserPrefPhaseSkew
		gm_SetPhaseSkew_S(UserPrefPhaseSkew);
   #endif
	#if FLIP_HPOS_ADJUSTER
		gmvw_InputHStartMain = MAX_SRC_HSTART - UserPrefHStart;
	#else
		gmvw_InputHStartMain = UserPrefHStart;
	#endif

	msgx("UpdateInputParameterSettings()",0);
	msgx("MAX_SRC_HSTART = %d", MAX_SRC_HSTART);
	msgx("gmvw_InputHStartMain = %d", gmvw_InputHStartMain);
	msgx("UserPrefHStart = %d", UserPrefHStart);
	msgx("gmvw_InputHTotalMain = %d", gmvw_InputHTotalMain);
	msgx("gmvb_InputPhase = %d", gmvb_InputPhase);
	#ifdef UserPrefPhaseSkew
	msgx("UserPrefPhaseSkew = %x", UserPrefPhaseSkew);
	#endif
}


//******************************************************************
// DESCRIPTION  :   Setup UserPreference Variables from ADC Offset2
//					and Gain registers
// SYNTEX     	:   void UpdateUserPrefAdcSettings(void)
// INPUT        :   None
// OUTPUT       :   none.
//******************************************************************
#ifdef Action_UpdateUserPrefAdcSettings_WB_Used
void UpdateUserPrefAdcSettings(void)
{
	msgx("Enter UpdateUserPrefAdcSettings RGB", 0);
	UserPrefAdcRedOffset2 	= gm_ReadRegByte(RED_OFFSET2);
	UserPrefAdcGreenOffset2 = gm_ReadRegByte(GRN_OFFSET2);
	UserPrefAdcBlueOffset2 	= gm_ReadRegByte(BLU_OFFSET2);
	UserPrefAdcRedGain 		= gm_ReadRegWord(RED_GAIN);
	UserPrefAdcGreenGain 	= gm_ReadRegWord(GRN_GAIN);
	UserPrefAdcBlueGain 		= gm_ReadRegWord(BLU_GAIN);
}
#endif // Action_UpdateUserPrefAdcSettings_WB_Used


//******************************************************************
// DESCRIPTION 	:	Vertical position adjuster function
// SYNTEX	:	void AdjustVPos(void)
// PARAMETERS	:	none
// RETURN	:	none
//******************************************************************
#ifdef Action_AdjustVPos_WB_Used
void AdjustVPos(void)
{
	gmvw_InputVStartMain = UserPrefVStart;
	msgx("Adjust VPos = %d", gmvw_InputVStartMain);
	gm_SetInputVPositionMain(gmvw_InputVStartMain);
}
#endif // #ifdef Action_AdjustVPos_WB_Used



//******************************************************************
// DESCRIPTION 	:	Horisontal position adjuster function
// SYNTEX	:
// PARAMETERS	:	none
// RETURN	:	none
//******************************************************************
#ifdef Action_AdjustHPos_WB_Used
void AdjustHPos (void)
{
	#if FLIP_HPOS_ADJUSTER
		gmvw_InputHStartMain = MAX_SRC_HSTART  - UserPrefHStart;
	#else
		gmvw_InputHStartMain = UserPrefHStart;
	#endif

	msgx("Adjust HPos()",0);
	msgx("MAX_SRC_HSTART = %d", MAX_SRC_HSTART);
	msgx("gmvw_InputHStartMain = %d", gmvw_InputHStartMain);
	msgx("UserPrefHStart = %d", UserPrefHStart);

	gm_SetInputHPositionMain(gmvw_InputHStartMain);
}
#endif // Action_AdjustHPos_WB_Used

//******************************************************************
// DESCRIPTION 	:	Horisontal size adjuster function
// SYNTEX		:
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
#ifdef Action_AdjustHTotal_WB_Used
void AdjustHTotal(void)
{
   // Merlin 0824, add for adjust Clock repeat key the value still adjust when release key in mode over 1152x864
	StopGetKeyISR();
	gm_TimerStart(HTotalDelay_10ms_TMR, 12);

	gmvw_InputHTotalMain = UserPrefHTotal;

	msgx("Adjust HTotal = %d", gmvw_InputHTotalMain);

	gm_SetInputHTotalMain(gmvw_InputHTotalMain);

	// MAX_SRC_HSTART is based on UserPrefHTotal, if UserPrefHTotal changes
	// UserPrefHStart should be recalculated.
	#if FLIP_HPOS_ADJUSTER
		UserPrefHStart = MAX_SRC_HSTART - gmvw_InputHStartMain;
	#else
		UserPrefHStart = gmvw_InputHStartMain;
	#endif

   // Merlin 0824, add for adjust Clock repeat key the value still adjust when release key in mode over 1152x864
	while(gm_TimerCheck(HTotalDelay_10ms_TMR)!=gmd_TMR_TIMED_OUT);
	StartGetKeyISR();

}
#endif // Action_AdjustHTotal_WB_Used



//******************************************************************
// DESCRIPTION 	:	Set Auto Adjust Phase Skew from mode dependent data.
// SYNTEX	:
// PARAMETERS	:	none
// RETURN	:	none
//******************************************************************
void AdjustPhaseSkew(void)
{
	#ifdef	UserPrefPhaseSkew
	gm_SetPhaseSkew_S(UserPrefPhaseSkew);
	#endif
}
//******************************************************************
// DESCRIPTION 	:	Horisontal phase adjuster function
// SYNTEX	:
// PARAMETERS	:	none
// RETURN	:	none
//******************************************************************
#ifdef Action_AdjustHSyncPhase_WB_Used
void AdjustHSyncPhase(void)
{
#ifdef ZERO_K_MAIN		// gives cleaner display sometimes, but adds a phase skew
	gmvb_InputPhase = ((UserPrefHSyncPhase + KM0PhaseOffset) & 0x3f);
#else
	gmvb_InputPhase = UserPrefHSyncPhase;
#endif

	gm_SetAdcPhaseMain(gmvb_InputPhase);

	msgx("gmvb_InputPhase = 0x%x", gmvb_InputPhase);
	msgx("SAMPLING_PHASE_DELAY = 0x%x", gm_ReadRegByte(SAMPLING_PHASE_DELAY));
}
#endif // Action_AdjustHSyncPhase_WB_Used


//******************************************************************
// DESCRIPTION 	:	Minimum vertical position
// SYNTEX	:	WORD MinimumVPos(void)
// PARAMETERS	:	none
// RETURN	:	Minimum vertical position
//******************************************************************
WORD MinimumVPos(void)
{
	return IPVS_ActiveStart;
}


//******************************************************************
// DESCRIPTION 	:	Maxinmum vertical position
// SYNTEX	:	WORD MaximumVPos(void)
// PARAMETERS	:	none
// RETURN	:	Maxinmum vertical position
//******************************************************************
WORD MaximumVPos(void)
{
	return (gmvw_InputVTotalMain - gmvw_InputHeightMain);
}



//******************************************************************
// DESCRIPTION 	:	Minimum horisontal position
// SYNTEX	:	WORD MinimumHPos(void)
// PARAMETERS	:	none
// RETURN	:	Minimum horisontal position
//******************************************************************
WORD MinimumHPos(void)
{
	return MIN_SRC_HSTART;
}



//******************************************************************
// DESCRIPTION 	:	Maximum horisontal position
// SYNTEX	:	WORD MaximumHPos(void)
// PARAMETERS	:	none
// RETURN	:	Maximum horisontal position
//******************************************************************
WORD MaximumHPos(void)
{
	return MAX_SRC_HSTART - IPHS_ActiveStart;
}