57xx_adjust.c

GM5621原代码

      switch(UserPrefThemeMode)
      {
      case ACM_MODE_NORMAL:
         UserPrefW_OsdAccAcmFlag &= ~AcmEnableBit;
         break;
      
      case ACM_MODE_CINEMA:
         LoadAcm3DSettings(gma_ACM3DRegionDefs_TheatreMode, gma_ACM3DCorrectionParamDefs_TheatreMode);
         UserPrefW_OsdAccAcmFlag |= AcmEnableBit;
         break;
      
      default:
      case ACM_MODE_VIVID:        //ACM_MODE_NATURE
         LoadAcm3DSettings(gma_ACM3DRegionDefs_VividMode, gma_ACM3DCorrectionParamDefs_VividMode);
         UserPrefW_OsdAccAcmFlag |= AcmEnableBit;
         break;
      
      case ACM_MODE_GAME:
         LoadAcm3DSettings(gma_ACM3DRegionDefs_GameMode, gma_ACM3DCorrectionParamDefs_GameMode);
         UserPrefW_OsdAccAcmFlag |= AcmEnableBit;
         break;
      
      case ACM_MODE_SPORT:
         LoadAcm3DSettings(gma_ACM3DRegionDefs_SportMode, gma_ACM3DCorrectionParamDefs_SportMode);
         UserPrefW_OsdAccAcmFlag |= AcmEnableBit;
         break;

      case ACM_MODE_SIXAXIS:
         LoadAcm3DSettings(gma_ACM3DRegionDefs_SixAxisMode, gma_ACM3DCorrectionParamDefs_SixAxisMode);

         // 1207, for 6 axis adjust
         gm_ACM3DAdjustSixAxisControl(RED_AXIS, UserPrefSixAxisRedColor);
         gm_ACM3DAdjustSixAxisControl(YELLOW_AXIS, UserPrefSixAxisYellowColor);
         gm_ACM3DAdjustSixAxisControl(GREEN_AXIS, UserPrefSixAxisGreenColor);
         gm_ACM3DAdjustSixAxisControl(CYAN_AXIS, UserPrefSixAxisCyanColor);
         gm_ACM3DAdjustSixAxisControl(BLUE_AXIS, UserPrefSixAxisBlueColor);
         gm_ACM3DAdjustSixAxisControl(MAGENTA_AXIS, UserPrefSixAxisMagentaColor);

         UserPrefW_OsdAccAcmFlag |= AcmEnableBit;
         break;

      }
   #endif
   
   }

#endif

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

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

#ifdef UserPrefAdcRedGainYUV
	if (InputPortArray[gmvb_CurrentPortMain].YUV)
		gm_SetAdcGainMain(UserPrefAdcRedGainYUV,UserPrefAdcGreenGainYUV,UserPrefAdcBlueGainYUV);
	else
#endif
   	gm_SetAdcGainMain(UserPrefAdcRedGain,UserPrefAdcGreenGain,UserPrefAdcBlueGain);

	AdjustColor();
	AdjustSharpness();

#if USE_AUDIO && USE_GSEL_DRVR_MODEL
	gm_CallDriver(DEV_AUDIO_DECODER, gmd_AUD_SET_OUTPUT_VOLUME, (WORD)UserPrefAUD_Volume, NULL_PTR);		
	Set_AudioMute=1;
	gm_TimerStart(Audio_SetMuteOff_Delay_100ms, 10);  
//	gm_CallDriver(DEV_AUDIO_DECODER, gmd_AUD_SET_OUTPUT_MUTE,   (WORD)UserPrefAUD_Mute,   NULL_PTR);
#endif

}

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

void SetBestValues(void)
{
	UserPrefHStartBestValue = UserPrefHStart;
	UserPrefVStartBestValue = UserPrefVStart;
	UserPrefHTotalBestValue = UserPrefHTotal;
}

void SaveBestValues(void)
{
	SetBestValues();
	SaveModeDependentSettings();
}

//******************************************************************
// 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_InputSamplingPhase[DEF_CHANNEL];

#ifdef ZERO_K_MAIN		// gives cleaner display sometimes, but adds a phase skew
	UserPrefHSyncPhase = ((gmvb_InputPhase - KM0PhaseOffset) & 0x3f);	//	1114-1
#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

   UserPrefHTotalBestValue = UserPrefHTotal;
   UserPrefHStartBestValue = UserPrefHStart;
   UserPrefVStartBestValue = UserPrefVStart;

	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)
{
#ifdef UserPrefAdcRedOffset2YUV
	if ( InputPortArray[gmvb_CurrentPortMain].YUV )
	{
		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);
		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);	// 1114-1
	//gmvb_InputPhase = UserPrefHSyncPhase;		// Louis 1114
#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


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