msosd.c

完整的软件学习--显示器驱动视频软件

#include <stdlib.h>
#include "types.h"
#include "ms_reg.h"
#include "board.h"
#include "panel.h"
#include "Menudef.h"
#include "font.h"
#include "debug.h"
#include "ms_rwreg.h"
#include "mstar.h"
#include "misc.h"
#include "global.h"
#include "Extlib.h"

extern idata Bool OsdTimeDrawGuageFlag;
extern idata Bool OsdTranDrawGuageFlag;

#if 0
#define DoubleXSize	0
#define DoubleYSize	0
#endif

#define  FontStart	0x00

//#define fourColorFontStart	0xa0 //colorfont address

#define eightColorFontStart	0xA0 //colorfont address

#define GuageFont1_Start 	0x12
#define GuageFont2		       0x13
#define GuageFont3			0x14
#define GuageFont4			0x15
#define GuageFont5			0x16
#define GuageFont6			0x17
#define GuageFont7			0x18
#define GuageFont8			0x19
#define GuageFont9			0x1A
#define GuageFont10			0x1B
#define GuageFont11			0x1C
#define GuageFont12			0x1D
#define GuageFont13			0x1E
#define GuageFont14			0x1F
#define GuageFont15_End		0x20

BYTE LanguageIndex=0;
BYTE SecondTblAddr=0xFF;

//==================================================================================
// Local function declaration
//
void mStar_WriteOSDByte(BYTE address, BYTE value);
BYTE mStar_ReadOSDByte(BYTE address);
void Osd_SetWindowSize(BYTE width, BYTE height);
void Osd_SetPosition(BYTE xPos, BYTE yPos);
void Osd_DrawChar(BYTE xPos, BYTE yPos, BYTE ch);
//void Osd_LoadFont(BYTE addr, WORD *fontPtr, BYTE num);
void Osd_LoadFont(BYTE addr, BYTE *fontPtr, WORD num);
void Osd_LoadColor(BYTE *colorPtr, BYTE num);
void Osd_LoadColorFont(BYTE addr, BYTE *fontPtr, WORD num);
void DrawLeftAlignNum(BYTE xPos, BYTE yPos, WORD value);
extern void Osd_setOsdTranslucent(BYTE value);

extern BYTE	MenuPageIndex;

//==================================================================================
// variable declaration
//
BYTE OsdWindowWidth=41;
BYTE OsdWindowHeight=15;
BYTE OsdFontColor=0x01;

xdata BYTE DoubleXSize;
xdata BYTE DoubleYSize;


//==================================================================================
// Code start
void Osd_InitOSD(void)
{ // Osd transparency control
  { BYTE retry=10;

    while (retry--)
      { mStar_WriteByte(OSDIOA, CLR_B);
        Delay1ms(3);
        if (mStar_ReadByte(OSDIOA)&CLR_B)
          mStar_ResetDClkPLL();
      }
  }
#if ChipID==ChipBB
  { mStar_WriteOSDByte(OSDDBC, 0x4); // enable double
    mStar_WriteOSDByte(OSDW, 0);
    mStar_WriteOSDByte(OSDH, 0);
    Osd_DrawChar(0, 0, 0x2);
    mStar_WriteOSDByte(IOSDC1, 0x03); //
    ForceDelay1ms(60);
    mStar_WriteOSDByte(IOSDC1, 0x00);
  }
#endif

  mStar_WriteByte(BLENDC, 0);//
  mStar_WriteByte(BLENDL, 0);//

  mStar_WriteOSDByte(OSDDBC, 0x5); // enable double
  mStar_WriteOSDByte(OCBUFO, 0x00); // disable OSD code buffer Base/Offset address
  
  
  Osd_SetWindowSize(20, 10); // set osd window
  Osd_SetPosition(50, 50); // set osd position
  Osd_LoadFont(0, &tOSDFont0, sizeof(tOSDFont0)); // load osd fonts
 // Osd_LoadFont(fourColorFontStart,&tOSDFourFont, sizeof(tOSDFourFont)); //VICK DBUGGCOLORFONT
  Osd_LoadColor(&tOSDColorPalette0, sizeof(tOSDColorPalette0));   
  mStar_WriteOSDByte(OCFF, 0x82);  // sail modify
  mStar_WriteOSDByte(IOSDC2, 0x83); //0x03); // color bit setting//VICK DBUGGCOLORFONT   // sail modify
  mStar_WriteOSDByte(OSDCFA, eightColorFontStart); // color font start address

     // load 8Color font table
  Osd_LoadFont(eightColorFontStart,&tOSDEightFont, sizeof(tOSDEightFont)); 

   

   if(TranslucentOffFlag)
	Osd_setOsdTranslucent(0);
  else
	Osd_setOsdTranslucent(0);

}


//--------------------------------------------------------------------
void DynamicLoadColorFont(void)
{
       if((MenuPageIndex==FactoryMenu)||(MenuPageIndex==ISPMenu)||(MenuPageIndex==DDCTypeMenu))
	   	 Osd_LoadFont(0, &tOSDFont0, sizeof(tOSDFont0)); // load osd fonts
#if Dual_Input_Icon_Enable
	else if(MenuPageIndex==StandbyMenu || MenuPageIndex==CableNotConnectedMenu || MenuPageIndex==SourceTypeMenu)
		{
		Osd_LoadFont(0, &tOSDFont0, sizeof(tOSDFont0)); // load osd fonts
		Osd_LoadFont(eightColorFontStart,&tAlarmEightFont, sizeof(tAlarmEightFont));
		}
#else
	else if(MenuPageIndex==StandbyMenu || MenuPageIndex==CableNotConnectedMenu)
		Osd_LoadFont(eightColorFontStart,&tAlarmEightFont, sizeof(tAlarmEightFont)); 
#endif
	else
		Osd_LoadFont(eightColorFontStart,&tOSDEightFont, sizeof(tOSDEightFont)); 
}

// setup osd window size
void Osd_SetWindowSize(BYTE width, BYTE height)
{ OsdWindowWidth=width&0x3F;
  OsdWindowHeight=height&0x1F;
  mStar_WriteOSDByte(OSDW, OsdWindowWidth-1);
  mStar_WriteOSDByte(OSDH, OsdWindowHeight-1);

  mStar_WriteByte(OSDIOA, 0xDE); // clear osd content
  ForceDelay1ms(3);
  mStar_WriteByte(OSDIOA, 0x9E);
}

// setup

void Osd_SetPosition(BYTE xPos, BYTE yPos)
{ WORD posValue;


if(MenuPageIndex==AutoMenu || MenuPageIndex==StandbyMenu || MenuPageIndex==CableNotConnectedMenu)
	  posValue=((DWORD)xPos*(PanelWidth-(WORD)OsdWindowWidth*12*2))/100+(PanelHStart-48);
else
	  posValue=((DWORD)xPos*(PanelWidth-(WORD)OsdWindowWidth*12))/100+(PanelHStart-48);


  posValue=posValue/4;
  mStar_WriteOSDByte(OHSTA_L, posValue&0xFF);
  mStar_WriteOSDByte(OHSTA_H, posValue>>8);


if(MenuPageIndex==AutoMenu || MenuPageIndex==StandbyMenu || MenuPageIndex==CableNotConnectedMenu)
	  posValue=((DWORD)yPos*(PanelHeight-(WORD)OsdWindowHeight*18*2))/100;
else
	  posValue=((DWORD)yPos*(PanelHeight-(WORD)OsdWindowHeight*18))/100;

  posValue=posValue/4;
  mStar_WriteOSDByte(OVSTA_L, posValue&0xFF);
  mStar_WriteOSDByte(OVSTA_H, posValue>>8);
}

void Osd_LoadFont(BYTE addr, BYTE *fontPtr, WORD num)
{ mStar_WriteByte(RAMFA, addr);
 while (num--)//vick mask:
   mStar_WriteByte(RAMFD, *(fontPtr++));
 //mStar_WriteTBL(RAMFD,fontPtr,num,0);//vick quicker than before
}

void Osd_DynamicLoadFont(BYTE addr, BYTE *fontPtr, WORD num)
{ mStar_WriteByte(RAMFA, addr);
  LoadPropFonts(fontPtr, num);
}

void Osd_LoadColor(BYTE *colorPtr, BYTE num)
{ mStar_WriteByte(OSDRA, CLR0R);
  mStar_WriteTBL(OSDRD, colorPtr, num, 0);
}

void Osd_SetTextColor(BYTE foreColor, BYTE backColor)
{ OsdFontColor=(foreColor&0xF)<<4|(backColor&0xF);
}
BYTE Osd_GetTextColor(void)
{ return OsdFontColor;
}

void Osd_DrawChar(BYTE xPos, BYTE yPos, BYTE ch)
{ WORD tempValue;
  BYTE drawCode=TRUE;

  if (yPos&BIT7)
    drawCode=FALSE;
  yPos&=0x3F;//~(BIT7|BIT6);

  tempValue=(WORD)yPos*OsdWindowWidth+xPos; // get real address
  mStar_WriteWord(DISPAA_H, tempValue); // display font attribute
  mStar_WriteByte(DISPAD, OsdFontColor);
  if (drawCode)
    { mStar_WriteWord(DISPCA_H, tempValue); // dispaly font code
      mStar_WriteByte(DISPCD, ASCII2FONT[ch]);
    }
}

void Osd_DrawStr(BYTE xPos, BYTE yPos, BYTE *str)
{ WORD tempValue;
  BYTE drawCode=TRUE;

  if (yPos&BIT7)
    drawCode=FALSE;
  yPos&=0x3F;//~(BIT7|BIT6);

#define dispChar	xPos
#define dispPtr		yPos
  tempValue=(WORD)yPos*OsdWindowWidth+xPos; // get real address
  dispPtr=0;
  mStar_WriteWord(DISPAA_H, tempValue);
  while (dispChar=*(str+dispPtr))  // display string font index
    { mStar_WriteByte(DISPAD, OsdFontColor);
      dispPtr++;
    }
  if (drawCode==TRUE)
    { dispPtr=0;
      mStar_WriteWord(DISPCA_H, tempValue);
      while (dispChar=*(str+dispPtr))  // display string font index
        { mStar_WriteByte(DISPCD, ASCII2FONT[dispChar]);
          dispPtr++;
        }
    }
#undef dispChar
#undef dispPtr
}

void Osd_DrawPropStr(BYTE xPos, BYTE yPos, BYTE *str)
{ WORD tempValue;
  BYTE drawCode=TRUE;

  if (yPos&BIT7)
    { drawCode=FALSE;
    }
  yPos&=0x3F;//~(BIT7|BIT6);

#define dispChar	xPos
#define dispPtr		yPos
  tempValue=(WORD)yPos*OsdWindowWidth+xPos; // get real address
  dispPtr=0;
  mStar_WriteWord(DISPAA_H, tempValue);
  while (dispPtr++<*(str+1))
    mStar_WriteByte(DISPAD, OsdFontColor);

  if (drawCode==TRUE)
    { dispPtr=0;
      mStar_WriteWord(DISPCA_H, tempValue);
      while (dispPtr<*(str+1))
        { mStar_WriteByte(DISPCD, (*str)+dispPtr);
          dispPtr++;
  	    }
    }
#undef dispChar
#undef dispPtr
}

#define Num2ASCII(Num) (Num+0x30)
void DrawNum(BYTE xPos, BYTE yPos, char len, WORD value)//int value)
{ char _minus=0;

  if (value<0)
    { value=0-value;
      _minus=1;
    }
  if (value==0)
    Osd_DrawChar(xPos+(len--), yPos, (BYTE)Num2ASCII(0));
  else  if(value==100)	
  	{Osd_DrawChar(xPos+3, yPos, (BYTE)Num2ASCII(0));
       Osd_DrawChar(xPos+2, yPos, (BYTE)Num2ASCII(0));
       Osd_DrawChar(xPos+1, yPos, (BYTE)Num2ASCII(1));
  	}
  else  if(value>100)	
  	{
            while (value && len) // translate integer to string
                 { Osd_DrawChar(xPos+(len--), yPos, (BYTE)Num2ASCII(value%10));
                     value/=10;
                  }
  	}
  	
   else {	  Osd_DrawChar(xPos+1, yPos, ' ');//fendy add clear-xx from 100-> xx

	while (value && len) // translate integer to string
        {    
             Osd_DrawChar(xPos+2, yPos, ' ');//fendy add clear-x      
             Osd_DrawChar(xPos+(len--), yPos, (BYTE)Num2ASCII(value%10));
             value/=10;
        }
    }
    
}

void DrawLeftAlignNum(BYTE xPos, BYTE yPos, WORD value)
{
    BYTE len =0;
		WORD temp = value;
  
    if (value==0)
        Osd_DrawChar(xPos, yPos, (BYTE)Num2ASCII(0));
    else 
    { 
      while(value) {
				len++; 
				value/=10;
      	}
			value = temp;
//			printData("len %d" , len);
     while (value) // translate integer to string
        {
            Osd_DrawChar(xPos+len-1, yPos, (BYTE)Num2ASCII(value%10));
            value/=10;
  		    len--;
        }
    }
}


void Osd_DrawNum(BYTE xPos, BYTE yPos, int value)
{ DrawNum(xPos, yPos, 3, value);
}
#if 0
void Osd_Draw4Num(BYTE xPos, BYTE yPos, int value)
{ DrawNum(xPos, yPos, 5, value);
}
#endif

//========================================================


//===================================================================================
void Osd_DrawGuage(BYTE xPos, BYTE yPos, BYTE length, BYTE value)
{
// BYTE leadPtr;
 WORD AdtempValue;
unsigned int bound;
BYTE  TempValue,TempFont ,range=100;

if(OsdTimeDrawGuageFlag)  { range=60;     OsdTimeDrawGuageFlag = FALSE;   }
if( OsdTranDrawGuageFlag)  { range=7;     OsdTranDrawGuageFlag = FALSE;   }

  AdtempValue=(WORD)yPos*OsdWindowWidth+(xPos);//+1); // get real address
  mStar_WriteWord(DISPAA_H, AdtempValue); // display font attribute
  mStar_WriteWord(DISPCA_H, AdtempValue); // dispaly font code
	length = length-2 ;//-5;
	bound   = ((length-2)*6 + 2*3) * value;

for (yPos = 0; yPos < length; yPos++)
    	{
		
		if( yPos == 0 || yPos == (length-1) )
		{
			if( bound )
			{
				if( bound >= (range*3) )
				{
					TempFont= (yPos==0) ?  GuageFont4 : GuageFont15_End;
					bound = bound - range*3;
				}
				else
				{
			       	TempValue   = (bound << 4) / (range*3);
					bound = 0;
	
					if (4 > TempValue)
						TempFont= (yPos==0) ? GuageFont1_Start : GuageFont12;	
					else if (8 > TempValue)
						TempFont= (yPos==0) ? GuageFont2 : GuageFont13;
					else if (12 > TempValue)
						TempFont = (yPos==0) ? GuageFont3 : GuageFont14;
					else  TempFont = (yPos==0) ? GuageFont4 : GuageFont15_End;
				}
			}
			else
			{
				TempFont= (yPos==0) ? GuageFont1_Start : GuageFont12;	
			}
		}
		else
		{
			if( bound )
			{
				if( bound >= (range*6) )
				{
					TempFont= GuageFont11;
					bound = bound - range*6;
				}
				else
				{
					TempValue   = (bound << 4) / (range*6);
					bound = 0;
	
					if (1 > TempValue)
						TempFont = GuageFont5;
					else if (4 > TempValue)
						TempFont = GuageFont6;
					else if (6 > TempValue)
						TempFont = GuageFont7;
					else if (9 > TempValue)
						TempFont = GuageFont8;
					else if (11 > TempValue)
						TempFont = GuageFont9;
					else if (14 > TempValue)
						TempFont= GuageFont10;
					else
						TempFont= GuageFont11;
				}
			}
			else
			{
				TempFont = GuageFont5;
			}
		
		}

		mStar_WriteByte(DISPCD, TempFont);
              mStar_WriteByte(DISPAD, OsdFontColor);
		
	}

}

void Osd_Show(void)
{ 
if(MenuPageIndex==AutoMenu || MenuPageIndex==StandbyMenu || MenuPageIndex==CableNotConnectedMenu)
{
	DoubleXSize = 1;
	DoubleYSize = 1;
}
else	
{	DoubleXSize = UserPrefOsdSize;
	DoubleYSize = UserPrefOsdSize;	
}
mStar_WriteOSDByte(IOSDC1, (DoubleXSize<<4)|(DoubleYSize<<6)|MWIN_B|MWBT_B);
}
void Osd_ShowNative(void)
{ mStar_WriteOSDByte(IOSDC1, MWIN_B|MWBT_B);
}
void Osd_Hide(void)
{ mStar_WriteOSDByte(IOSDC1, 0x00);
}

void mStar_WriteOSDByte(BYTE address, BYTE value)
{ mStar_WriteByte(OSDRA, address);
  mStar_WriteByte(OSDRD, value);
}
BYTE mStar_ReadOSDByte(BYTE address)
{ mStar_WriteByte(OSDRA, address);
  return mStar_ReadByte(OSDRD);
}


// ============================
// Draw Hex for Debug
BYTE Hex2ASCII(BYTE Num)
{ return (Num<10)?(Num+0x30):(Num+0x37);
}


void DrawHex(BYTE xPos, BYTE yPos, WORD value)
{ 
char len=1;
  while (value && len>=0)
    { Osd_DrawChar(xPos+(len--), yPos, (BYTE)Hex2ASCII(value%0x10));
      value/=0x10;
    }
    if (len>=0)
    for (value=0; value<=len; value++)
      Osd_DrawChar(xPos+value, yPos, (BYTE)'0');
}

void Osd_DrawHex(BYTE xPos, BYTE yPos, WORD value)
{ DrawHex(xPos, yPos, value);
}