adjust.c

GM5621原代码

/*
	$Workfile:   adjust.c  $
	$Revision:   1.156  $
	$Date:   Sep 06 2005 05:01:02  $
*/

//******************************************************************
//
//          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	0

#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)()


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
};

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

static void __near matrix_MxM(SDWORD *A, SDWORD *B);
static void __near matrix_MxA(SDWORD *A, SWORD C);
static void __near matrix_MxC(SDWORD *A, SWORD C);

static short sinus(BYTE);
static short cosinus(BYTE);

//******************************************************************
// 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)
{
#ifdef UserPrefW_OsdAccAcmFlag
#if USE_ACC_ACM
	msg("UserPrefW_OsdAccAcmFlagn %x",(WORD)UserPrefW_OsdAccAcmFlag );

	if(UserPrefW_OsdAccAcmFlag & WindowEnableBit)
	{
		switch(UserPrefW_OsdAccAcmFlag & WindowMask)
		{
			case WindowLetterBox :
				{
					WORD HighlightWinFrontPorch, wHStart;

					msg("ColorWindow: LetterBox", 0);
					wHStart = gmvw_OutputHStartMain;
					HighlightWinFrontPorch = PanelMinHTotal - wHStart - gmc_PanelWidth;
					if( HighlightWinFrontPorch <= HIGHLIGHT_WINDOW_FRONT_PORCH)
						wHStart = PanelMinHTotal - gmc_PanelWidth - HIGHLIGHT_WINDOW_FRONT_PORCH;

					gm_WriteRegWord(DH_WIN_START, wHStart);
					gm_WriteRegWord(DH_WIN_WIDTH, gmc_PanelWidth);
					gm_WriteRegWord(DV_WIN_START, gmvw_OutputVStartMain + gmc_PanelHeight/2 - gmc_PanelWidth/32*9);  //16:9 format
					gm_WriteRegWord(DV_WIN_LENGTH, gmc_PanelWidth/16*9);

					gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
				}
				break;
			case WindowLetterBox2 :
				{
					WORD HighlightWinFrontPorch, wHStart;

					msg("ColorWindow: LetterBox2", 0);
					wHStart = gmvw_OutputHStartMain;
					HighlightWinFrontPorch = PanelMinHTotal - wHStart - gmc_PanelWidth;
					if( HighlightWinFrontPorch <= HIGHLIGHT_WINDOW_FRONT_PORCH)
						wHStart = PanelMinHTotal - gmc_PanelWidth - HIGHLIGHT_WINDOW_FRONT_PORCH;

					gm_WriteRegWord(DH_WIN_START, wHStart);
					gm_WriteRegWord(DH_WIN_WIDTH, gmc_PanelWidth);
					gm_WriteRegWord(DV_WIN_START, gmvw_OutputVStartMain + gmc_PanelHeight/2 - gmc_PanelWidth/32*10);  //16:10 format
					gm_WriteRegWord(DV_WIN_LENGTH, gmc_PanelWidth/16*10);

					gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
				}
				break;
			case WindowLeftLetterBox :
				{
					WORD HighlightWinFrontPorch, wHStart;

					msg("ColorWindow: LeftLetterBox", 0);

					wHStart = gmvw_OutputHStartMain;
					HighlightWinFrontPorch = PanelMinHTotal - wHStart - gmc_PanelWidth;
					if( HighlightWinFrontPorch <= HIGHLIGHT_WINDOW_FRONT_PORCH)
						wHStart = PanelMinHTotal - gmc_PanelWidth - HIGHLIGHT_WINDOW_FRONT_PORCH;

					gm_WriteRegWord(DH_WIN_START, wHStart);
					gm_WriteRegWord(DH_WIN_WIDTH, gmc_PanelWidth/2);
					gm_WriteRegWord(DV_WIN_START, gmvw_OutputVStartMain + gmc_PanelHeight/2 - gmc_PanelWidth/32*9);  //16:9 format
					gm_WriteRegWord(DV_WIN_LENGTH, gmc_PanelWidth/16*9);

					gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
				}
				break;
			case WindowFullScreen :
				{
					WORD HighlightWinFrontPorch, wHStart;
					msg("ColorWindow: FullScreen", 0);

					wHStart = gmvw_OutputHStartMain;
					HighlightWinFrontPorch = PanelMinHTotal - wHStart - gmc_PanelWidth;
					if( HighlightWinFrontPorch <= HIGHLIGHT_WINDOW_FRONT_PORCH)
						wHStart = PanelMinHTotal - gmc_PanelWidth - HIGHLIGHT_WINDOW_FRONT_PORCH;

					gm_WriteRegWord(DH_WIN_START, wHStart);
					gm_WriteRegWord(DH_WIN_WIDTH, gmc_PanelWidth);
					gm_WriteRegWord(DV_WIN_START, gmvw_OutputVStartMain);
					gm_WriteRegWord(DV_WIN_LENGTH, gmc_PanelHeight);

					gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
				}
				break;
			case WindowDDCCISetting :
				{
					gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
				}
				break;
			default :
				msg("Unknown Window option!!",0);
				break;
		} // switch window
	}// if window enabled
	else
	{//clear video window
		gm_WriteRegWord(DH_WIN_START, 0);
		gm_WriteRegWord(DH_WIN_WIDTH, 0);
		gm_WriteRegWord(DV_WIN_START, 0);  //16:9 format
		gm_WriteRegWord(DV_WIN_LENGTH, 0);
		gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
	}


	if((InputPortArray[gmvb_CurrentPortMain].ACM_En))
	{
		switch(UserPrefACMMode)
		{
			case ACM_MODE_NORMAL:
				{
					msg("Enter ACM_MODE_NORMAL", 0);
                    UserPrefW_OsdAccAcmFlag  &= ~(AcmEnableBit | AccEnableBit);
				}
				break;
			case ACM_MODE_CINEMA:
				{
					gm_ACM_loadFEMatrix(CMFineTable_Cinema, (BYTE const far *)CMIntpTable_Cinema, 0x01);
					gm_WriteRegByte(ACM_INTERP_GAIN, (CMGainV_Cinema | (CMGainU_Cinema << 4)));
						  {
								gm_InitACC(&ACCData_Cinema);
                        gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
                    }                    
					gm_WriteRegByte(YC_LINK_CTRL,0x00);
                    UserPrefW_OsdAccAcmFlag  |= (AcmEnableBit | AccEnableBit);
				}
				break;
			case ACM_MODE_VIVID:
				{
					msg("Enter ACM_MODE_VIVID", 0);
					gm_ACM_loadFEMatrix(CMFineTable_Vivid, (BYTE const far *)CMIntpTable_Vivid, 0x01);
					gm_WriteRegByte(ACM_INTERP_GAIN, (CMGainV_Vivid | (CMGainU_Vivid << 4)));
                    {
								gm_InitACC(&ACCData_Vivid);
                        gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
					}
					gm_WriteRegByte(YC_LINK_CTRL,0x00);
                    UserPrefW_OsdAccAcmFlag  |= (AcmEnableBit | AccEnableBit);
				}
				break;
			case ACM_MODE_NATURE:
				{
					msg("Enter ACM_MODE_NATURE", 0);
					gm_ACM_loadFEMatrix(CMFineTable_Nature, (BYTE const far *)CMIntpTable_Nature, 0x01);
					gm_WriteRegByte(ACM_INTERP_GAIN, (CMGainV_Nature | (CMGainU_Nature << 4)));
                    {
								gm_InitACC(&ACCData_Nature);
								gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
                    }
					gm_WriteRegByte(YC_LINK_CTRL,0x00);
                    UserPrefW_OsdAccAcmFlag  |= (AcmEnableBit | AccEnableBit);
				}
				break;
			case ACM_MODE_SPORT:
				{
					msg("Enter ACM_MODE_SPORT", 0);
					gm_ACM_loadFEMatrix(CMFineTable_Sport, (BYTE const far *)CMIntpTable_Sport, 0x01);
					gm_WriteRegByte(ACM_INTERP_GAIN, (CMGainV_Sport | (CMGainU_Sport << 4)));
                    {
                        gm_InitACC(&ACCData_Sport);
                        gm_WriteRegByte(HOST_CONTROL, DPFORCE_UPDATE | IPFORCE_UPDATE);
                    }
					gm_WriteRegByte(YC_LINK_CTRL,0x00);
                    UserPrefW_OsdAccAcmFlag  |= (AcmEnableBit | AccEnableBit);
				}
				break;
		}
	}// if ACM enabled

#endif //USE_ACC_ACM
#endif
	AdjustColor();

}

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

	AdjustACCACM();

#ifdef UserPrefAdcRedGainYUV
	if ( InputPortArray[gmvb_CurrentPortMain].YUV || gm_ReadRegByte(RGB2YUV_CTRL))
		gm_SetAdcOffset2Main(UserPrefAdcRedOffset2YUV,UserPrefAdcGreenOffset2YUV,UserPrefAdcBlueOffset2YUV);
	else
#endif
		gm_SetAdcOffset2Main(UserPrefAdcRedOffset2,UserPrefAdcGreenOffset2,UserPrefAdcBlueOffset2);

#ifdef UserPrefAdcRedGainYUV
	if ( InputPortArray[gmvb_CurrentPortMain].YUV || gm_ReadRegByte(RGB2YUV_CTRL))
		gm_SetAdcGainMain(UserPrefAdcRedGainYUV,UserPrefAdcGreenGainYUV,UserPrefAdcBlueGainYUV);
	else
#endif
	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;
	UserPrefHSyncPhase = gmvb_InputPhase;
	#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("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;
	gmvb_InputPhase = UserPrefHSyncPhase;
	#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);
	#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)
{
#ifdef UserPrefAdcRedOffset2YUV
	if ( InputPortArray[gmvb_CurrentPortMain].YUV || gm_ReadRegByte(RGB2YUV_CTRL))
	{
		msgx("Enter UpdateUserPrefAdcSettings YUV", 0);
		UserPrefAdcRedOffset2YUV 	= gm_ReadRegByte(RED_OFFSET2);
		UserPrefAdcGreenOffset2YUV = gm_ReadRegByte(GRN_OFFSET2);
		UserPrefAdcBlueOffset2YUV 	= gm_ReadRegByte(BLU_OFFSET2);
		UserPrefAdcRedGainYUV 		= gm_ReadRegWord(RED_GAIN);
		UserPrefAdcGreenGainYUV 	= gm_ReadRegWord(GRN_GAIN);
		UserPrefAdcBlueGainYUV 		= gm_ReadRegWord(BLU_GAIN);
	}
	else
#endif
	{
		msgx("Enter UpdateUserPrefAdcSettings RGB", 0);
		UserPrefAdcRedOffset2 	= gm_ReadRegByte(RED_OFFSET2);
		UserPrefAdcGreenOffset2 = gm_ReadRegByte(GRN_OFFSET2);