graph.c

C语言编写的监控中心终端程序。基于GPRS上传收发数据功能

#include "config.h"
#include "global.h"
#include "regmap.h"
#include "func.h"
#include "util.h"
#include "graph.h"

typedef struct {
    BYTE		Hi;
    UINT16		Lo;
}   COLOR;

static COLOR		MapColor;
static COLOR		MapColorSave;
static COLOR		MapBackColor;
static BYTE		MapFontSizeSave;

static BYTE		MapLineWidth;
static BYTE		MapWindowIndex;

#if 0
static BYTE		MapRollFlag;
static UINT16		MapRollSize;
static UINT16		MapRollAddr;
static BYTE		MapRollStep;
static UINT32		MapRollFontColor;
static UINT32		MapRollBackColor;

static BYTE		MapBottomHoldTimer;
static BYTE		MapBottomHoldFlag;

static BYTE		MapNoteEnterOK;
static BYTE		MapNoteFlag;
static UINT16		MapNoteSize;
static UINT16		MapNoteAddr;
static BYTE		MapNoteStep;

static BYTE		MapBillEnterOK;
#endif

/************************************************************************
 *	Code Start							*
 ************************************************************************/
static inline void __plotXY(UINT16 x, UINT16 y)
{
#if CONFIG==CONFIG_COMBO_SVCD
    x = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
    *(BYTE *)(SDRAM_BASE | (y << 10) | x) = MapColor.Hi;
    if ((x & 0x01) == 0 && (y & 0x01) == 0) {
	y = (y >> 1) + regs0->ref0_chroma;
	*(UINT16 *)(SDRAM_BASE | (y << 10) | (x /* & 0xfffe */)) = MapColor.Lo;
    }
#else
    /* store y */
    *Y_XY(x, y) = MapColor.Hi;
    /* store CbCr (using 420 format) */
    *C_XY(x, y) = MapColor.Lo;
#endif
}

const MAP_WINDOW	MapWindowMax = {
    {	0,		0		},
    {	MAP_SIZE_X - 1,	MAP_SIZE_Y - 1,	},
};

void InitGraphVar()
{
    MapFontSize		= 32;
    MapLineWidth	= 2;
    MapWindowIndex	= 0;

#if 0
    MapRollFlag		= FALSE;
    MapNoteFlag		= FALSE;
    MapNoteEnterOK	= FALSE;
    MapBillEnterOK	= FALSE;
#endif
}

static inline BYTE MapPointInWindow(INT16 x, INT16 y)
{
    if (MapWindowIndex) {
#if 0
	return (x >= MapWindowNavi.lt.x) &&
	       (x <= MapWindowNavi.rd.x) &&
	       (y >= MapWindowNavi.lt.y) &&
	       (y <= MapWindowNavi.rd.y);
#else
	return (x >= ROAD_START_X) && (x <= ROAD_END_X) &&
	       (y >= ROAD_START_Y) && (y <= ROAD_END_Y);
#endif
    }
    else {
#if 0
	return (x >= MapWindowMax.lt.x) &&
	       (x <= MapWindowMax.rd.x) &&
	       (y >= MapWindowMax.lt.y) &&
	       (y <= MapWindowMax.rd.y);
#else
	return (x >= 0) && (x < MAP_SIZE_X) &&
	       (y >= 0) && (y < MAP_SIZE_Y);
#endif
    }
}

void MapSetColor(UINT32 Color)
{
    MapColor.Hi = (Color >> 16) & 0xff;
    MapColor.Lo = (Color & 0xffff);
}

void MapSetBackColor(UINT32 Color)
{
    MapBackColor.Hi = (Color >> 16) & 0xff;
    MapBackColor.Lo = (Color & 0xffff);
}

UINT32 MapGetColor()
{
    return (MapColor.Hi << 16) | MapColor.Lo;
}

UINT32 MapGetBackColor()
{
    return (MapBackColor.Hi << 16) | MapBackColor.Lo;
}

void MapSaveColor()
{
    MapColorSave = MapColor;
}

void MapRestoreColor()
{
    MapColor = MapColorSave;
}

void MapSetFontSize(BYTE Size)
{
    if (Size == 16 || Size == 24 || Size == 32) {
	MapFontSize = Size;
    }
}

BYTE MapGetFontSize()
{
    return MapFontSize;
}

void MapSaveFontSize()
{
    MapFontSizeSave = MapFontSize;
}

void MapRestoreFontSize()
{
    MapFontSize = MapFontSizeSave;
}

void MapClearWindow(INT16 x, INT16 y, INT16 xSize, INT16 ySize)
{
    INT16		i, j;

    if (xSize <= 0 || ySize <= 0) return;

    for (j = y; j < y + ySize; j++) {
	for (i = x; i < x + xSize; i++) {
	    __plotXY(i, j);
	}
    }
}

void MapSaveWindow(UINT16 yStart, UINT16 ySize)
{
    UINT16		x, y, z;
    UINT32		Count;

    Count = 0;
    for (y = yStart; y < yStart + ySize; y++) {
	for (x = 0; x < MAP_SIZE_X; x++) {
	    *(BYTE *)(SDRAM_BASE + GRAPH_Y_START * 1024 + Count) =
	    *(BYTE *)(SDRAM_BASE | (y << 10) | x);
	    Count++;
	}
    }

    Count = 0;
    for (y = yStart; y < yStart + ySize; y += 2) {
	z = (y >> 1) + regs0->ref0_chroma;
	for (x = 0; x < MAP_SIZE_X; x += 2) {
	    *(UINT16 *)(SDRAM_BASE + GRAPH_C_START * 1024 + Count) =
	    *(UINT16 *)(SDRAM_BASE | (z << 10) | x);
	    Count += 2;
	}
    }
}

void MapLoadWindow(UINT16 yStart, UINT16 ySize)
{
    UINT16		x, y, z;
    UINT32		Count;

    Count = 0;
    for (y = yStart; y < yStart + ySize; y++) {
	for (x = 0; x < MAP_SIZE_X; x++) {
	    *(BYTE *)(SDRAM_BASE | (y << 10) | x) =
	    *(BYTE *)(SDRAM_BASE + GRAPH_Y_START * 1024 + Count);
	    Count++;
	}
    }

    Count = 0;
    for (y = yStart; y < yStart + ySize; y += 2) {
	z = (y >> 1) + regs0->ref0_chroma;
	for (x = 0; x < MAP_SIZE_X; x += 2) {
	    *(UINT16 *)(SDRAM_BASE | (z << 10) | x) =
	    *(UINT16 *)(SDRAM_BASE + GRAPH_C_START * 1024 + Count);
	    Count += 2;
	}
    }
}

void MapMoveWindowUp(UINT16 xStart, UINT16 yStart, UINT16 xSize, UINT16 ySize)
{
    UINT16		x, y;
    UINT16		a, b;

    for (y = yStart; y < yStart + ySize - 20; y++) {
	for (x = xStart; x < xStart + xSize; x++) {
	    a = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    b = y + 20;
	    *(BYTE *)(SDRAM_BASE | (y << 10) | a) =
	    *(BYTE *)(SDRAM_BASE | (b << 10) | a);

	    if ((x & 0x01) == 0 && (y & 0x01) == 0) {
		b = y + 20;
		a = (y >> 1) + regs0->ref0_chroma;
		b = (b >> 1) + regs0->ref0_chroma;
		*(UINT16 *)(SDRAM_BASE | (a << 10) | x) =
		*(UINT16 *)(SDRAM_BASE | (b << 10) | x);
	    }
	}
    }
}

void MapMoveWindowLeft(UINT16 xStart, UINT16 yStart, UINT16 xSize, UINT16 ySize, BYTE Len)
{
    UINT16		x, y, z;
    UINT16		a, b;

    for (x = xStart; x < xStart + xSize - Len; x++) {
	for (y = yStart; y < yStart + ySize; y++) {
	    b = x + Len;
	    a = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    b = (b & 0xffe7) | ((b & 0x10) >> 1) | ((b & 0x08) << 1);
	    *(BYTE *)(SDRAM_BASE | (y << 10) | a) =
	    *(BYTE *)(SDRAM_BASE | (y << 10) | b);

	    if ((x & 0x01) == 0 && (y & 0x01) == 0) {
		z = (y >> 1) + regs0->ref0_chroma;
		*(UINT16 *)(SDRAM_BASE | (z << 10) | a) =
		*(UINT16 *)(SDRAM_BASE | (z << 10) | b);
	    }
	}
    }
}

void MapSaveFrame(UINT16 xStart, UINT16 yStart, UINT16 xSize, UINT16 ySize)
{
    UINT16		x, y;
    UINT16		i, j;
    UINT32		Count;

    if (xStart & 0x01)	xStart++;

    Count = 0;
    for (y = yStart; y < yStart + ySize; y++) {
	for (x = xStart; x < xStart + xSize; x++) {
	    i = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    *(BYTE *)(SDRAM_BASE + FRAME_Y_START * 1024 + Count) =
	    *(BYTE *)(SDRAM_BASE | (y << 10) | i);
	    Count++;
	}
    }

    Count = 0;
    for (y = yStart; y < yStart + ySize; y += 2) {
	i = (y >> 1) + regs0->ref0_chroma;
	for (x = xStart; x < xStart + xSize; x += 2) {
	    j = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    *(UINT16 *)(SDRAM_BASE + FRAME_C_START * 1024 + Count) =
	    *(UINT16 *)(SDRAM_BASE | (i << 10) | j);
	    Count += 2;
	}
    }
}

void MapLoadFrame(UINT16 xStart, UINT16 yStart, UINT16 xSize, UINT16 ySize)
{
    UINT16		x, y;
    UINT16		i, j;
    UINT32		Count;

    if (xStart & 0x01)	xStart++;

    Count = 0;
    for (y = yStart; y < yStart + ySize; y++) {
	for (x = xStart; x < xStart + xSize; x++) {
	    i = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    *(BYTE *)(SDRAM_BASE | (y << 10) | i) =
	    *(BYTE *)(SDRAM_BASE + FRAME_Y_START * 1024 + Count);
	    Count++;
	}
    }

    Count = 0;
    for (y = yStart; y < yStart + ySize; y += 2) {
	i = (y >> 1) + regs0->ref0_chroma;
	for (x = xStart; x < xStart + xSize; x += 2) {
	    j = (x & 0xffe7) | ((x & 0x10) >> 1) | ((x & 0x08) << 1);
	    *(UINT16 *)(SDRAM_BASE | (i << 10) | j) =
	    *(UINT16 *)(SDRAM_BASE + FRAME_C_START * 1024 + Count);
	    Count += 2;
	}
    }
}

void MapSetLineWidth(BYTE Width)
{
    if (Width > 0 && Width <= 16)
	MapLineWidth = Width;
}

BYTE MapGetLineWidth()
{
    return MapLineWidth;
}

void MapDrawLine(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    INT16		W, H, Ha, dY, f;

    /*
     ** always draws from small X to large X
     */
    if (SX > EX) {
	W = EX, EX = SX, SX = W;
	W = EY, EY = SY, SY = W;
    }

    /*
     ** we might want to clip the line here
     */
    W = (EX - SX);
    H = (EY - SY);
    Ha = (H < 0) ? -H : H;
    dY = (H < 0) ? -1 : 1;

    if (Ha > W)	{
	/* Y-majored */
	f = 0;
	while (1) {
	    if (MapPointInWindow(SX, SY))
		__plotXY(SX, SY);
	    if (SY == EY)
		break;
	    if ((f += W) >= Ha)	{
		f -= Ha;
		SX++;
	    }
	    SY += dY;
	}
    }
    else {
	/* X-majored */
	f = 0;
	while (1) {
	    if (MapPointInWindow(SX, SY))
		__plotXY(SX, SY);
	    if (SX == EX)
		break;
	    if ((f += Ha) >= W)	{
		f -= W;
		SY += dY;
	    }
	    SX++;
	}
    }
}

void MapDrawLineWidth(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    INT16		W, H, Ha, dY, f, x, y;
    UINT16		i, j;
    BYTE		HalfWidth = MapLineWidth / 2;

    for (i = 0; i < MapLineWidth; i++) {
	for (j = 0; j < MapLineWidth; j++) {
	    x =	SX + i - HalfWidth;
	    y = SY + j - HalfWidth;
	    if (MapPointInWindow(x, y))	__plotXY(x, y);

	    x =	EX + i - HalfWidth;
	    y = EY + j - HalfWidth;
	    if (MapPointInWindow(x, y))	__plotXY(x, y);
	}
    }

    /*
     ** always draws from small X to large X
     */
    if (SX > EX) {
	W = EX, EX = SX, SX = W;
	W = EY, EY = SY, SY = W;
    }

    /*
     ** we might want to clip the line here
     */
    W = (EX - SX);
    H = (EY - SY);
    Ha = (H < 0) ? -H : H;
    dY = (H < 0) ? -1 : 1;

    if (Ha > W)	{
	/* Y-majored */
	f = 0;
	while (1) {
	    x = SX - HalfWidth;
	    y = SY - HalfWidth;
	    for (i = 0; i < MapLineWidth; i++) {
		if (MapPointInWindow(x + i, y))	__plotXY(x + i, y);
		if (MapPointInWindow(x, y + i))	__plotXY(x, y + i);
	    }

	    x = SX + HalfWidth;
	    y = SY + HalfWidth;
	    for (i = 0; i < MapLineWidth; i++) {
		if (MapPointInWindow(x - i, y))	__plotXY(x - i, y);
		if (MapPointInWindow(x, y - i))	__plotXY(x, y - i);
	    }

	    if (SY == EY)
		break;
	    if ((f += W) >= Ha)	{
		f -= Ha;
		SX++;
	    }
	    SY += dY;
	}
    }
    else {
	/* X-majored */
	f = 0;
	while (1) {
	    x = SX - HalfWidth;
	    y = SY - HalfWidth;
	    for (i = 0; i < MapLineWidth; i++) {
		if (MapPointInWindow(x + i, y))	__plotXY(x + i, y);
		if (MapPointInWindow(x, y + i))	__plotXY(x, y + i);
	    }

	    x = SX + HalfWidth;
	    y = SY + HalfWidth;
	    for (i = 0; i < MapLineWidth; i++) {
		if (MapPointInWindow(x - i, y))	__plotXY(x - i, y);
		if (MapPointInWindow(x, y - i))	__plotXY(x, y - i);
	    }

	    if (SX == EX)
		break;
	    if ((f += Ha) >= W)	{
		f -= W;
		SY += dY;
	    }
	    SX++;
	}
    }
}

void MapDrawLineNavi(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    MapWindowIndex = 1;
    MapDrawLine(SX, SY, EX, EY);
    MapWindowIndex = 0;
}

void MapDrawLineWidthNavi(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    MapWindowIndex = 1;
    MapDrawLineWidth(SX, SY, EX, EY);
    MapWindowIndex = 0;
}

void MapDrawFrame(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    BYTE		i;
    UINT32		Color;

    Color = MapGetColor();
    MapSetColor(MapGetBackColor());
    for (i = 0; i < MapLineWidth; i++) {
	MapDrawRectangle(SX + i, SY + i, EX - i, EY - i);
    }

    MapSetColor(Color);
    MapFillRectangle(SX + MapLineWidth, SY + MapLineWidth,
		     EX - MapLineWidth, EY - MapLineWidth);