upgosdshow.c

M3355的源代码

#include <gui.h>
#include <comsub.h>
#include <flash.h>
#include <upgrade.h>

#define BG_COLOR	123
#define TEXT_COLOR	30

#define SCR_WIDHT	608
#define SCR_HIGH	424
/*
#define UPGRADE_READDATA	0
#define UPGRADE_WARNING	1
#define UPGRADE_DETECT		2
#define UPGRADE_EARSE		3
#define UPGRADE_PROGRAM	4
#define UPGRADE_FINISH		5
 
#define PROCESS_1	0
#define PROCESS_2	1
#define PROCESS_3	2
#define PROCESS_4	3
#define PROCESS_5	4
#define PROCESS_OK	4
#define PROCESS_ERROR	5
*/
static HDC upghdc;

void FillScrBG(void);
//void InitUpgOSD(void);
void CloseUpgOSD(void);
//void ShowUpgInfo(BYTE bState,BYTE bInputMsg);
void ShowReadDatainfo(BYTE bInputMsg);
void ShowWaringInfo(BYTE bInputMsg);
void ShowDetectInfo(BYTE bInputMsg);
void ShowEarseInfo(BYTE bInputMsg);
void ShowProgramInfo(BYTE bInputMsg);
void ShowFinishInfo();

void FillScrBG(void)
{
    RECT rect;
    HBRUSH hbr;

//for test
//	return;
	
//    SetRect(&rect,0,0, SCR_WIDHT,SCR_HIGH);
    SetRect(&rect,0,20, SCR_WIDHT,280);

    hbr = CreateSolidBrush(GetColorInDef256Palette(BG_COLOR));
    FillRect(upghdc,&rect,hbr);
    DeleteObject((HGDIOBJ)hbr);
}

void InitUpgOSD(void)
{
    upghdc = CreateDC("DISPLAY", "OSD", NULL, NULL);
    SetBkMode(upghdc, OPAQUE);
}

void CloseUpgOSD(void)
{
    DeleteDC(upghdc);
}

void ShowUpgInfo(BYTE bState,BYTE bInputMsg)
{
    switch(bState)
    {
    case UPGRADE_READDATA:
        ShowReadDatainfo(bInputMsg);
        break;
    case UPGRADE_WARNING:
        ShowWaringInfo(bInputMsg);
        break;
#if (_SDRAM_MODE==_SDRAM_4M16x1_MODE_)
    case UPGRADE_DETECT:
        ShowDetectInfo(bInputMsg);
        break;
    case UPGRADE_EARSE:
        ShowEarseInfo(bInputMsg);
        break;
    case UPGRADE_PROGRAM:
        ShowProgramInfo(bInputMsg);
        break;
    case UPGRADE_FINISH:
        ShowFinishInfo();
        break;
#endif
    }
}

void ShowReadDatainfo(BYTE bInputMsg)
{
    BYTE bTitle[] = ">>CDR Upgrade<<";
    BYTE bReadInfo[] = "Read Data   ";
    BYTE bInput[3];
    RECT rect;

    FillScrBG();
    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));
    SetRect(&rect,0,80, SCR_WIDHT,80+20);

    DrawText(upghdc,UNICODE(bTitle),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
    if((bInputMsg/10) == 0)
        bInput[0]=0x20;
    else
        bInput[0]=bInputMsg/10 + '0';
    bInput[1] = bInputMsg%10 + '0';
    bInput[2] = '\0';
    SetRect(&rect,0,160, SCR_WIDHT,160+20);
    StringCat(bReadInfo, bInput);
    DrawText(upghdc,UNICODE(bReadInfo),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);

}

void ShowWaringInfo(BYTE bInputMsg)
{
    BYTE bTitle[] = ">>CDR Upgrade<<";
    BYTE bWarning[] = "-WARNING-";
    BYTE bWarnInfo1[] ="Donot Power Off  during update";
    BYTE bWarnInfo2[] = "Permenent failure could result";
    BYTE bWarnHelp[] = "Press the [UP] key to start ...";
    BYTE bWarnHelp2[] = "Updating...";
	//Dickma 1212
    BYTE bWarnError1[] = "CD-upgrade disc bad";
    BYTE bWarnError2[] = "Flash bad, plesae change one";
    BYTE bWarnError3[] = "Upgrade failed(Power off...)";

    RECT rect;

    FillScrBG();
    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));

    SetRect(&rect,0,80, SCR_WIDHT,80+20);
    DrawText(upghdc,UNICODE(bTitle),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);

    SetRect(&rect,0,110, SCR_WIDHT,110+20);
    DrawText(upghdc,UNICODE(bWarning),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);

//	if (bInputMsg == 0)
	{
	    SetRect(&rect,0,140, SCR_WIDHT,140+20);
	    DrawText(upghdc,UNICODE(bWarnInfo1),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
	}

    SetRect(&rect,0,170, SCR_WIDHT,170+20);
    DrawText(upghdc,UNICODE(bWarnInfo2),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);

	SetRect(&rect,0,200, SCR_WIDHT,200+20);
	switch(bInputMsg)
	{
//    SetRect(&rect,0,240, SCR_WIDHT,240+20);
		case 0:
		    DrawText(upghdc,UNICODE(bWarnHelp),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
			break;
		case 1:
			DrawText(upghdc,UNICODE(bWarnError1),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
			break;
		case 2:
			DrawText(upghdc,UNICODE(bWarnError2),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
			break;
		case 3:
			DrawText(upghdc,UNICODE(bWarnError3),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
			break;
		case 4:
			DrawText(upghdc,UNICODE(bWarnHelp2),-1,&rect, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
			break;
	}
}

#if (_SDRAM_MODE==_SDRAM_4M16x1_MODE_)
void ShowDetectInfo(BYTE bInputMsg)
{
    BYTE bTitle[] = ">>CDR Upgrade<<";
    BYTE bDetect[] = "Flash Detect : Process.";
    BYTE bEarse[] = "Flash Erasing: Process";
    BYTE bProgram[] = "Flash Programming[      ]";
    BYTE bDetect2[] = ".";
    BYTE bDetect3[] = "..";
    BYTE bDetect4[] = "...";
    BYTE bDetectOk[] = "...OK";
    BYTE bDetectError[] = "...error";
    RECT rect;

    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));

    if(bInputMsg == PROCESS_1)
    {
        FillScrBG();
        SetRect(&rect,40,80, SCR_WIDHT,80+20);
        DrawText(upghdc,UNICODE(bTitle),-1,&rect, DT_SINGLELINE|DT_VCENTER);

        SetRect(&rect,40,160, SCR_WIDHT,160+20);
        DrawText(upghdc,UNICODE(bDetect),-1,&rect, DT_SINGLELINE|DT_VCENTER);

        SetRect(&rect,40,200, SCR_WIDHT,200+20);
        DrawText(upghdc,UNICODE(bEarse),-1,&rect, DT_SINGLELINE|DT_VCENTER);

        SetRect(&rect,40,240, SCR_WIDHT,240+20);
        DrawText(upghdc,UNICODE(bProgram),-1,&rect, DT_SINGLELINE|DT_VCENTER);
    }
    else
    {
        switch(bInputMsg)
        {
        case PROCESS_2:
            StringCat(bDetect, bDetect2);
            break;
        case PROCESS_3:
            StringCat(bDetect, bDetect3);
            break;
        case PROCESS_4:
            StringCat(bDetect, bDetect4);
            break;
        case PROCESS_OK:
            StringCat(bDetect, bDetectOk);
            break;
        case PROCESS_ERROR:
            StringCat(bDetect, bDetectError);
            break;
        }
        SetRect(&rect,40,160, SCR_WIDHT,160+20);
        DrawText(upghdc,UNICODE(bDetect),-1,&rect, DT_SINGLELINE|DT_VCENTER);

    }

}
void ShowProgramInfo(BYTE bInputMsg)
{
    BYTE bProgram[] = "Flash Programming:Process[";
    BYTE bProgram1[] = ">      ]";
    BYTE bProgram2[] = ">>     ]";
    BYTE bProgram3[] = ">>>    ]";
    BYTE bProgram4[] = ">>>>   ]";
    BYTE bProgram5[] = ">>>>>> ]";
    BYTE bProgramError[] = "....error]";
    RECT rect;

    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));

    switch(bInputMsg)
    {
    case PROCESS_1:
        StringCat(bProgram, bProgram1);
        break;
    case PROCESS_2:
        StringCat(bProgram, bProgram2);
        break;
    case PROCESS_3:
        StringCat(bProgram, bProgram3);
        break;
    case PROCESS_4:
        StringCat(bProgram, bProgram4);
        break;
    case PROCESS_5:
        StringCat(bProgram, bProgram5);
        break;
    case PROCESS_ERROR:
        StringCat(bProgram, bProgramError);
        break;
    }
    SetRect(&rect,40,240, SCR_WIDHT,240+20);
    DrawText(upghdc,UNICODE(bProgram),-1,&rect, DT_OPAQUE|DT_SINGLELINE|DT_VCENTER);



}
void ShowEarseInfo(BYTE bInputMsg)
{
    BYTE bEarse[] = "Flash Erasing: Process";
    BYTE bEarse1[] = ".";
    BYTE bEarse2[] = "..";
    BYTE bEarse3[] = "...";
    BYTE bEarse4[] = "....";
    BYTE bEarseOk[] = "....OK";
    BYTE bEarseError[] = "....error";
    RECT rect;

    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));

    switch(bInputMsg)
    {
    case PROCESS_1:
        StringCat(bEarse, bEarse1);
        break;
    case PROCESS_2:
        StringCat(bEarse, bEarse2);
        break;
    case PROCESS_3:
        StringCat(bEarse, bEarse3);
        break;
    case PROCESS_4:
        StringCat(bEarse, bEarse4);
        break;
    case PROCESS_OK:
        StringCat(bEarse, bEarseOk);
        break;
    case PROCESS_ERROR:
        StringCat(bEarse, bEarseError);
        break;
    }
    SetRect(&rect,40,200, SCR_WIDHT,200+20);
    DrawText(upghdc,UNICODE(bEarse),-1,&rect, DT_SINGLELINE|DT_VCENTER);

}
#endif

void ShowFinishInfo()
{
    BYTE bTitle[] = ">>CDR Upgrade<<";
    BYTE bFinishInfo[] = "Finished.....";
    RECT rect;

    FillScrBG();
    SetTextColor(upghdc, GetColorInDef256Palette(TEXT_COLOR));
    SetBkColor(upghdc, GetColorInDef256Palette(BG_COLOR));

    SetRect(&rect,40,80, SCR_WIDHT,80+20);
    DrawText(upghdc,UNICODE(bTitle),-1,&rect, DT_SINGLELINE|DT_VCENTER);
    SetRect(&rect,40,160, SCR_WIDHT,160+20);
    DrawText(upghdc,UNICODE(bFinishInfo),-1,&rect, DT_SINGLELINE|DT_VCENTER);
}

//////////////////////////////////////////////////////////////////////
//
//show progress using frame buffer
//


//#if ((UPGRADE_MODE == UPGRADE_FLASH_MODE))
#include <m3325jpg.h>
//#else	//8M DRAM
//extern const DWORD FramBufferOffsetY[];
//extern const DWORD FramBufferOffsetC[];
//extern unsigned char Y2DramTable[];
//extern unsigned char CbDramTable[];
//extern unsigned char CrDramTable[];
//#endif


void PutYpixel(WORD x,WORD y,unsigned char fram,unsigned char Ynum)
{
	(*(unsigned char *)(FramBufferOffsetY[fram]+Y2DramTable[(x)%32]+(((x)>>5)<<5)+((y)<<11)))=Ynum;
}
void PutCbpixel(WORD x,WORD y,unsigned char fram,unsigned char Cbnum)
{
	(*(unsigned char *)(FramBufferOffsetC[fram]+CbDramTable[(((x)>>1)%16)]+(((x)>>5)<<5)+((y)<<11)))=Cbnum;
}
void PutCrpixel(WORD x,WORD y,unsigned char fram,unsigned char Crnum)
{
	(*(unsigned char *)(FramBufferOffsetC[fram]+CrDramTable[(((x)>>1)%16)]+(((x)>>5)<<5)+((y)<<11)))=Crnum;
}

void DrawBar(int left, int top, int right, int bottom,
	         BYTE y, BYTE cb, BYTE cr,
	         unsigned char fram)
{
	int ix, iy;

	for (iy=top; iy<=bottom; iy++)
	{
		for (ix=left; ix<=right; ix++)
		{
			PutYpixel(ix, iy, fram, y);
			if (iy%2 == 0)
			{
				PutCbpixel(ix, iy, fram, cb);
				PutCrpixel(ix, iy, fram, cr);
			}
		}
	}
}

//show upgrade progress by writing frame buffer
BOOL g_fProgress = FALSE;
void ShowProgress(int nProgress)
{
	int left, right, top, bottom;
	int width = 300;
	int height = 20;
	int i;
	BYTE y, cb, cr;
	int right2;

//	SPRINTF("progress: %d\r\n", nProgress);
	left = 210;
	right = left + width*nProgress/100 - 1;
	right2 = left + width - 1;
	top  = 380;
	bottom = top + height - 1;

	if (!g_fProgress)
	{
		y = Y(255,0,0);
		cb = Cb(255,0,0);
		cr = Cr(255,0,0);
		//line top&bottom
		for (i=left-6; i<= right2+5; i++)
		{
			PutYpixel(i, top-6, UPGRADE_DISPLAY_FRAME, y);
			PutCbpixel(i, top-6, UPGRADE_DISPLAY_FRAME, cb);
			PutCrpixel(i, top-6, UPGRADE_DISPLAY_FRAME, cr);

			PutYpixel(i, bottom+5, UPGRADE_DISPLAY_FRAME, y);
			PutCbpixel(i, bottom+5, UPGRADE_DISPLAY_FRAME, cb);
			PutCrpixel(i, bottom+5, UPGRADE_DISPLAY_FRAME, cr);
		}
		//line left&right
		for (i=top-6; i<= bottom+5; i++)
		{
			PutYpixel(left-6, i, UPGRADE_DISPLAY_FRAME, y);
			PutCbpixel(left-6, i, UPGRADE_DISPLAY_FRAME, cb);
			PutCrpixel(left-6, i, UPGRADE_DISPLAY_FRAME, cr);

			PutYpixel(right2+5, i, UPGRADE_DISPLAY_FRAME, y);
			PutCbpixel(right2+5, i, UPGRADE_DISPLAY_FRAME, cb);
			PutCrpixel(right2+5, i, UPGRADE_DISPLAY_FRAME, cr);
		}
		clear_catch();
		g_fProgress = TRUE;
	}

	if (nProgress == 0)
		return;

	y = Y(255,255,0);
	cb = Cb(255,255,0);
	cr = Cr(255,255,0);
	DrawBar(left, top, right, bottom,
		    y,
		    cb,
		    cr,
		    UPGRADE_DISPLAY_FRAME);
	clear_catch();
	if (nProgress == 100)
		g_fProgress = FALSE;
}

tEndCondition jpgClearFBuf2(unsigned char clridx,
						   BYTE y, BYTE cb, BYTE cr)
{
    int i;
	//improve performance faster
    *(volatile BYTE *)0xDF000081 = y;    //SetM3323BYTE(0x81,0x10);
    *(volatile BYTE *)0xDF000082 = cb;    //SetM3323BYTE(0x82,0x80);
    *(volatile BYTE *)0xDF000083 = cr;    //SetM3323BYTE(0x83,0x80);
    *(volatile BYTE *)0xDF000077 = 0x14;    //SetM3323BYTE(0x77,0x14);

    if (clridx==1)
        *(volatile BYTE *)0xDF000080 = 0x0f;        //SetM3323BYTE(0x80,0x0f); //F1: frame 01
    if (clridx==3)
        *(volatile BYTE *)0xDF000080 = 0x1f;         //SetM3323BYTE(0x80,0x1f); //F2: frame 11
    if (clridx==2)
        *(volatile BYTE *)0xDF000080 = 0x2f;        //SetM3323BYTE(0x80,0x2f); //F1: frame 00
    if (clridx==0)
        *(volatile BYTE *)0xDF000080 = 0x3f;        //SetM3323BYTE(0x80,0x3f); //F2: frame 10

    for(i=0;i<65534;i++)
        if((GetM3323BYTE(0x80) & 0x01) == 0x00)
            break;

    if (i == 65534)
    {
        PRINTF(" Frame_BUF TimeOut, fridx=%u\n",clridx);
        return TimeOut;
    }
    else
    {
        //PRINTF("Clear Frame_BUF, fridx=%u\n",clridx);
        return OK;
    }

}

//mark 40323
/*
BOOL ShowOSD_WriteFlash(BYTE Times)
{
    BYTE input;

    PRINTF("\n ==== Times=%d \n",Times);
    switch(Times)
    {
    case 0:
        input=PROCESS_1;
        break;
    case 1:
        input=PROCESS_2;
        break;
    case 2:
        input=PROCESS_3;
        break;
    case 3:
        input=PROCESS_4;
        break;
    default:
        return ;
    }
    ShowUpgInfo(UPGRADE_PROGRAM,input);
}
*/