osdoper.c

车载DVD osdIC TW8816原厂代码

#include "Config.h"

#include "typedefs.h"
#include "main.h"
#include "i2c.h"
#include "Tw88.h"
#include "measure.h"
#include "dispinfo.h"
#include "osdbasic.h"
#include "osdmenu.h"
#include "adc.h"
#include "etc_eep.h"
#include "pc_eep.h"
#include "audio.h"
#include "printf.h"
#include "udfont.h"
#include "panel.h"

#include "rgbmix.h"		// for TW8801

CODE struct RegisterInfo UserRange={0,100,50};

CODE struct RegisterInfo OSDMenuYRange= { OSDMENUY_MIN,	OSDMENUY_MAX,	OSDMENUY_50		};				
CODE struct RegisterInfo OSDMenuXRange= { OSDMENUX_MIN, OSDMENUX_MAX,	OSDMENUX_50		};				

CODE struct RegisterInfo PCUserColorTempRange = { 0, 55, 28 };			

CODE struct RegisterInfo PanelContrastRange={	0,199,100};
CODE struct RegisterInfo PanelBrightnessRange={	45,210,128};
CODE struct RegisterInfo PanelSharpnessRange={	0,7,3};
CODE struct RegisterInfo PanelHueRange={	0,0x3f,0x20};
CODE struct RegisterInfo PanelSaturationRange={	45,210,128};
#ifdef BACKLIGHT_CCFL
CODE struct RegisterInfo PanelBacklightRange={	0x06,0x1f,0x12};
#else
CODE struct RegisterInfo PanelBacklightRange={	45,210,128};
#endif

CODE struct RegisterInfo VideoContrastRange={	0,255,128};
CODE struct RegisterInfo VideoBrightnessRange={	-128,127,0};
CODE struct RegisterInfo VideoSaturationRange={	0,255,128};
CODE struct RegisterInfo VideoHueRange={	-128,127,0};	//-90~90
CODE struct RegisterInfo VideoSharpnessRange={	0,7,3};
CODE struct RegisterInfo DigitalVideoSaturationRange={0, 0x7f, 0x40};

#define contrast 0
#define bright	 1
#define staturation_U 2
#define staturation_V 3
#define hue		 4
#define sharpness 5
#define backlight 6
/*
CODE BYTE Contast_Reg_Addr[]={0x11, // Composite
							  0x11, // Svideo
	                          0x3b, // Component
	                          0x71, // DTV
	                          0x11, // TV
	                          0x3b  // Scart
	};*/
#ifdef WIDE_SCREEN
extern BYTE WideScreenMode;
#define MAXWIDESCREEN 4
#endif
#ifdef SUPPORT_COMPONENT
extern IDATA BYTE  ComponentMode;
#endif
extern	IDATA BYTE  InputSelection;
extern     CODE struct _DECODER_FORMAT DecoderFormat[];
//==============================================================
//
//  OSD Menu Operation Function
//
//==============================================================
#define MAX_OSDPOSITIONMODE	5
CODE BYTE OSDPOSITIONMODE_TABLE[][2] = { 
	{OSDMENUX_50, OSDMENUY_50},
	{OSDMENUX_MIN,OSDMENUY_MIN},
	{OSDMENUX_MIN,OSDMENUY_MAX},
	{OSDMENUX_MAX,OSDMENUY_MAX},
	{OSDMENUX_MAX,OSDMENUY_MIN},
};

#ifdef SUPPORT_OSDPOSITIONMOVE
BYTE GetOSDPositionMode(void)
{
	BYTE val;
	val = GetOSDPositionModeEE();
//	Printf("OSD Position=%d\r\n",(BYTE)val);
	
	return val;
}

BYTE SetOSDPositionMode( BYTE flag )
{
	int val, addx, addy;
	BYTE i,inc, winno;
	BYTE OSDStart[5][3];
	WORD tmp;

	#ifdef ADD_ANALOGPANEL
		if(IsAnalogOn()) return 0;
	#endif


	// Get OSD Position Mode
	i = GetOSDPositionMode();
	inc = ( flag==UP  ? 1  :  -1  );
	i = i + MAX_OSDPOSITIONMODE + inc;
	i %= MAX_OSDPOSITIONMODE;

	addx = OSDPOSITIONMODE_TABLE[i][0];
	addx -= OSDMenuX;
	OSDMenuX = OSDPOSITIONMODE_TABLE[i][0];

	addy = OSDPOSITIONMODE_TABLE[i][1];
	addy -= OSDMenuY;
	OSDMenuY = OSDPOSITIONMODE_TABLE[i][1];

	for( winno=OSDCURSORWINDOW; winno<=OSDMENU_TITLEWIN; winno++) {
		val = GetOSDWindowX( winno );
		val += addx;
		tmp = (BYTE)val<<3;
		OSDStart[winno-OSDCURSORWINDOW][1] = tmp;
		OSDStart[winno-OSDCURSORWINDOW][0] = tmp>>8;

		val = GetOSDWindowY( winno );
		val += addy;
		tmp = (BYTE)val<<2;
		OSDStart[winno-OSDCURSORWINDOW][2] = tmp;
		OSDStart[winno-OSDCURSORWINDOW][0] = OSDStart[winno-OSDCURSORWINDOW][0] | (tmp>>4 & 0x70);
	}

	WaitEndofDisplayArea();	
	//WriteTW88(0x90, 0x80); //Close OSD by external
/*	for (winno=OSDCURSORWINDOW; winno<=OSDMENU_TITLEWIN ;winno++ )
	{
		SetOSDWindowNum(j);
		WriteTW88(TW88_WINATTR, 0x00);
	}


	delay(1);
*/
	// Move OSD Position of each windows
//	WriteTW88(0xff, ReadTW88(0xff) & 0xef);
	WriteTW88(0xe0, ReadTW88(0xe0) & 0xef);
	for( winno=OSDCURSORWINDOW; winno<=OSDMENU_TITLEWIN; winno++) {
		SetOSDWindowNum(winno);				// set winno
#ifdef INTERNAL_MCU // it doesn't have auto increase I2C mode
		WriteTW88(0xa0, OSDStart[winno-OSDCURSORWINDOW][0]);
		WriteTW88(0xa1, OSDStart[winno-OSDCURSORWINDOW][1]);
		WriteTW88(0xa2, OSDStart[winno-OSDCURSORWINDOW][2]);
#else
		WriteI2Cn(TW88I2CAddress, 0xa0, &OSDStart[winno-OSDCURSORWINDOW], 3); 
#endif
	}
//	WriteTW88(0xff, ReadTW88(0xff) | 0x10);
	WriteTW88(0xe0, ReadTW88(0xe0) | 0x10);
	SaveOSDPositionModeEE(i);

	WaitEndofDisplayArea();	
	WriteTW88(0x90, 0); // Open OSD


	return i;
}

/*
BYTE GetOSDMenuXValue(void)
{
	int ival;

	Mapping1(OSDMenuX, &OSDMenuXRange, &ival, &UserRange);
	OSDItemValue = ival;
	return (BYTE)ival;
}

BYTE GetOSDMenuYValue(void)
{
	int ival;

	Mapping1(OSDMenuY, &OSDMenuYRange, &ival, &UserRange);
	OSDItemValue = ival;
	return (BYTE)ival;
}


BYTE SetOSDMenuYValue(BYTE flag)
{

	int val, add;
	BYTE winno;

    add = ( flag==UP  ? 1  :  -1  );
	val =  OSDItemValue + add;
	if( val< UserRange.Min || val> UserRange.Max ) {
		return GetOSDMenuYValue();
	}

	Mapping1(val, &UserRange, &add, &OSDMenuYRange);
	SaveOSDYPositionEE(add);
	add -= OSDMenuY;
	OSDMenuY += add;
	SaveOSDYPositionEE(OSDMenuY);
	OSDItemValue = val;

	for( winno=OSDCURSORWINDOW; winno<=OSDMENU_TITLEWIN; winno++) {
		val = GetOSDWindowY( winno );
		SetOSDWindowY(winno,val+add);
	}
	return OSDItemValue;
}

BYTE SetOSDMenuXValue(BYTE flag)
{
	int val, add;
	BYTE winno;

	add = ( flag==UP  ? 1  :  -1  );
	val = OSDItemValue + add;
	if( val< UserRange.Min || val> UserRange.Max ) {
		return OSDItemValue;
	}

	Mapping1(val, &UserRange, &add, &OSDMenuXRange);
	add -= OSDMenuX;
	OSDMenuX += add;
	SaveOSDXPositionEE(OSDMenuX);
	OSDItemValue = val;

	for( winno=OSDCURSORWINDOW; winno<=OSDMENU_TITLEWIN; winno++) {
		val = GetOSDWindowX( winno );
		SetOSDWindowX(winno,val+add);
	}
	return OSDItemValue;

}
*/
#endif
/*
BYTE SetOSDDuration(BYTE newd)
{
	OSDDuration = newd;
	return OSDDuration;
}

*/
void ResetOSDValue(void)
{

	OSDMenuX = OSDPOSITIONMODE_TABLE[0][0];  // Default
	OSDMenuY = OSDPOSITIONMODE_TABLE[0][1];
	#ifdef SUPPORT_OSDPOSITIONMOVE
	SaveOSDPositionModeEE(0);
	#endif
//	SetOSDDuration( 10);
//	SaveOSDDurationEE(10);

	SaveOSDLangEE(0);	// Save default Language1

	InitOSDMenu();	
}

#define HOUR			1
#define MIN				2
#define MAX_LANG	5	// Max Language : 2
BYTE GetOSDLang(void)
{
	OSDLang = GetOSDLangEE();
	OSDLang %= MAX_LANG;
	return OSDLang;
}

BYTE SetLanguage (BYTE flag)
{
	char inc;
	inc = ( flag==UP  ? 1  :  -1  );
	OSDLang = OSDLang + MAX_LANG + inc;
	OSDLang %= MAX_LANG ; 

	SaveOSDLangEE(OSDLang);

	return OSDLang;
}


#define INC_SLEEPTIMER		30
#define	MAX_SLEEPTIMER		150

BYTE ChangeSleepTimer( BYTE flag )
{
	int t;

	t = OSDItemValue / INC_SLEEPTIMER * INC_SLEEPTIMER;		//cut edge of remained sleep timer.

	if( flag==UP )	t+= INC_SLEEPTIMER;
	else			t-= INC_SLEEPTIMER;

	if( t<0 )		t = 0;
	if( t> MAX_SLEEPTIMER)	t = MAX_SLEEPTIMER;

	OSDItemValue = t;
	return OSDItemValue;
}


//======================================================================
/*BYTE GetOSDDurationValue(void)
{
	OSDItemValue = GetOSDDurationEE();
	return OSDItemValue;

}

BYTE GetOSDDuration(void)
{
	return OSDDuration;
}
*/
void SetRGBContrast( BYTE temp, BYTE val )
{
	WORD index;
	BYTE i;
	int newval, toValue;

	index = PC_COLOR_DATA + 1 + temp*3;
	for( i=0; i<3; i++)
	{
		 newval = ReadEEP( index+i );
		 Mapping1( newval, &UserRange , &toValue, &PCUserColorTempRange);
               SelectPanelAttrRegGroup(GROUP_RGB); // Need to refresh "INDX_CB" bit  // Hans
	 	 SetPanelContrastReg(i,   toValue + val );
	}
}

#define MAX_COLORTEMP	4

CODE BYTE PCColorTempRGB[][3]={
	75,		50,		50,				// Mode 1: Warm
	50,		50,		50,				// Mode 2: plain -- COLOR_MODE2
	50,		50,		75,				// Mode 3: Cold
	50,		50,		50				// User mode
};

#define COLOR_MODE2		1
#define COLOR_USER		3

BYTE SetPCColorTemp(BYTE flag)
{
	BYTE val;
	int  regv;
	char inc;

	//OSDItemValue = GetPCColorTempModeEE();

	inc = ( flag==UP  ? 1  :  -1  );
	OSDItemValue = OSDItemValue + MAX_COLORTEMP + inc;
	OSDItemValue %= MAX_COLORTEMP ; 

	SetPCColorTempModeEE ( OSDItemValue );
	val = GetPanelContrastEE();
	Mapping1( val, &UserRange ,&regv, &PanelContrastRange);
	SetRGBContrast( OSDItemValue, (BYTE)regv );

	if( GetPCColorTempModeEE() != 3 )  // User
			DrawAttrCnt(OSDMENU_SUBADDR+MENU_WIDTH*2, BACK_COLOR, (MENU_HEIGHT-1)*MENU_WIDTH );	
	else
			DrawAttrCnt(OSDMENU_SUBADDR+MENU_WIDTH*2, DEFAULT_COLOR, (MENU_HEIGHT-1)*MENU_WIDTH );	

	return OSDItemValue;
}

#ifdef SUPPORT_PC
BYTE GetPCColorTemp(BYTE color) 
{
	OSDItemValue = GetPCUserColorTempEE(color);
	return OSDItemValue;
}
#endif

BYTE SetPCColor(BYTE color, BYTE flag) 
{
	int newval, toValue, regv;

//	GetPCColorTemp(color);
	newval = ( flag==UP  ? OSDItemValue+1  :  OSDItemValue-1  );
	if( newval< UserRange.Min || newval> UserRange.Max )
		return OSDItemValue;

	OSDItemValue = newval;
	Mapping1( newval, &UserRange , &toValue, &PCUserColorTempRange);
	SavePCUserColorTempEE(color, newval);

	newval = GetPanelContrastEE() ;
	Mapping1( newval, &UserRange ,&regv, &PanelContrastRange);

	SelectPanelAttrRegGroup(GROUP_RGB); // Need to refresh "INDX_CB" bit  // Hans
	SetPanelContrastReg(color,(BYTE)(toValue + regv) );

	return  OSDItemValue;
}



#if defined( SUPPORT_PC ) || defined( SUPPORT_DTV )

void ResetPanelAttributeValue(void)
{
	BYTE i, j;

	SetPCColorTempModeEE( COLOR_USER );	//default
	for( j=0; j< 4; j++)
		for( i=0; i< 3; i++)
			WriteEEP ( PC_COLOR_DATA + 1 + j*3 + i, PCColorTempRGB[j][i] );

	SavePanelContrastEE( UserRange.Default );
	SavePanelBrightnessEE( UserRange.Default );

	GetInitPanelAttribute1();		// Panel Brightness / Contrast
}

BYTE SetPanelContrast(BYTE flag) 
{

	int newval, regv;

	newval = ( flag==UP  ? OSDItemValue+1  :  OSDItemValue-1  );
	if( newval< UserRange.Min || newval> UserRange.Max )
		return OSDItemValue;

	Mapping1( newval, &UserRange , &regv, &PanelContrastRange);
	SetRGBContrast( GetPCColorTempModeEE(), regv );
	SavePanelContrastEE(newval);

	OSDItemValue = newval;
	return newval;
}

BYTE SetPanelBrightness(BYTE flag) 
{

	int newv, regv;

	newv = ( flag==UP  ? OSDItemValue+1  :  OSDItemValue-1  );
	if( newv< UserRange.Min || newv> UserRange.Max )
		return OSDItemValue;

	Mapping1( newv, &UserRange , &regv, &PanelBrightnessRange);
	SelectPanelAttrRegGroup(GROUP_RGB); // Need to refresh "INDX_CB" bit  // Hans
	SetPanelBrightnessReg(RED,  (BYTE)regv);
	SetPanelBrightnessReg(GREEN,(BYTE)regv);
	SetPanelBrightnessReg(BLUE, (BYTE)regv);
	SavePanelBrightnessEE(newv);
	OSDItemValue = newv;
	return newv;
}

#endif


CODE BYTE VideoModeTable[][6] ={
	{	0x11,   0x10,     0x13,     0x14, 0x15,   0x78,},// TW8816's Video Picture control Reg Address
//       contrast-+-bright-+-sat_u-+-sat_v-+-hue-+--sharpness---+
	{	0x63,     0x00,	0x80,     0x80,     0x00,     0x3b,  },	// Mode 1: 
	{	0x68,     0xf8,	0x90,     0x90,     0x00,     0x03,  },	// Mode 2: 
	{	0x58,     0xf8,	0xa0,     0xa0,     0x00,     0x03,  },	// Mode 3: 
//	{	0x60,     0x00,	0x80,     0x80,     0x00,     0x03,  },	// User Mode 
};

#define USER_VIDEOMODE	3
void SetVideoMode(BYTE mode)
{
	int  i,regv;

	SetVideoModeEE ( mode );
	
       // don't load settings from eeprom when no eeprom. // Hans 	
       if(( GetFWRevEE()!=FWVER ) || (mode > USER_VIDEOMODE))
       {