scrsav.c

MTK portableDVD 采用mtk1389方案的代码

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 03/10/27 10:19a   $       ****************/
/***************  $Revision: 2.0 $       ****************/
/***************                                       ****************/
/***************   Description : OSD                   ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Peter Huang           ****************/
/**********************************************************************/

#include "general.h"
#include <stdlib.h>

#pragma NOAREGS

#ifdef GUI_DC_SELECT
extern BOOL _fgInitMsgKeep;
#endif

//#define SCRSAV_DEBUG
#ifdef SCRSAV_DEBUG
extern DRS232LogS(char * pcStr);
extern DRS232LogB(BYTE bV1, BYTE bV2, BYTE bV3, BYTE bV4);
extern xdata DWRD _dCreatedWB;
#endif

#define SS_RET_FALSE         0
#define SS_RET_SUCCESS       1
#define SS_RET_PROCESSING    2
#define SS_RET_FINISHED      3

#define SS_PROCESS_PERIOD   15
#define SS_FADE_OUT_SPEED   3
#define SS_MIXRATE_MAX      15

#define SS_POS_X_MIN     WB_SS_START_X
#define SS_POS_X_MAX     WB_SS_END_X
#define SS_POS_Y_MIN     WB_SS_START_Y
#define SS_POS_Y_MAX     WB_SS_END_Y


/*the size of foot_bmp*/
#define BMP_UP_BEAR_H       86    //MIN 86
#define BMP_UP_BEAR_W       106
#define BMP_UPL_BEAR_H      54    //MIN 54
#define BMP_UPL_BEAR_W      106 
#define BMP_UPR_BEAR_H      68    //MIN 58
#define BMP_UPR_BEAR_W      106
#define BMP_R_BEAR_OFFSET   40
#define BMP_L_BEAR_OFFSET   70
#define BMP_BEAR_MAX_W      106


#define BMP_UP_BIRD_H         78     //MIN 78
#define BMP_UP_BIRD_W         78
#define BMP_UPL_BIRD_H        48    //MIN 38
#define BMP_UPL_BIRD_W        100
#define BMP_UPR_BIRD_H        48   //MIN 38
#define BMP_UPR_BIRD_W        100
#define BMP_L_BIRD_OFFSET     48
#define BMP_R_BIRD_OFFSET     42
#define BMP_BIRD_MAX_W        100



#define BMP_UP_PIG_H       56   //MIN 56
#define BMP_UP_PIG_W       56
#define BMP_UPL_PIG_H      36   // MIN 30
#define BMP_UPL_PIG_W      56
#define BMP_UPR_PIG_H      36   //MIN 36
#define BMP_UPR_PIG_W      56
#define BMP_L_PIG_OFFSET   42
#define BMP_R_PIG_OFFSET   32
#define BMP_PIG_MAX_W      56


#define BMP_UP_HUMAN_H      100
#define BMP_UP_HUMAN_W      78
#define BMP_UPL_HUMAN_H     64     //MIN 60
#define BMP_UPL_HUMAN_W     104
#define BMP_UPR_HUMAN_H     64    //MIN 56
#define BMP_UPR_HUMAN_W     104 
#define BMP_L_HUMAN_OFFSET  40
#define BMP_R_HUMAN_OFFSET  40
#define BMP_HUMAN_MAX_W     104

#define BMP_UP_BBK_H        50
#define BMP_UP_BBK_W        174
#define BMP_UP_BBK_OFFSET   80
#define BMP_LR_BBK_OFFSET   150
#define BMP_BBK_MAX_W       174

typedef enum
{
  SS_DIR_UP,      
  SS_DIR_DOWN,   
  SS_DIR_RIGHT,     
  SS_DIR_LEFT,     
  SS_DIR_UP_RIGHT,  
  SS_DIR_UP_LEFT,    
  SS_DIR_DOWN_RIGHT, 
  SS_DIR_DOWN_LEFT,
  SS_DIR_NS,
  SS_DIR_MAX = SS_DIR_NS - 1,
  SS_DIR_NONE = 0xFF
} E_SS_DIRECTION ; 


typedef enum
{
  SS_POS_TOP,      
  SS_POS_BOTTOM,   
  SS_POS_RIGHT,     
  SS_POS_LEFT,     
  SS_POS_NS,
  SS_POS_MAX = SS_POS_NS - 1,
  SS_POS_NONE = 0xFF
} E_SS_POSITION ; 


typedef enum
{
  SS_BMP_BEAR,
	SS_BMP_BIRD,
	SS_BMP_PIG,
	SS_BMP_HUMAN,
  SS_BMP_BBK,
	SS_BMP_NS,
	SS_BMP_MAX = SS_BMP_NS - 1,
	SS_BMP_NONE = 0xFF
} E_SS_BMP_TARGET;

typedef enum
{
  SS_STATE_INIT,
	SS_STATE_WALKING,
	SS_STATE_PASTE,
	SS_STATE_FINISHED,
	SS_STATE_NS,
	SS_STATE_MAX = SS_STATE_NS - 1,
	SS_STATE_NONE = 0xFF
} E_SS_STATE;


typedef enum
{
	SS_COL_BACKGROUND,
	SS_COL_BLACK1,
	SS_COL_BLACK2,
	SS_COL_WHITE1,
	SS_COL_GREEN1,
	SS_COL_ORANGE1,
	SS_COL_BLUE1,
	SS_COL_WHITE2,
	SS_COL_GREEN2,
	SS_COL_ORANGE2,
	SS_COL_BLUE2,
	SS_COL_WHITE3,
	SS_COL_GREEN3,
	SS_COL_ORANGE3,
	SS_COL_BLUE3,
	SS_COL_BLACK3,
  SS_COL_NS,
  SS_COL_MAX = SS_COL_NS - 1,
  SS_COL_NONE = SS_COL_BACKGROUND
};


typedef BYTE (code *bSsBmpState)(void) large;

xdata BYTE _bSSDelay;
xdata BYTE _bBmpMarker;  //record which bmp has been display.
xdata WORD _wPosX;
xdata WORD _wPosY;
xdata E_SS_DIRECTION _eDiretion;
xdata E_SS_BMP_TARGET _eBmpTarget = SS_BMP_NONE;
xdata E_SS_STATE _eSsState;
xdata WORD _wSsBmpIdx;
xdata BYTE _bSsColIdx;
xdata BYTE _bSsMixRat;
extern void vUpdMp3Info() large;//songchen.


/*********************************************************************
  Function    : static void bSsGetStartPos(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static void bSsGetStartPos(BYTE bPos, WORD bSpace) large
{
	switch(bPos)
	{
    case SS_POS_TOP:
		{
			_wPosY = WB_SS_START_Y;
			_wPosX = (WORD)bSpace * (rand() % (SS_BMP_WIDTH / bSpace - 1) + 1);
      break;
    }

		case SS_POS_BOTTOM:
		{
			_wPosY = WB_SS_END_Y;
			_wPosX = rand() % (SS_BMP_WIDTH - bSpace - 1);
      break;
		}

		case SS_POS_RIGHT:
		{
			_wPosY = (WORD)bSpace * (rand() % (SS_BMP_HEIGHT / bSpace - 1) + 1);
			_wPosX = WB_SS_END_X;
      break;
		}

		case SS_POS_LEFT:
		{
			_wPosY = (WORD)bSpace * (rand() % (SS_BMP_HEIGHT / bSpace - 1) + 1);
			_wPosX = WB_SS_START_X;
      break;
		}

		default:
		break;
	}

	_eDiretion = rand() % SS_DIR_NS;
} 


/*********************************************************************
  Function    : static BYTE bSsGetNextPosBear(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static BYTE bSsGetNextPosBear(void) large
{
	int  bTemp;
	BYTE bRet = SS_RET_SUCCESS;

	//_eDiretion = rand() % SS_DIR_NS;

	switch(_eDiretion)
	{
    case SS_DIR_UP:
		case SS_DIR_DOWN:
    {
			bTemp = (int)_wPosY - BMP_UP_BEAR_H;
			if(bTemp > 0)
			{
			  _wPosY = (WORD)bTemp;
			}
			else
			{
        return(bRet = SS_RET_FALSE);
			}
					
			_wSsBmpIdx = BMP_SS_BEAR_UP;
			break;
		}
				
		case SS_DIR_UP_RIGHT:
		case SS_DIR_DOWN_RIGHT:
		case SS_DIR_RIGHT:
    {
			bTemp = (int)_wPosY - BMP_UPR_BEAR_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
        return(bRet = SS_RET_FALSE);
			}
					
			bTemp = _wPosX + BMP_R_BEAR_OFFSET;
			if(bTemp < (WB_SS_END_X - BMP_UPR_BEAR_W))
			{
			  _wPosX = (WORD)bTemp;
			}
			else
			{
        return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BEAR_UPR;
			break;
		}
				
		case SS_DIR_UP_LEFT:
		case SS_DIR_DOWN_LEFT:
		case SS_DIR_LEFT:
		default:
		{
			bTemp = (int)_wPosY - BMP_UPL_BEAR_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
						
			bTemp = (int)_wPosX - BMP_L_BEAR_OFFSET;
			if(bTemp > 0)
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BEAR_UPL;
			break;
		}
	}

  return(bRet);
}



/*********************************************************************
  Function    : static BYTE bSsGetNextPosBird(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static BYTE bSsGetNextPosBird(void) large
{
	int  bTemp;
	BYTE bRet = SS_RET_SUCCESS;

	//_eDiretion = rand() % SS_DIR_NS;

	switch(_eDiretion)
	{
		case SS_DIR_UP:
		case SS_DIR_DOWN:
		{
			bTemp = (int)_wPosY - BMP_UP_BIRD_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BIRD_UP;
			break;
		}
					
		case SS_DIR_UP_RIGHT:
		case SS_DIR_DOWN_RIGHT:
		case SS_DIR_RIGHT:
		{
			bTemp = (int)_wPosY - BMP_UPR_BIRD_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
						
			bTemp = _wPosX + BMP_R_BIRD_OFFSET;
			if(bTemp < (WB_SS_END_X - BMP_UPR_BIRD_W))
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BIRD_UPR;
			break;
		}
				
		case SS_DIR_UP_LEFT:
		case SS_DIR_DOWN_LEFT:
		case SS_DIR_LEFT:
		default:
		{
			bTemp = (int)_wPosY - BMP_UPL_BIRD_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
							
			bTemp = (int)_wPosX - BMP_L_BIRD_OFFSET;
			if(bTemp > 0)
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BIRD_UPL;
			break;
		}
	}

	return(bRet);
}


/*********************************************************************
  Function    : static BYTE bSsGetNextPosPig(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static BYTE bSsGetNextPosPig(void) large
{
	int  bTemp;
	BYTE bRet = SS_RET_SUCCESS;

	//_eDiretion = rand() % SS_DIR_NS;

	switch(_eDiretion)
	{
		case SS_DIR_UP:
		case SS_DIR_DOWN:
		{
			bTemp = (int)_wPosY - BMP_UP_PIG_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
	
			_wSsBmpIdx = BMP_SS_PIG_UP;
			break;
		}
						
		case SS_DIR_UP_RIGHT:
		case SS_DIR_DOWN_RIGHT:
		case SS_DIR_RIGHT:
		{
			bTemp = (int)_wPosY - BMP_UPR_PIG_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
							
			bTemp = _wPosX + BMP_R_PIG_OFFSET;
			if(bTemp < (WB_SS_END_X - BMP_UPR_PIG_W))
			{
			  _wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
	
			_wSsBmpIdx = BMP_SS_PIG_UPR;
			break;
		}
					
		case SS_DIR_UP_LEFT:
		case SS_DIR_DOWN_LEFT:
		case SS_DIR_LEFT:
		default:
		{
			bTemp = (int)_wPosY - BMP_UPL_PIG_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
								
			bTemp = (int)_wPosX - BMP_L_PIG_OFFSET;
			if(bTemp > 0)
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
	
			_wSsBmpIdx = BMP_SS_PIG_UPL;
			break;
		}
	}
	
	return(bRet);
}



/*********************************************************************
  Function    : static BYTE bSsGetNextPosHuman(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static BYTE bSsGetNextPosHuman(void) large
{
	int  bTemp;
	BYTE bRet = SS_RET_SUCCESS;

	//_eDiretion = rand() % SS_DIR_NS;

	switch(_eDiretion)
	{
		case SS_DIR_UP:
		case SS_DIR_DOWN:
    {
			bTemp = (int)_wPosY - BMP_UP_HUMAN_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_HUMAN_UP;
			break;
		}
						
		case SS_DIR_UP_RIGHT:
		case SS_DIR_DOWN_RIGHT:
		case SS_DIR_RIGHT:
		{
			bTemp = (int)_wPosY - BMP_UPR_HUMAN_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
							
			bTemp = _wPosX + BMP_R_HUMAN_OFFSET;
			if(bTemp < (WB_SS_END_X - BMP_UPR_HUMAN_W))
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_HUMAN_UPR;
			break;
		}
					
		case SS_DIR_UP_LEFT:
		case SS_DIR_DOWN_LEFT:
		case SS_DIR_LEFT:
		default:
		{
			bTemp = (int)_wPosY - BMP_UPL_HUMAN_H;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
								
			bTemp = (int)_wPosX - BMP_L_HUMAN_OFFSET;
			if(bTemp > 0)
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_HUMAN_UPL;
			break;
		}
	}
				
  return(bRet);
}


/*********************************************************************
  Function    : static BYTE bSsGetNextPosBBK(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static BYTE bSsGetNextPosBBK(void) large
{
	int  bTemp;
	BYTE bRet = SS_RET_SUCCESS;

	//_eDiretion = rand() % SS_DIR_NS;

  switch(_eDiretion)
	{
		case SS_DIR_UP:
		case SS_DIR_DOWN:
		{
			bTemp = (int)_wPosY - BMP_UP_BBK_H - BMP_UP_BBK_OFFSET;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BBK;
			break;
		}
							
		case SS_DIR_UP_RIGHT:
		case SS_DIR_DOWN_RIGHT:
		case SS_DIR_RIGHT:
		{
			bTemp = (int)_wPosY - BMP_UP_BBK_H - BMP_UP_BBK_OFFSET;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
								
			bTemp = _wPosX + BMP_LR_BBK_OFFSET;
			if(bTemp < (WB_SS_END_X - BMP_UP_BBK_W))
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BBK;
			break;
		}
						
		case SS_DIR_UP_LEFT:
		case SS_DIR_DOWN_LEFT:
		case SS_DIR_LEFT:
		default:
		{
			bTemp = (int)_wPosY - BMP_UP_BBK_H - BMP_UP_BBK_OFFSET;
			if(bTemp > 0)
			{
				_wPosY = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}
									
			bTemp = (int)_wPosX - BMP_LR_BBK_OFFSET;
			if(bTemp > 0)
			{
				_wPosX = (WORD)bTemp;
			}
			else
			{
				return(bRet = SS_RET_FALSE);
			}

			_wSsBmpIdx = BMP_SS_BBK;
			break;
		}
	}

  return(bRet);
}

/*********************************************************************
  Function    : static void vSsPasteBmp(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static void vSsPasteBmp(void) large
{
  if((SS_BMP_NONE != _eBmpTarget) && (BMP_NULL != _wSsBmpIdx))
  {
    vOsdPasteBmpXY(_wPosX, _wPosY, WB_SS, _wSsBmpIdx);
  }
}


/*********************************************************************
  Function    : static void vSsGetBmpColor(void) large
  Description : 
  Parameter :
  Return    :
**********************************************************************/
static void vSsGetBmpColor(void) large
{
  BYTE bColor;

	bColor = rand() % SS_COL_NS;

	switch(bColor)
	{
    case SS_COL_WHITE1:
		case SS_COL_WHITE2:
		case SS_COL_WHITE3:
		case SS_COL_BACKGROUND:
    {
			_bSsColIdx = SS_COL_WHITE1;
			break;
    }