3471 lines
118 KiB
C
3471 lines
118 KiB
C
/**************************************************************************//**
|
|
* @file 2d.c
|
|
* @brief N9H30 GE2D driver source file
|
|
*
|
|
* @note
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
* Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
|
|
*****************************************************************************/
|
|
#include "rtthread.h"
|
|
|
|
#include "NuMicro.h"
|
|
#include <drv_sys.h>
|
|
|
|
//#define DEBUG
|
|
//#define DEF_COND_WAIT 1
|
|
|
|
static unsigned int GFX_BPP;
|
|
static unsigned int GFX_WIDTH;
|
|
static unsigned int GFX_HEIGHT;
|
|
|
|
#if defined ( __GNUC__ ) && !(__CC_ARM)
|
|
__attribute__((aligned(32))) static void *GFX_START_ADDR = NULL;
|
|
__attribute__((aligned(32))) static void *GFX_PAT_ADDR = NULL;
|
|
#else
|
|
static __align(32) void *GFX_START_ADDR = NULL;
|
|
static __align(32) void *GFX_PAT_ADDR = NULL;
|
|
#endif
|
|
|
|
#define PN 1 // Quadrant 1
|
|
#define NN 2 // Quadrant 2
|
|
#define NP 3 // Quadrant 3
|
|
#define PP 4 // Quadrant 4
|
|
|
|
#define ABS(x) (((x)>0)?(x):-(x))
|
|
#define MAX(a,b) (((a)>(b))?(a):(b))
|
|
|
|
/* octant code of line drawing */
|
|
|
|
#define XpYpXl (0<<1) // XY octant position is 1~3 in Control register
|
|
#define XpYpYl (1<<1)
|
|
#define XpYmXl (2<<1)
|
|
#define XpYmYl (3<<1)
|
|
#define XmYpXl (4<<1)
|
|
#define XmYpYl (5<<1)
|
|
#define XmYmXl (6<<1)
|
|
#define XmYmYl (7<<1)
|
|
|
|
static MONOPATTERN MonoPatternData[6] =
|
|
{
|
|
{0x00000000, 0xff000000}, // HS_HORIZONTAL
|
|
{0x08080808, 0x08080808}, // HS_VERTICAL
|
|
{0x80402010, 0x08040201}, // HS_FDIAGONAL
|
|
{0x01020408, 0x10204080}, // HS_BDIAGONAL
|
|
{0x08080808, 0xff080808}, // HS_CROSS
|
|
{0x81422418, 0x18244281} // HS_DIAGCROSS
|
|
};
|
|
|
|
static char _DrawMode = MODE_OPAQUE;
|
|
static UINT32 _ColorKey = COLOR_KEY;
|
|
static UINT32 _ColorKeyMask = 0xFFFFFF;
|
|
|
|
static BOOL _EnableAlpha = FALSE;
|
|
static int _AlphaKs, _AlphaKd;
|
|
static BOOL _ClipEnable = FALSE;
|
|
static BOOL _OutsideClip = FALSE;
|
|
static UINT32 _ClipTL, _ClipBR;
|
|
static int _PatternType;
|
|
|
|
static unsigned char FontData8[256][8] =
|
|
{
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //0
|
|
{0x7E, 0x81, 0xA5, 0x81, 0xBD, 0x99, 0x81, 0x7E}, //1
|
|
{0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E}, //2
|
|
{0x6C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00}, //3
|
|
{0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00}, //4
|
|
{0x38, 0x7C, 0x38, 0xFE, 0xFE, 0x92, 0x10, 0x7C}, //5
|
|
{0x00, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x7C}, //6
|
|
{0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00}, //7
|
|
{0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF}, //8
|
|
{0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00}, //9
|
|
{0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF}, //10
|
|
{0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78}, //11
|
|
{0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18}, //12
|
|
{0x3F, 0x33, 0x3F, 0x30, 0x30, 0x70, 0xF0, 0xE0}, //13
|
|
{0x7F, 0x63, 0x7F, 0x63, 0x63, 0x67, 0xE6, 0xC0}, //14
|
|
{0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99}, //15
|
|
{0x80, 0xE0, 0xF8, 0xFE, 0xF8, 0xE0, 0x80, 0x00}, //16
|
|
{0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02, 0x00}, //17
|
|
{0x18, 0x3C, 0x7E, 0x18, 0x18, 0x7E, 0x3C, 0x18}, //18
|
|
{0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00}, //19
|
|
{0x7F, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x00}, //20
|
|
{0x3E, 0x63, 0x38, 0x6C, 0x6C, 0x38, 0x86, 0xFC}, //21
|
|
{0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00}, //22
|
|
{0x18, 0x3C, 0x7E, 0x18, 0x7E, 0x3C, 0x18, 0xFF}, //23
|
|
{0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00}, //24
|
|
{0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00}, //25
|
|
{0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00}, //26
|
|
{0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00}, //27
|
|
{0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00}, //28
|
|
{0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00}, //29
|
|
{0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00}, //30
|
|
{0x00, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x00, 0x00}, //31
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //32
|
|
{0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00}, //33
|
|
{0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00}, //34
|
|
{0x6C, 0x6C, 0xFE, 0x6C, 0xFE, 0x6C, 0x6C, 0x00}, //35
|
|
{0x18, 0x7E, 0xC0, 0x7C, 0x06, 0xFC, 0x18, 0x00}, //36
|
|
{0x00, 0xC6, 0xCC, 0x18, 0x30, 0x66, 0xC6, 0x00}, //37
|
|
{0x38, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0x76, 0x00}, //38
|
|
{0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00}, //39
|
|
{0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00}, //40
|
|
{0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00}, //41
|
|
{0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00}, //42
|
|
{0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00}, //43
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30}, //44
|
|
{0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}, //45
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00}, //46
|
|
{0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00}, //47
|
|
{0x7C, 0xCE, 0xDE, 0xF6, 0xE6, 0xC6, 0x7C, 0x00}, //48
|
|
{0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xFC, 0x00}, //49
|
|
{0x78, 0xCC, 0x0C, 0x38, 0x60, 0xCC, 0xFC, 0x00}, //50
|
|
{0x78, 0xCC, 0x0C, 0x38, 0x0C, 0xCC, 0x78, 0x00}, //51
|
|
{0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x1E, 0x00}, //52
|
|
{0xFC, 0xC0, 0xF8, 0x0C, 0x0C, 0xCC, 0x78, 0x00}, //53
|
|
{0x38, 0x60, 0xC0, 0xF8, 0xCC, 0xCC, 0x78, 0x00}, //54
|
|
{0xFC, 0xCC, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00}, //55
|
|
{0x78, 0xCC, 0xCC, 0x78, 0xCC, 0xCC, 0x78, 0x00}, //56
|
|
{0x78, 0xCC, 0xCC, 0x7C, 0x0C, 0x18, 0x70, 0x00}, //57
|
|
{0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x00}, //58
|
|
{0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30}, //59
|
|
{0x18, 0x30, 0x60, 0xC0, 0x60, 0x30, 0x18, 0x00}, //60
|
|
{0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00}, //61
|
|
{0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60, 0x00}, //62
|
|
{0x3C, 0x66, 0x0C, 0x18, 0x18, 0x00, 0x18, 0x00}, //63
|
|
{0x7C, 0xC6, 0xDE, 0xDE, 0xDC, 0xC0, 0x7C, 0x00}, //64
|
|
{0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0x00}, //65
|
|
{0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00}, //66
|
|
{0x3C, 0x66, 0xC0, 0xC0, 0xC0, 0x66, 0x3C, 0x00}, //67
|
|
{0xF8, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00}, //68
|
|
{0xFE, 0x62, 0x68, 0x78, 0x68, 0x62, 0xFE, 0x00}, //69
|
|
{0xFE, 0x62, 0x68, 0x78, 0x68, 0x60, 0xF0, 0x00}, //70
|
|
{0x3C, 0x66, 0xC0, 0xC0, 0xCE, 0x66, 0x3A, 0x00}, //71
|
|
{0xCC, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0xCC, 0x00}, //72
|
|
{0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00}, //73
|
|
{0x1E, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0x00}, //74
|
|
{0xE6, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0xE6, 0x00}, //75
|
|
{0xF0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00}, //76
|
|
{0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00}, //77
|
|
{0xC6, 0xE6, 0xF6, 0xDE, 0xCE, 0xC6, 0xC6, 0x00}, //78
|
|
{0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00}, //79
|
|
{0xFC, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00}, //80
|
|
{0x7C, 0xC6, 0xC6, 0xC6, 0xD6, 0x7C, 0x0E, 0x00}, //81
|
|
{0xFC, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0xE6, 0x00}, //82
|
|
{0x7C, 0xC6, 0xE0, 0x78, 0x0E, 0xC6, 0x7C, 0x00}, //83
|
|
{0xFC, 0xB4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00}, //84
|
|
{0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFC, 0x00}, //85
|
|
{0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00}, //86
|
|
{0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xFE, 0x6C, 0x00}, //87
|
|
{0xC6, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0xC6, 0x00}, //88
|
|
{0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x30, 0x78, 0x00}, //89
|
|
{0xFE, 0xC6, 0x8C, 0x18, 0x32, 0x66, 0xFE, 0x00}, //90
|
|
{0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00}, //91
|
|
{0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x02, 0x00}, //92
|
|
{0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00}, //93
|
|
{0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00}, //94
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, //95
|
|
{0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, //96
|
|
{0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00}, //97
|
|
{0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0xDC, 0x00}, //98
|
|
{0x00, 0x00, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x00}, //99
|
|
{0x1C, 0x0C, 0x0C, 0x7C, 0xCC, 0xCC, 0x76, 0x00}, //100
|
|
{0x00, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00}, //101
|
|
{0x38, 0x6C, 0x64, 0xF0, 0x60, 0x60, 0xF0, 0x00}, //102
|
|
{0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8}, //103
|
|
{0xE0, 0x60, 0x6C, 0x76, 0x66, 0x66, 0xE6, 0x00}, //104
|
|
{0x30, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00}, //105
|
|
{0x0C, 0x00, 0x1C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78}, //106
|
|
{0xE0, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0xE6, 0x00}, //107
|
|
{0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00}, //108
|
|
{0x00, 0x00, 0xCC, 0xFE, 0xFE, 0xD6, 0xD6, 0x00}, //109
|
|
{0x00, 0x00, 0xB8, 0xCC, 0xCC, 0xCC, 0xCC, 0x00}, //110
|
|
{0x00, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00}, //111
|
|
{0x00, 0x00, 0xDC, 0x66, 0x66, 0x7C, 0x60, 0xF0}, //112
|
|
{0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0x1E}, //113
|
|
{0x00, 0x00, 0xDC, 0x76, 0x62, 0x60, 0xF0, 0x00}, //114
|
|
{0x00, 0x00, 0x7C, 0xC0, 0x70, 0x1C, 0xF8, 0x00}, //115
|
|
{0x10, 0x30, 0xFC, 0x30, 0x30, 0x34, 0x18, 0x00}, //116
|
|
{0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00}, //117
|
|
{0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00}, //118
|
|
{0x00, 0x00, 0xC6, 0xC6, 0xD6, 0xFE, 0x6C, 0x00}, //119
|
|
{0x00, 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0x00}, //120
|
|
{0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8}, //121
|
|
{0x00, 0x00, 0xFC, 0x98, 0x30, 0x64, 0xFC, 0x00}, //122
|
|
{0x1C, 0x30, 0x30, 0xE0, 0x30, 0x30, 0x1C, 0x00}, //123
|
|
{0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, //124
|
|
{0xE0, 0x30, 0x30, 0x1C, 0x30, 0x30, 0xE0, 0x00}, //125
|
|
{0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //126
|
|
{0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00}, //127
|
|
{0x7C, 0xC6, 0xC0, 0xC6, 0x7C, 0x0C, 0x06, 0x7C}, //128
|
|
{0x00, 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x00}, //129
|
|
{0x1C, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00}, //130
|
|
{0x7E, 0x81, 0x3C, 0x06, 0x3E, 0x66, 0x3B, 0x00}, //131
|
|
{0xCC, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00}, //132
|
|
{0xE0, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00}, //133
|
|
{0x30, 0x30, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00}, //134
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC0, 0x78, 0x0C, 0x38}, //135
|
|
{0x7E, 0x81, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00}, //136
|
|
{0xCC, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00}, //137
|
|
{0xE0, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00}, //138
|
|
{0xCC, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00}, //139
|
|
{0x7C, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00}, //140
|
|
{0xE0, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00}, //141
|
|
{0xC6, 0x10, 0x7C, 0xC6, 0xFE, 0xC6, 0xC6, 0x00}, //142
|
|
{0x30, 0x30, 0x00, 0x78, 0xCC, 0xFC, 0xCC, 0x00}, //143
|
|
{0x1C, 0x00, 0xFC, 0x60, 0x78, 0x60, 0xFC, 0x00}, //144
|
|
{0x00, 0x00, 0x7F, 0x0C, 0x7F, 0xCC, 0x7F, 0x00}, //145
|
|
{0x3E, 0x6C, 0xCC, 0xFE, 0xCC, 0xCC, 0xCE, 0x00}, //146
|
|
{0x78, 0x84, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00}, //147
|
|
{0x00, 0xCC, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00}, //148
|
|
{0x00, 0xE0, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00}, //149
|
|
{0x78, 0x84, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x00}, //150
|
|
{0x00, 0xE0, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x00}, //151
|
|
{0x00, 0xCC, 0x00, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8}, //152
|
|
{0xC3, 0x18, 0x3C, 0x66, 0x66, 0x3C, 0x18, 0x00}, //153
|
|
{0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x78, 0x00}, //154
|
|
{0x18, 0x18, 0x7E, 0xC0, 0xC0, 0x7E, 0x18, 0x18}, //155
|
|
{0x38, 0x6C, 0x64, 0xF0, 0x60, 0xE6, 0xFC, 0x00}, //156
|
|
{0xCC, 0xCC, 0x78, 0x30, 0xFC, 0x30, 0xFC, 0x30}, //157
|
|
{0xF8, 0xCC, 0xCC, 0xFA, 0xC6, 0xCF, 0xC6, 0xC3}, //158
|
|
{0x0E, 0x1B, 0x18, 0x3C, 0x18, 0x18, 0xD8, 0x70}, //159
|
|
{0x1C, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00}, //160
|
|
{0x38, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00}, //161
|
|
{0x00, 0x1C, 0x00, 0x78, 0xCC, 0xCC, 0x78, 0x00}, //162
|
|
{0x00, 0x1C, 0x00, 0xCC, 0xCC, 0xCC, 0x76, 0x00}, //163
|
|
{0x00, 0xF8, 0x00, 0xB8, 0xCC, 0xCC, 0xCC, 0x00}, //164
|
|
{0xFC, 0x00, 0xCC, 0xEC, 0xFC, 0xDC, 0xCC, 0x00}, //165
|
|
{0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00}, //166
|
|
{0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00}, //167
|
|
{0x18, 0x00, 0x18, 0x18, 0x30, 0x66, 0x3C, 0x00}, //168
|
|
{0x00, 0x00, 0x00, 0xFC, 0xC0, 0xC0, 0x00, 0x00}, //169
|
|
{0x00, 0x00, 0x00, 0xFC, 0x0C, 0x0C, 0x00, 0x00}, //170
|
|
{0xC6, 0xCC, 0xD8, 0x36, 0x6B, 0xC2, 0x84, 0x0F}, //171
|
|
{0xC3, 0xC6, 0xCC, 0xDB, 0x37, 0x6D, 0xCF, 0x03}, //172
|
|
{0x18, 0x00, 0x18, 0x18, 0x3C, 0x3C, 0x18, 0x00}, //173
|
|
{0x00, 0x33, 0x66, 0xCC, 0x66, 0x33, 0x00, 0x00}, //174
|
|
{0x00, 0xCC, 0x66, 0x33, 0x66, 0xCC, 0x00, 0x00}, //175
|
|
{0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88}, //176
|
|
{0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA}, //177
|
|
{0xDB, 0xF6, 0xDB, 0x6F, 0xDB, 0x7E, 0xD7, 0xED}, //178
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //179
|
|
{0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18}, //180
|
|
{0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18}, //181
|
|
{0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36}, //182
|
|
{0x00, 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36}, //183
|
|
{0x00, 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18}, //184
|
|
{0x36, 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36}, //185
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //186
|
|
{0x00, 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36}, //187
|
|
{0x36, 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00}, //188
|
|
{0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00}, //189
|
|
{0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00}, //190
|
|
{0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18}, //191
|
|
{0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00}, //192
|
|
{0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00}, //193
|
|
{0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18}, //194
|
|
{0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18}, //195
|
|
{0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00}, //196
|
|
{0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18}, //197
|
|
{0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18}, //198
|
|
{0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36}, //199
|
|
{0x36, 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00}, //200
|
|
{0x00, 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36}, //201
|
|
{0x36, 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00}, //202
|
|
{0x00, 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36}, //203
|
|
{0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36}, //204
|
|
{0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00}, //205
|
|
{0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36}, //206
|
|
{0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00}, //207
|
|
{0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00}, //208
|
|
{0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18}, //209
|
|
{0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36}, //210
|
|
{0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00}, //211
|
|
{0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00}, //212
|
|
{0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18}, //213
|
|
{0x00, 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36}, //214
|
|
{0x36, 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36}, //215
|
|
{0x18, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18}, //216
|
|
{0x18, 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00}, //217
|
|
{0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18}, //218
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, //219
|
|
{0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF}, //220
|
|
{0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0}, //221
|
|
{0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F}, //222
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00}, //223
|
|
{0x00, 0x00, 0x76, 0xDC, 0xC8, 0xDC, 0x76, 0x00}, //224
|
|
{0x00, 0x78, 0xCC, 0xF8, 0xCC, 0xF8, 0xC0, 0xC0}, //225
|
|
{0x00, 0xFC, 0xCC, 0xC0, 0xC0, 0xC0, 0xC0, 0x00}, //226
|
|
{0x00, 0x00, 0xFE, 0x6C, 0x6C, 0x6C, 0x6C, 0x00}, //227
|
|
{0xFC, 0xCC, 0x60, 0x30, 0x60, 0xCC, 0xFC, 0x00}, //228
|
|
{0x00, 0x00, 0x7E, 0xD8, 0xD8, 0xD8, 0x70, 0x00}, //229
|
|
{0x00, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x60, 0xC0}, //230
|
|
{0x00, 0x76, 0xDC, 0x18, 0x18, 0x18, 0x18, 0x00}, //231
|
|
{0xFC, 0x30, 0x78, 0xCC, 0xCC, 0x78, 0x30, 0xFC}, //232
|
|
{0x38, 0x6C, 0xC6, 0xFE, 0xC6, 0x6C, 0x38, 0x00}, //233
|
|
{0x38, 0x6C, 0xC6, 0xC6, 0x6C, 0x6C, 0xEE, 0x00}, //234
|
|
{0x1C, 0x30, 0x18, 0x7C, 0xCC, 0xCC, 0x78, 0x00}, //235
|
|
{0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x00, 0x00}, //236
|
|
{0x06, 0x0C, 0x7E, 0xDB, 0xDB, 0x7E, 0x60, 0xC0}, //237
|
|
{0x38, 0x60, 0xC0, 0xF8, 0xC0, 0x60, 0x38, 0x00}, //238
|
|
{0x78, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x00}, //239
|
|
{0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00}, //240
|
|
{0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x7E, 0x00}, //241
|
|
{0x60, 0x30, 0x18, 0x30, 0x60, 0x00, 0xFC, 0x00}, //242
|
|
{0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0xFC, 0x00}, //243
|
|
{0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18}, //244
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70}, //245
|
|
{0x18, 0x18, 0x00, 0x7E, 0x00, 0x18, 0x18, 0x00}, //246
|
|
{0x00, 0x76, 0xDC, 0x00, 0x76, 0xDC, 0x00, 0x00}, //247
|
|
{0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00}, //248
|
|
{0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00}, //249
|
|
{0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00}, //250
|
|
{0x0F, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x1C}, //251
|
|
{0x58, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00}, //252
|
|
{0x70, 0x98, 0x30, 0x60, 0xF8, 0x00, 0x00, 0x00}, //253
|
|
{0x00, 0x00, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00}, //254
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} //255
|
|
};
|
|
|
|
static unsigned char FontData16[256][16] =
|
|
{
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //0
|
|
{0x00, 0x00, 0x7E, 0x81, 0xA5, 0x81, 0x81, 0xBD, 0x99, 0x81, 0x81, 0x7E, 0x00, 0x00, 0x00, 0x00}, //1
|
|
{0x00, 0x00, 0x7E, 0xFF, 0xDB, 0xFF, 0xFF, 0xC3, 0xE7, 0xFF, 0xFF, 0x7E, 0x00, 0x00, 0x00, 0x00}, //2
|
|
{0x00, 0x00, 0x00, 0x00, 0x6C, 0xFE, 0xFE, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00}, //3
|
|
{0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}, //4
|
|
{0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0xE7, 0xE7, 0xE7, 0x99, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //5
|
|
{0x00, 0x00, 0x00, 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x7E, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //6
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //7
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, //8
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00}, //9
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, //10
|
|
{0x00, 0x00, 0x1E, 0x0E, 0x1A, 0x32, 0x78, 0xCC, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0x00, 0x00, 0x00}, //11
|
|
{0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //12
|
|
{0x00, 0x00, 0x3F, 0x33, 0x3F, 0x30, 0x30, 0x30, 0x30, 0x70, 0xF0, 0xE0, 0x00, 0x00, 0x00, 0x00}, //13
|
|
{0x00, 0x00, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x63, 0x63, 0x67, 0xE7, 0xE6, 0xC0, 0x00, 0x00, 0x00}, //14
|
|
{0x00, 0x00, 0x00, 0x18, 0x18, 0xDB, 0x3C, 0xE7, 0x3C, 0xDB, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //15
|
|
{0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFE, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00}, //16
|
|
{0x00, 0x02, 0x06, 0x0E, 0x1E, 0x3E, 0xFE, 0x3E, 0x1E, 0x0E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00}, //17
|
|
{0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00}, //18
|
|
{0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00}, //19
|
|
{0x00, 0x00, 0x7F, 0xDB, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00}, //20
|
|
{0x00, 0x7C, 0xC6, 0x60, 0x38, 0x6C, 0xC6, 0xC6, 0x6C, 0x38, 0x0C, 0xC6, 0x7C, 0x00, 0x00, 0x00}, //21
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00}, //22
|
|
{0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00}, //23
|
|
{0x00, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //24
|
|
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00}, //25
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //26
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //27
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //28
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6C, 0xFE, 0x6C, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //29
|
|
{0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7C, 0x7C, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00}, //30
|
|
{0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x7C, 0x7C, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}, //31
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //32
|
|
{0x00, 0x00, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //33
|
|
{0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //34
|
|
{0x00, 0x00, 0x00, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x6C, 0xFE, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00}, //35
|
|
{0x18, 0x18, 0x7C, 0xC6, 0xC2, 0xC0, 0x7C, 0x06, 0x86, 0xC6, 0x7C, 0x18, 0x18, 0x00, 0x00, 0x00}, //36
|
|
{0x00, 0x00, 0x00, 0x00, 0xC2, 0xC6, 0x0C, 0x18, 0x30, 0x60, 0xC6, 0x86, 0x00, 0x00, 0x00, 0x00}, //37
|
|
{0x00, 0x00, 0x38, 0x6C, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //38
|
|
{0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //39
|
|
{0x00, 0x00, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0C, 0x00, 0x00, 0x00, 0x00}, //40
|
|
{0x00, 0x00, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00}, //41
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //42
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //43
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00}, //44
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //45
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //46
|
|
{0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00}, //47
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xCE, 0xD6, 0xD6, 0xE6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //48
|
|
{0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00}, //49
|
|
{0x00, 0x00, 0x7C, 0xC6, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00}, //50
|
|
{0x00, 0x00, 0x7C, 0xC6, 0x06, 0x06, 0x3C, 0x06, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //51
|
|
{0x00, 0x00, 0x0C, 0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x0C, 0x0C, 0x1E, 0x00, 0x00, 0x00, 0x00}, //52
|
|
{0x00, 0x00, 0xFE, 0xC0, 0xC0, 0xC0, 0xFC, 0x0E, 0x06, 0x06, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //53
|
|
{0x00, 0x00, 0x38, 0x60, 0xC0, 0xC0, 0xFC, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //54
|
|
{0x00, 0x00, 0xFE, 0xC6, 0x06, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00}, //55
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //56
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x06, 0x06, 0x0C, 0x78, 0x00, 0x00, 0x00, 0x00}, //57
|
|
{0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, //58
|
|
{0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00}, //59
|
|
{0x00, 0x00, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00}, //60
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //61
|
|
{0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00}, //62
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x0C, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //63
|
|
{0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xDE, 0xDE, 0xDE, 0xDC, 0xC0, 0x7C, 0x00, 0x00, 0x00, 0x00}, //64
|
|
{0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //65
|
|
{0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x66, 0x66, 0xFC, 0x00, 0x00, 0x00, 0x00}, //66
|
|
{0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xC0, 0xC0, 0xC2, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00}, //67
|
|
{0x00, 0x00, 0xF8, 0x6C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00, 0x00, 0x00, 0x00}, //68
|
|
{0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00, 0x00}, //69
|
|
{0x00, 0x00, 0xFE, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00}, //70
|
|
{0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xDE, 0xC6, 0xC6, 0x66, 0x3A, 0x00, 0x00, 0x00, 0x00}, //71
|
|
{0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //72
|
|
{0x00, 0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //73
|
|
{0x00, 0x00, 0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0x00, 0x00, 0x00}, //74
|
|
{0x00, 0x00, 0xE6, 0x66, 0x6C, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00}, //75
|
|
{0x00, 0x00, 0xF0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00, 0x00, 0x00, 0x00}, //76
|
|
{0x00, 0x00, 0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //77
|
|
{0x00, 0x00, 0xC6, 0xE6, 0xF6, 0xFE, 0xDE, 0xCE, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //78
|
|
{0x00, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00}, //79
|
|
{0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00}, //80
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xDE, 0x7C, 0x0C, 0x0E, 0x00, 0x00}, //81
|
|
{0x00, 0x00, 0xFC, 0x66, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00}, //82
|
|
{0x00, 0x00, 0x7C, 0xC6, 0xC6, 0x60, 0x38, 0x0C, 0x06, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //83
|
|
{0x00, 0x00, 0x7E, 0x7E, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //84
|
|
{0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //85
|
|
{0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00}, //86
|
|
{0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xD6, 0xD6, 0xFE, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00}, //87
|
|
{0x00, 0x00, 0xC6, 0xC6, 0x6C, 0x6C, 0x38, 0x38, 0x6C, 0x6C, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //88
|
|
{0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //89
|
|
{0x00, 0x00, 0xFE, 0xC6, 0x86, 0x0C, 0x18, 0x30, 0x60, 0xC2, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00}, //90
|
|
{0x00, 0x00, 0x3C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, 0x00, 0x00, 0x00, 0x00}, //91
|
|
{0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00}, //92
|
|
{0x00, 0x00, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x3C, 0x00, 0x00, 0x00, 0x00}, //93
|
|
{0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //94
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00}, //95
|
|
{0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //96
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //97
|
|
{0x00, 0x00, 0xE0, 0x60, 0x60, 0x78, 0x6C, 0x66, 0x66, 0x66, 0x66, 0xDC, 0x00, 0x00, 0x00, 0x00}, //98
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC0, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //99
|
|
{0x00, 0x00, 0x1C, 0x0C, 0x0C, 0x3C, 0x6C, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //100
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //101
|
|
{0x00, 0x00, 0x38, 0x6C, 0x64, 0x60, 0xF0, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00}, //102
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xCC, 0x78, 0x00}, //103
|
|
{0x00, 0x00, 0xE0, 0x60, 0x60, 0x6C, 0x76, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00}, //104
|
|
{0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //105
|
|
{0x00, 0x00, 0x06, 0x06, 0x00, 0x0E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3C, 0x00}, //106
|
|
{0x00, 0x00, 0xE0, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x78, 0x6C, 0x66, 0xE6, 0x00, 0x00, 0x00, 0x00}, //107
|
|
{0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //108
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xEC, 0xFE, 0xD6, 0xD6, 0xD6, 0xD6, 0xD6, 0x00, 0x00, 0x00, 0x00}, //109
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00}, //110
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //111
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00}, //112
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0x0C, 0x1E, 0x00}, //113
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xDC, 0x76, 0x62, 0x60, 0x60, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x00}, //114
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xC6, 0x60, 0x38, 0x0C, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //115
|
|
{0x00, 0x00, 0x10, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1C, 0x00, 0x00, 0x00, 0x00}, //116
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //117
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00}, //118
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xD6, 0xD6, 0xFE, 0x6C, 0x00, 0x00, 0x00, 0x00}, //119
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0x6C, 0x38, 0x38, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00}, //120
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x0C, 0xF8, 0x00}, //121
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xCC, 0x18, 0x30, 0x60, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00}, //122
|
|
{0x00, 0x00, 0x0E, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0E, 0x00, 0x00, 0x00, 0x00}, //123
|
|
{0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //124
|
|
{0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0E, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00}, //125
|
|
{0x00, 0x00, 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //126
|
|
{0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00}, //127
|
|
{0x00, 0x00, 0x3C, 0x66, 0xC2, 0xC0, 0xC0, 0xC0, 0xC2, 0x66, 0x3C, 0x0C, 0x06, 0x7C, 0x00, 0x00}, //128
|
|
{0x00, 0x00, 0xCC, 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //129
|
|
{0x00, 0x0C, 0x18, 0x30, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //130
|
|
{0x00, 0x10, 0x38, 0x6C, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //131
|
|
{0x00, 0x00, 0xCC, 0xCC, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //132
|
|
{0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //133
|
|
{0x00, 0x38, 0x6C, 0x38, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //134
|
|
{0x00, 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x60, 0x66, 0x3C, 0x0C, 0x06, 0x3C, 0x00, 0x00, 0x00}, //135
|
|
{0x00, 0x10, 0x38, 0x6C, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //136
|
|
{0x00, 0x00, 0xC6, 0xC6, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //137
|
|
{0x00, 0x60, 0x30, 0x18, 0x00, 0x7C, 0xC6, 0xFE, 0xC0, 0xC0, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //138
|
|
{0x00, 0x00, 0x66, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //139
|
|
{0x00, 0x18, 0x3C, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //140
|
|
{0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //141
|
|
{0x00, 0xC6, 0xC6, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //142
|
|
{0x38, 0x6C, 0x38, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //143
|
|
{0x18, 0x30, 0x60, 0x00, 0xFE, 0x66, 0x60, 0x7C, 0x60, 0x60, 0x66, 0xFE, 0x00, 0x00, 0x00, 0x00}, //144
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x76, 0x36, 0x7E, 0xD8, 0xD8, 0x6E, 0x00, 0x00, 0x00, 0x00}, //145
|
|
{0x00, 0x00, 0x3E, 0x6C, 0xCC, 0xCC, 0xFE, 0xCC, 0xCC, 0xCC, 0xCC, 0xCE, 0x00, 0x00, 0x00, 0x00}, //146
|
|
{0x00, 0x10, 0x38, 0x6C, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //147
|
|
{0x00, 0x00, 0xC6, 0xC6, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //148
|
|
{0x00, 0x60, 0x30, 0x18, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //149
|
|
{0x00, 0x30, 0x78, 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //150
|
|
{0x00, 0x60, 0x30, 0x18, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //151
|
|
{0x00, 0x00, 0xC6, 0xC6, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7E, 0x06, 0x0C, 0x78, 0x00}, //152
|
|
{0x00, 0xC6, 0xC6, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00}, //153
|
|
{0x00, 0xC6, 0xC6, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //154
|
|
{0x00, 0x18, 0x18, 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //155
|
|
{0x00, 0x38, 0x6C, 0x64, 0x60, 0xF0, 0x60, 0x60, 0x60, 0x60, 0xE6, 0xFC, 0x00, 0x00, 0x00, 0x00}, //156
|
|
{0x00, 0x00, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //157
|
|
{0x00, 0xF8, 0xCC, 0xCC, 0xF8, 0xC4, 0xCC, 0xDE, 0xCC, 0xCC, 0xCC, 0xC6, 0x00, 0x00, 0x00, 0x00}, //158
|
|
{0x00, 0x0E, 0x1B, 0x18, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0x70, 0x00, 0x00}, //159
|
|
{0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //160
|
|
{0x00, 0x0C, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00}, //161
|
|
{0x00, 0x18, 0x30, 0x60, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //162
|
|
{0x00, 0x18, 0x30, 0x60, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x00}, //163
|
|
{0x00, 0x00, 0x76, 0xDC, 0x00, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00}, //164
|
|
{0x76, 0xDC, 0x00, 0xC6, 0xE6, 0xF6, 0xFE, 0xDE, 0xCE, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //165
|
|
{0x00, 0x3C, 0x6C, 0x6C, 0x3E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //166
|
|
{0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //167
|
|
{0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, 0xC0, 0xC6, 0xC6, 0x7C, 0x00, 0x00, 0x00, 0x00}, //168
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00}, //169
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00}, //170
|
|
{0x00, 0xC0, 0xC0, 0xC2, 0xC6, 0xCC, 0x18, 0x30, 0x60, 0xCE, 0x93, 0x06, 0x0C, 0x1F, 0x00, 0x00}, //171
|
|
{0x00, 0xC0, 0xC0, 0xC2, 0xC6, 0xCC, 0x18, 0x30, 0x66, 0xCE, 0x9A, 0x3F, 0x06, 0x0F, 0x00, 0x00}, //172
|
|
{0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3C, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00}, //173
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x66, 0xCC, 0x66, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //174
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xCC, 0x66, 0x33, 0x66, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //175
|
|
{0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44}, //176
|
|
{0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA}, //177
|
|
{0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77}, //178
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //179
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //180
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //181
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //182
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //183
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //184
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //185
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //186
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //187
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //188
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //189
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //190
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //191
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //192
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //193
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //194
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //195
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //196
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //197
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //198
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //199
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //200
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //201
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //202
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //203
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //204
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //205
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //206
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //207
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //208
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //209
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //210
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //211
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //212
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //213
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //214
|
|
{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}, //215
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //216
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //217
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //218
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, //219
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, //220
|
|
{0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0}, //221
|
|
{0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F}, //222
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //223
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xDC, 0xD8, 0xD8, 0xD8, 0xDC, 0x76, 0x00, 0x00, 0x00, 0x00}, //224
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xC6, 0xFC, 0xC6, 0xC6, 0xFC, 0xC0, 0xC0, 0xC0, 0x00, 0x00}, //225
|
|
{0x00, 0x00, 0xFE, 0xC6, 0xC6, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00}, //226
|
|
{0x00, 0x00, 0x00, 0x00, 0x80, 0xFE, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00}, //227
|
|
{0x00, 0x00, 0x00, 0xFE, 0xC6, 0x60, 0x30, 0x18, 0x30, 0x60, 0xC6, 0xFE, 0x00, 0x00, 0x00, 0x00}, //228
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00}, //229
|
|
{0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xC0, 0x00, 0x00, 0x00}, //230
|
|
{0x00, 0x00, 0x00, 0x00, 0x76, 0xDC, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00}, //231
|
|
{0x00, 0x00, 0x00, 0x7E, 0x18, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00}, //232
|
|
{0x00, 0x00, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00}, //233
|
|
{0x00, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0x6C, 0x6C, 0x6C, 0x6C, 0xEE, 0x00, 0x00, 0x00, 0x00}, //234
|
|
{0x00, 0x00, 0x1E, 0x30, 0x18, 0x0C, 0x3E, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00}, //235
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xDB, 0xDB, 0xDB, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //236
|
|
{0x00, 0x00, 0x00, 0x03, 0x06, 0x7E, 0xCF, 0xDB, 0xF3, 0x7E, 0x60, 0xC0, 0x00, 0x00, 0x00, 0x00}, //237
|
|
{0x00, 0x00, 0x1C, 0x30, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00}, //238
|
|
{0x00, 0x00, 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, 0x00, 0x00, 0x00}, //239
|
|
{0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00}, //240
|
|
{0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00}, //241
|
|
{0x00, 0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}, //242
|
|
{0x00, 0x00, 0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}, //243
|
|
{0x00, 0x00, 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18}, //244
|
|
{0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0xD8, 0x70, 0x00, 0x00, 0x00, 0x00}, //245
|
|
{0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7E, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, //246
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xDC, 0x00, 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //247
|
|
{0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //248
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //249
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //250
|
|
{0x00, 0x0F, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x6C, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x00}, //251
|
|
{0x00, 0xD8, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //252
|
|
{0x00, 0x70, 0x98, 0x30, 0x60, 0xC8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, //253
|
|
{0x00, 0x00, 0x00, 0x00, 0x7C, 0x7C, 0x7C, 0x7C, 0x7C, 0x7C, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00}, //254
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} //255
|
|
};
|
|
|
|
struct nu_ge2d
|
|
{
|
|
char *name;
|
|
IRQn_Type irqn;
|
|
E_SYS_IPRST rstidx;
|
|
E_SYS_IPCLK clkidx;
|
|
|
|
rt_mutex_t lock;
|
|
#if defined(DEF_COND_WAIT)
|
|
rt_sem_t signal;
|
|
#endif
|
|
};
|
|
typedef struct nu_ge2d *nu_ge2d_t;
|
|
|
|
static struct nu_ge2d g_sNuGe2d =
|
|
{
|
|
.name = "GE2D",
|
|
.irqn = IRQ_GE2D,
|
|
.rstidx = GE2DRST,
|
|
.clkidx = GE2DCKEN
|
|
};
|
|
|
|
#define NU_GE2D_LOCK() { \
|
|
rt_err_t result = rt_mutex_take(g_sNuGe2d.lock, RT_WAITING_FOREVER); \
|
|
RT_ASSERT(result == RT_EOK); \
|
|
}
|
|
|
|
#define NU_GE2D_UNLOCK() { \
|
|
rt_err_t result = rt_mutex_release(g_sNuGe2d.lock); \
|
|
RT_ASSERT(result == RT_EOK); \
|
|
}
|
|
|
|
#if defined(DEF_COND_WAIT)
|
|
#define NU_GE2D_COND_WAIT() { \
|
|
rt_err_t result = rt_sem_take(g_sNuGe2d.signal, RT_WAITING_FOREVER); \
|
|
RT_ASSERT(result == RT_EOK); \
|
|
}
|
|
|
|
#define NU_GE2D_SIGNAL() { \
|
|
rt_err_t result = rt_sem_release(g_sNuGe2d.signal); \
|
|
RT_ASSERT(result == RT_EOK); \
|
|
}
|
|
/* Interrupt Service Routine for GE2D */
|
|
static void nu_ge2d_isr(int vector, void *param)
|
|
{
|
|
/* Clear interrupt status. */
|
|
outpw(REG_GE2D_INTSTS, 1);
|
|
|
|
/* Signal condition-waiting to resume caller. */
|
|
NU_GE2D_SIGNAL();
|
|
}
|
|
#else
|
|
#define NU_GE2D_COND_WAIT() { \
|
|
while ((inpw(REG_GE2D_INTSTS) & 0x01) == 0); \
|
|
outpw(REG_GE2D_INTSTS, 1); \
|
|
}
|
|
#define NU_GE2D_SIGNAL()
|
|
#endif
|
|
|
|
|
|
static unsigned long make_color(int color)
|
|
{
|
|
UINT32 r, g, b;
|
|
|
|
if (GFX_BPP == 8)
|
|
{
|
|
r = (color & 0x00e00000) >> 16; // 3 bits
|
|
g = (color & 0x0000e000) >> 11; // 3 bits
|
|
b = (color & 0x000000c0) >> 6; // 2 bits
|
|
return (r | g | b);
|
|
}
|
|
else if (GFX_BPP == 16)
|
|
{
|
|
r = (color & 0x00f80000) >> 8; // 5 bits
|
|
g = (color & 0x0000fc00) >> 5; // 6 bits
|
|
b = (color & 0x000000f8) >> 3; // 5 bits
|
|
return (r | g | b);
|
|
}
|
|
else return (UINT32)color;
|
|
}
|
|
/// @endcond /* HIDDEN_SYMBOLS */
|
|
|
|
/**
|
|
* @brief Clear the on screen buffer with a specified color.
|
|
* @param[in] color clear with this color.
|
|
* @return none
|
|
*/
|
|
void ge2dClearScreen(int color)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 color32, dest_pitch, dest_dimension;
|
|
|
|
color32 = make_color(color);
|
|
|
|
cmd32 = 0xcc430040;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_BGCOLR, color32); // fill with background color
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixels
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
outpw(REG_GE2D_DSTSPA, 0); // starts from (0,0)
|
|
|
|
dest_dimension = GFX_HEIGHT << 16 | GFX_WIDTH;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Set output data mask.
|
|
* @param[in] mask is mask value
|
|
* @return none
|
|
*/
|
|
void ge2dSetWriteMask(int mask)
|
|
{
|
|
outpw(REG_GE2D_WRPLNMSK, make_color(mask));
|
|
}
|
|
|
|
/**
|
|
* @brief Set source origin starting address.
|
|
* @param[in] ptr pointer of start address
|
|
* @return none
|
|
*/
|
|
void ge2dSetSourceOriginStarting(void *ptr)
|
|
{
|
|
outpw(REG_GE2D_XYSORG, (int)ptr);
|
|
}
|
|
|
|
/**
|
|
* @brief Set destination origin starting address.
|
|
* @param[in] ptr pointer of start address
|
|
* @return none
|
|
*/
|
|
void ge2dSetDestinationOriginStarting(void *ptr)
|
|
{
|
|
outpw(REG_GE2D_XYDORG, (int)ptr);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Reset graphics engine.
|
|
* @param none
|
|
* @return none
|
|
*/
|
|
void ge2dReset(void)
|
|
{
|
|
outpw(REG_GE2D_MISCTL, 0x40); // FIFO reset
|
|
outpw(REG_GE2D_MISCTL, 0x00);
|
|
|
|
outpw(REG_GE2D_MISCTL, 0x80); // Engine reset
|
|
outpw(REG_GE2D_MISCTL, 0x00);
|
|
}
|
|
|
|
/**
|
|
* @brief Graphics engine initialization.
|
|
* @param[in] bpp bit per pixel
|
|
* @param[in] width is width of display memory
|
|
* @param[in] height is height of display memory
|
|
* @param[in] destination is pointer of destination buffer address
|
|
* @return none
|
|
*/
|
|
void ge2dInit(int bpp, int width, int height, void *destination)
|
|
{
|
|
UINT32 data32;
|
|
|
|
if (destination == NULL)
|
|
return;
|
|
|
|
NU_GE2D_LOCK();
|
|
|
|
ge2dReset();
|
|
|
|
GFX_WIDTH = width;
|
|
GFX_HEIGHT = height;
|
|
|
|
_DrawMode = MODE_TRANSPARENT;
|
|
_ColorKey = COLOR_KEY;
|
|
_ColorKeyMask = 0xFFFFFF;
|
|
|
|
GFX_START_ADDR = (void *)destination;
|
|
|
|
if (GFX_BPP != bpp)
|
|
{
|
|
GFX_BPP = bpp;
|
|
if (GFX_PAT_ADDR != NULL)
|
|
{
|
|
rt_free_align(GFX_PAT_ADDR);
|
|
GFX_PAT_ADDR = RT_NULL;
|
|
}
|
|
if (GFX_PAT_ADDR == NULL)
|
|
{
|
|
uint32_t u32Size = (8 * 8 * (GFX_BPP / 8)) * 2;
|
|
GFX_PAT_ADDR = (void *)rt_malloc_align(u32Size, u32Size);
|
|
RT_ASSERT(GFX_PAT_ADDR != RT_NULL);
|
|
sysprintf("[%s] Allocated %d@0x%08x.\n", __func__, u32Size, GFX_PAT_ADDR);
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("[%s]\n", __func__);
|
|
sysprintf("screen width = %d\n", GFX_WIDTH);
|
|
sysprintf("screen height = %d\n", GFX_HEIGHT);
|
|
sysprintf("screen bpp = %d\n", GFX_BPP);
|
|
sysprintf("destination = 0x%x\n", destination);
|
|
#endif
|
|
|
|
outpw(REG_GE2D_INTSTS, 1); // clear interrupt
|
|
outpw(REG_GE2D_PATSA, (unsigned int)GFX_PAT_ADDR);
|
|
outpw(REG_GE2D_CTL, 0); // disable interrupt
|
|
outpw(REG_GE2D_XYDORG, (unsigned int)GFX_START_ADDR);
|
|
outpw(REG_GE2D_XYSORG, (unsigned int)GFX_START_ADDR);
|
|
|
|
outpw(REG_GE2D_WRPLNMSK, 0x00ffffff); // write plane mask
|
|
|
|
data32 = GE_BPP_8; // default is 8 bpp
|
|
|
|
if (GFX_BPP == 16)
|
|
{
|
|
data32 |= GE_BPP_16;
|
|
}
|
|
else if (GFX_BPP == 32)
|
|
{
|
|
data32 |= GE_BPP_32;
|
|
}
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
/**
|
|
* @brief Reset FIFO of graphics engine.
|
|
* @param none
|
|
* @return none
|
|
*/
|
|
void ge2dResetFIFO(void)
|
|
{
|
|
UINT32 temp32;
|
|
|
|
temp32 = inpw(REG_GE2D_MISCTL);
|
|
temp32 |= 0x00000040;
|
|
outpw(REG_GE2D_MISCTL, temp32);
|
|
temp32 &= 0xffffffbf;
|
|
outpw(REG_GE2D_MISCTL, temp32);
|
|
}
|
|
|
|
/**
|
|
* @brief Set BitBlt drawing mode.
|
|
* @param[in] opt is drawing mode
|
|
* @param[in] ckey is value of color key
|
|
* @param[in] mask is value of color mask
|
|
* @return none
|
|
*/
|
|
void ge2dBitblt_SetDrawMode(int opt, int ckey, int mask)
|
|
{
|
|
if (opt == MODE_TRANSPARENT)
|
|
{
|
|
_DrawMode = MODE_TRANSPARENT;
|
|
|
|
_ColorKey = make_color(ckey);
|
|
_ColorKeyMask = make_color(mask);
|
|
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (opt == MODE_DEST_TRANSPARENT)
|
|
{
|
|
_DrawMode = MODE_DEST_TRANSPARENT;
|
|
|
|
_ColorKey = make_color(ckey);
|
|
_ColorKeyMask = make_color(mask);
|
|
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else
|
|
{
|
|
_DrawMode = MODE_OPAQUE; // default is OPAQUE
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Set alpha blending programming.
|
|
* @param[in] opt is selection for enable or disable
|
|
* @param[in] ks is value of alpha blending factor Ks
|
|
* @param[in] kd is value of alpha blending factor Kd
|
|
* @return none
|
|
*/
|
|
int ge2dBitblt_SetAlphaMode(int opt, int ks, int kd)
|
|
{
|
|
if (ks + kd > 255)
|
|
return -1;
|
|
|
|
if (opt == 1)
|
|
{
|
|
_EnableAlpha = TRUE;
|
|
_AlphaKs = ks;
|
|
_AlphaKd = kd;
|
|
}
|
|
else
|
|
{
|
|
_EnableAlpha = FALSE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Screen-to-Screen BitBlt with SRCCOPY ROP operation.
|
|
* @param[in] srcx is source x position
|
|
* @param[in] srcy is source y position
|
|
* @param[in] destx is destination x position
|
|
* @param[in] desty is destination y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display width
|
|
* @return none
|
|
*/
|
|
void ge2dBitblt_ScreenToScreen(int srcx, int srcy, int destx, int desty, int width, int height)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_to_screen_blt():\n");
|
|
sysprintf("(%d,%d)=>(%d,%d)\n", srcx, srcy, destx, desty);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430000;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
if (srcx > destx) //+X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0x08;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
else //-X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
cmd32 |= 0x04; // 010
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0xc; // 110
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("new srcx=%d srcy=%d\n", srcx, srcy);
|
|
sysprintf("new destx=%d desty=%d\n", destx, desty);
|
|
#endif
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | GFX_WIDTH;
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = srcy << 16 | srcx;
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
//
|
|
// force to use the same starting address
|
|
//
|
|
outpw(REG_GE2D_XYSORG, (int)GFX_START_ADDR);
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR); //smf
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Screen-to-Screen BitBlt with ROP option.
|
|
* @param[in] srcx is source x position
|
|
* @param[in] srcy is source y position
|
|
* @param[in] destx is destination x position
|
|
* @param[in] desty is destination y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display width
|
|
* @param[in] rop is rop option
|
|
* @return none
|
|
*/
|
|
void ge2dBitblt_ScreenToScreenRop(int srcx, int srcy, int destx, int desty, int width, int height, int rop)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_to_screen_rop_blt():\n");
|
|
sysprintf("ROP=0x%x\n", rop);
|
|
sysprintf("(%d,%d)=>(%d,%d)\n", srcx, srcy, destx, desty);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
cmd32 = 0x00430000 | (rop << 24);
|
|
|
|
if (_PatternType == TYPE_MONO)
|
|
{
|
|
cmd32 |= 0x00000010; // default is TYPE_COLOR
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
if (srcx > destx) //+X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0x08;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
else //-X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
cmd32 |= 0x04; // 010
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0xc; // 110
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("new srcx=%d srcy=%d\n", srcx, srcy);
|
|
sysprintf("new destx=%d desty=%d\n", destx, desty);
|
|
#endif
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | GFX_WIDTH; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = srcy << 16 | srcx;
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
//
|
|
// force to use the same starting address
|
|
//
|
|
outpw(REG_GE2D_XYSORG, (int)GFX_START_ADDR);
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR); //smf
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
if ((rop == 0x00) || (rop == 0xff))
|
|
{
|
|
cmd32 = (cmd32 & 0xffff0fff) | 0x00009000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Source to destination BitBlt with SRCCOPY ROP operation.
|
|
* @param[in] srcx is source x position
|
|
* @param[in] srcy is source y position
|
|
* @param[in] destx is destination x position
|
|
* @param[in] desty is destination y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display width
|
|
* @param[in] srcpitch is source pixel pitch
|
|
* @param[in] destpitch is destination pixel pitch
|
|
* @return none
|
|
* @note before calling this function, it would set the source and destination origin starting place
|
|
*/
|
|
void ge2dBitblt_SourceToDestination(int srcx, int srcy, int destx, int desty, int width, int height, int srcpitch, int destpitch)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("source_to_destination_blt():\n");
|
|
sysprintf("(%d,%d)=>(%d,%d)\n", srcx, srcy, destx, desty);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430000;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
if (srcx > destx) //+X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0x08;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
else //-X
|
|
{
|
|
if (srcy > desty) //+Y
|
|
{
|
|
cmd32 |= 0x04; // 010
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
}
|
|
else //-Y
|
|
{
|
|
cmd32 |= 0xc; // 110
|
|
srcx = srcx + width - 1;
|
|
destx = destx + width - 1;
|
|
srcy = srcy + height - 1;
|
|
desty = desty + height - 1;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("new srcx=%d srcy=%d\n", srcx, srcy);
|
|
sysprintf("new destx=%d desty=%d\n", destx, desty);
|
|
#endif
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = destpitch << 16 | srcpitch; // pitch in pixel, back | GFX_WIDTH ??
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = srcy << 16 | srcx;
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Set the clip rectangle. (top-left to down-right).
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @return none
|
|
*/
|
|
void ge2dClip_SetClip(int x1, int y1, int x2, int y2)
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("set_clip(): (%d,%d)-(%d,%d)\n", x1, y1, x2, y2);
|
|
#endif
|
|
|
|
if ((x1 >= 0) && (y1 >= 0) && (x2 >= 0) && (y2 >= 0))
|
|
{
|
|
if ((x2 > x1) && (y2 > y1))
|
|
{
|
|
_ClipEnable = TRUE;
|
|
/* hardware clipper not includes last pixel */
|
|
x2++;
|
|
y2++;
|
|
_ClipTL = (UINT32)((y1 << 16) | x1);
|
|
_ClipBR = (UINT32)((y2 << 16) | x2);
|
|
}
|
|
else
|
|
{
|
|
_ClipEnable = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_ClipEnable = FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Set the clip to inside clip or outside clip.
|
|
* @param[in] opt is option for setting clip inside or outside, value could be
|
|
* - \ref MODE_INSIDE_CLIP
|
|
* - \ref MODE_OUTSIDE_CLIP
|
|
* @return none
|
|
*/
|
|
void ge2dClip_SetClipMode(int opt)
|
|
{
|
|
_OutsideClip = (opt == 0) ? FALSE : TRUE;
|
|
|
|
if (_OutsideClip)
|
|
{
|
|
#ifdef DEBUG
|
|
sysprintf("set_clip_mode(): OUTSIDE\n");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG
|
|
sysprintf("set_clip_mode(): INSIDE\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Draw an one-pixel rectangle frame.
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @param[in] color is color of this rectangle
|
|
* @param[in] opt is draw option, value could be
|
|
* - 0: rectangle
|
|
* - 1: diagonal
|
|
* @return none
|
|
*/
|
|
void ge2dDrawFrame(int x1, int y1, int x2, int y2, int color, int opt)
|
|
{
|
|
UINT32 dest_pitch, dest_start, dest_dimension;
|
|
UINT32 color32;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("draw_frame():\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x1, y1, x2, y2);
|
|
sysprintf("color=0x%x opt=%d\n", color, opt);
|
|
#endif
|
|
|
|
/*
|
|
** The opt==1 case must be specially handled.
|
|
*/
|
|
|
|
if (opt == 0)
|
|
{
|
|
outpw(REG_GE2D_CTL, 0xcccb0000); // rectangle
|
|
}
|
|
else
|
|
{
|
|
outpw(REG_GE2D_CTL, 0xcccf0000); // diagonal
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x1, y1, x2, y2);
|
|
#endif
|
|
|
|
color32 = make_color(color);
|
|
outpw(REG_GE2D_FGCOLR, color32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = y1 << 16 | x1;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = (y2 - y1) << 16 | (x2 - x1);
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_MISCTL, inpw(REG_GE2D_MISCTL)); // address caculation
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Draw an solid rectangle line.
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @param[in] color is color of this line
|
|
* @return none
|
|
*/
|
|
void ge2dLine_DrawSolidLine(int x1, int y1, int x2, int y2, int color)
|
|
{
|
|
int abs_X, abs_Y, min, max;
|
|
UINT32 step_constant, initial_error, direction_code;
|
|
UINT32 cmd32, dest_pitch, dest_start;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("draw_solid_line():\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x1, y1, x2, y2);
|
|
sysprintf("color=0x%x\n", color);
|
|
#endif
|
|
|
|
abs_X = ABS(x2 - x1); //absolute value
|
|
abs_Y = ABS(y2 - y1); //absolute value
|
|
if (abs_X > abs_Y) // X major
|
|
{
|
|
max = abs_X;
|
|
min = abs_Y;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * (min) - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpXl;
|
|
else // -Y direction
|
|
direction_code = XpYmXl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpXl;
|
|
else // -Y direction
|
|
direction_code = XmYmXl;
|
|
}
|
|
}
|
|
else // Y major
|
|
{
|
|
max = abs_Y;
|
|
min = abs_X;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * (min) - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpYl;
|
|
else // -Y direction
|
|
direction_code = XpYmYl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpYl;
|
|
else // -Y direction
|
|
direction_code = XmYmYl;
|
|
}
|
|
}
|
|
|
|
outpw(REG_GE2D_BETSC, step_constant);
|
|
outpw(REG_GE2D_BIEPC, initial_error);
|
|
|
|
cmd32 = 0x008b0000 | direction_code;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_BGCOLR, make_color(color));
|
|
outpw(REG_GE2D_FGCOLR, make_color(color));
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
dest_start = y1 << 16 | x1;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Draw an solid rectangle line with assigned RGB565 color
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @param[in] color is color of this line
|
|
* @return none
|
|
*/
|
|
void ge2dLine_DrawSolidLine_RGB565(int x1, int y1, int x2, int y2, int color)
|
|
{
|
|
int abs_X, abs_Y, min, max;
|
|
UINT32 step_constant, initial_error, direction_code;
|
|
UINT32 cmd32, dest_pitch, dest_start;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("draw_solid_line():\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x1, y1, x2, y2);
|
|
sysprintf("color=0x%x\n", color);
|
|
#endif
|
|
|
|
abs_X = ABS(x2 - x1); //absolute value
|
|
abs_Y = ABS(y2 - y1); //absolute value
|
|
if (abs_X > abs_Y) // X major
|
|
{
|
|
max = abs_X;
|
|
min = abs_Y;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * (min) - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpXl;
|
|
else // -Y direction
|
|
direction_code = XpYmXl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpXl;
|
|
else // -Y direction
|
|
direction_code = XmYmXl;
|
|
}
|
|
}
|
|
else // Y major
|
|
{
|
|
max = abs_Y;
|
|
min = abs_X;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * (min) - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpYl;
|
|
else // -Y direction
|
|
direction_code = XpYmYl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpYl;
|
|
else // -Y direction
|
|
direction_code = XmYmYl;
|
|
}
|
|
}
|
|
|
|
outpw(REG_GE2D_BETSC, step_constant);
|
|
outpw(REG_GE2D_BIEPC, initial_error);
|
|
|
|
cmd32 = 0x008b0000 | direction_code;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_BGCOLR, color);
|
|
outpw(REG_GE2D_FGCOLR, color);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
dest_start = y1 << 16 | x1;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Draw a styled line.
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @param[in] style is style of line pattern
|
|
* @param[in] fgcolor is color of foreground
|
|
* @param[in] bkcolor is color of background
|
|
* @param[in] draw_mode is transparent is enable or not
|
|
* @return none
|
|
*/
|
|
void ge2dLine_DrawStyledLine(int x1, int y1, int x2, int y2, int style, int fgcolor, int bkcolor, int draw_mode)
|
|
{
|
|
int abs_X, abs_Y, min, max;
|
|
UINT32 step_constant, initial_error, direction_code;
|
|
UINT32 cmd32, dest_pitch, dest_start;
|
|
UINT32 temp32, line_control_code;
|
|
|
|
abs_X = ABS(x2 - x1);
|
|
abs_Y = ABS(y2 - y1);
|
|
if (abs_X > abs_Y) // X major
|
|
{
|
|
max = abs_X;
|
|
min = abs_Y;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * min - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpXl;
|
|
else // -Y direction
|
|
direction_code = XpYmXl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpXl;
|
|
else // -Y direction
|
|
direction_code = XmYmXl;
|
|
}
|
|
}
|
|
else // Y major
|
|
{
|
|
max = abs_Y;
|
|
min = abs_X;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * min - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpYl;
|
|
else // -Y direction
|
|
direction_code = XpYmYl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpYl;
|
|
else // -Y direction
|
|
direction_code = XmYmYl;
|
|
}
|
|
}
|
|
|
|
outpw(REG_GE2D_BETSC, step_constant);
|
|
outpw(REG_GE2D_BIEPC, initial_error);
|
|
|
|
cmd32 = 0x009b0000 | direction_code; // styled line
|
|
if (draw_mode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // default is MODE_OPAQUE
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_BGCOLR, make_color(bkcolor));
|
|
outpw(REG_GE2D_FGCOLR, make_color(fgcolor));
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
dest_start = y1 << 16 | x1;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
line_control_code = style;
|
|
temp32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
temp32 = (line_control_code << 16) | temp32;
|
|
|
|
outpw(REG_GE2D_MISCTL, temp32); // address caculation
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Draw a styled line using RGB565 color
|
|
* @param[in] x1 is top-left x position
|
|
* @param[in] y1 is top-left y position
|
|
* @param[in] x2 is down-right x position
|
|
* @param[in] y2 is down-right y position
|
|
* @param[in] style is style of line pattern
|
|
* @param[in] fgcolor is color of foreground
|
|
* @param[in] bkcolor is color of background
|
|
* @param[in] draw_mode is transparent is enable or not
|
|
* @return none
|
|
*/
|
|
void ge2dLine_DrawStyledLine_RGB565(int x1, int y1, int x2, int y2, int style, int fgcolor, int bkcolor, int draw_mode)
|
|
{
|
|
int abs_X, abs_Y, min, max;
|
|
UINT32 step_constant, initial_error, direction_code;
|
|
UINT32 cmd32, dest_pitch, dest_start;
|
|
UINT32 temp32, line_control_code;
|
|
|
|
abs_X = ABS(x2 - x1);
|
|
abs_Y = ABS(y2 - y1);
|
|
if (abs_X > abs_Y) // X major
|
|
{
|
|
max = abs_X;
|
|
min = abs_Y;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * min - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpXl;
|
|
else // -Y direction
|
|
direction_code = XpYmXl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpXl;
|
|
else // -Y direction
|
|
direction_code = XmYmXl;
|
|
}
|
|
}
|
|
else // Y major
|
|
{
|
|
max = abs_Y;
|
|
min = abs_X;
|
|
|
|
step_constant = (((UINT32)(2 * (min - max))) << 16) | (UINT32)(2 * min);
|
|
initial_error = (((UINT32)(2 * min - max)) << 16) | (UINT32)(max);
|
|
|
|
if (x2 > x1) // +X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XpYpYl;
|
|
else // -Y direction
|
|
direction_code = XpYmYl;
|
|
}
|
|
else // -X direction
|
|
{
|
|
if (y2 > y1) // +Y direction
|
|
direction_code = XmYpYl;
|
|
else // -Y direction
|
|
direction_code = XmYmYl;
|
|
}
|
|
}
|
|
|
|
outpw(REG_GE2D_BETSC, step_constant);
|
|
outpw(REG_GE2D_BIEPC, initial_error);
|
|
|
|
cmd32 = 0x009b0000 | direction_code; // styled line
|
|
if (draw_mode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // default is MODE_OPAQUE
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_BGCOLR, bkcolor);
|
|
outpw(REG_GE2D_FGCOLR, fgcolor);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
dest_start = y1 << 16 | x1;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
line_control_code = style;
|
|
temp32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
temp32 = (line_control_code << 16) | temp32;
|
|
|
|
outpw(REG_GE2D_MISCTL, temp32); // address caculation
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle solid color fill with foreground color.
|
|
* @param[in] dx x position
|
|
* @param[in] dy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] color is color of foreground
|
|
* @return none
|
|
*/
|
|
void ge2dFill_Solid(int dx, int dy, int width, int height, int color)
|
|
{
|
|
UINT32 cmd32, color32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("solid_fill() begin\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", dx, dy, dx + width - 1, dy + height - 1);
|
|
sysprintf("color=0x%x\n", color);
|
|
#endif
|
|
|
|
color32 = make_color(color);
|
|
cmd32 = 0xcc430060;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_FGCOLR, color32); // fill with foreground color
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = dy << 16 | dx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle solid color fill with RGB565 color.
|
|
* @param[in] dx x position
|
|
* @param[in] dy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] color is RGB565 color of foreground
|
|
* @return none
|
|
*/
|
|
void ge2dFill_Solid_RGB565(int dx, int dy, int width, int height, int color)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("solid_fill()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", dx, dy, dx + width - 1, dy + height - 1);
|
|
sysprintf("color=0x%x\n", color);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430060;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_FGCOLR, color); // fill with foreground color
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = dy << 16 | dx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle solid color fill with background color.
|
|
* @param[in] dx x position
|
|
* @param[in] dy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] color is color of background
|
|
* @return none
|
|
*/
|
|
void ge2dFill_SolidBackground(int dx, int dy, int width, int height, int color)
|
|
{
|
|
UINT32 cmd32, color32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("solid_fill_back()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", dx, dy, dx + width - 1, dy + height - 1);
|
|
sysprintf("color=0x%x\n", color);
|
|
#endif
|
|
|
|
color32 = make_color(color);
|
|
|
|
cmd32 = 0xcc430040;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_BGCOLR, color32); // fill with foreground color
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = dy << 16 | dx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle fill with 8x8 color pattern.
|
|
* @param[in] dx x position
|
|
* @param[in] dy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @return none
|
|
* @note The color pattern data is stored in the off-screen buffer.
|
|
*/
|
|
void ge2dFill_ColorPattern(int dx, int dy, int width, int height)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("color_pattern_fill()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", dx, dy, dx + width - 1, dy + height - 1);
|
|
sysprintf("pattern offset (%d,%d)\n", dx % 8, dy % 8);
|
|
#endif
|
|
|
|
cmd32 = 0xf0430000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = dy << 16 | dx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle fill with 8x8 mono pattern.
|
|
* @param[in] dx x position
|
|
* @param[in] dy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] opt is transparent is enable or not
|
|
* @return none
|
|
*/
|
|
void ge2dFill_MonoPattern(int dx, int dy, int width, int height, int opt)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("mono_pattern_fill()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", dx, dy, dx + width - 1, dy + height - 1);
|
|
#endif
|
|
|
|
cmd32 = 0xf0430010;
|
|
if (opt == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00006000;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = dy << 16 | dx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle fill with 8x8 color pattern.
|
|
* @param[in] sx x position
|
|
* @param[in] sy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] rop is ROP operation code
|
|
* @return none
|
|
*/
|
|
void ge2dFill_ColorPatternROP(int sx, int sy, int width, int height, int rop)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("color_pattern_fill()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", sx, sy, sx + width - 1, sy + height - 1);
|
|
sysprintf("pattern offset (%d,%d)\n", sx % 8, sy % 8);
|
|
#endif
|
|
|
|
cmd32 = 0x00430000 | (rop << 24);
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = sy << 16 | sx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Rectangle fill with 8x8 mono pattern.
|
|
* @param[in] sx x position
|
|
* @param[in] sy y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] opt is transparent is enable or not
|
|
* @param[in] rop is ROP operation code
|
|
* @return none
|
|
*/
|
|
void ge2dFill_MonoPatternROP(int sx, int sy, int width, int height, int rop, int opt)
|
|
{
|
|
UINT32 cmd32;
|
|
UINT32 dest_start, dest_pitch, dest_dimension;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("mono_pattern_fill()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", sx, sy, sx + width - 1, sy + height - 1);
|
|
#endif
|
|
|
|
cmd32 = 0x00430010 | (rop << 24);
|
|
if (opt == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00006000;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = sy << 16 | sx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief TileBLT function.
|
|
* @param[in] srcx source x position
|
|
* @param[in] srcy source y position
|
|
* @param[in] destx destination x position
|
|
* @param[in] desty destination y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] x_count is tile count for x-axis
|
|
* @param[in] y_count is tile count for y-axis
|
|
* @return none
|
|
*/
|
|
void ge2dFill_TileBlt(int srcx, int srcy, int destx, int desty, int width, int height, int x_count, int y_count)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 tile_ctl;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("tile_blt_image()\n");
|
|
sysprintf("(%d,%d)=>(%d,%d)\n", srcx, srcy, destx, desty);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
sysprintf("%dx%d grids\n", x_count, y_count);
|
|
#endif
|
|
|
|
if (x_count > 0) x_count--;
|
|
if (y_count > 0) y_count--;
|
|
|
|
cmd32 = 0xcc430400; // b10 is the tile control
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | GFX_WIDTH; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = srcy << 16 | srcx; // redundancy ??
|
|
outpw(REG_GE2D_SRCSPA, src_start); // redundancy ??
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
tile_ctl = (y_count << 8) | (x_count);
|
|
outpw(REG_GE2D_TCNTVHSF, tile_ctl);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Host-to-Screen BitBlt with SRCCOPY (through data port)
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] buf is pointer of HostBLT data
|
|
* @return none
|
|
*/
|
|
void ge2dHostBlt_Write(int x, int y, int width, int height, void *buf)
|
|
{
|
|
UINT32 cmd32, dest_pitch, dest_start, dest_dimension;
|
|
int transfer_count, i, j;
|
|
UINT32 *ptr32, data32;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("host_write_blt()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x, y, x + width - 1, y + height - 1);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430020;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
ptr32 = (UINT32 *)buf;
|
|
for (i = 0; i < height; i++) // 120
|
|
{
|
|
transfer_count = (width * (GFX_BPP / 8) + 3) / 4; // 4-byte count
|
|
|
|
while (transfer_count >= 8)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < 8; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
transfer_count -= 8;
|
|
}
|
|
|
|
if (transfer_count > 0)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < transfer_count; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
}
|
|
}
|
|
|
|
while ((inpw(REG_GE2D_INTSTS) & 0x01) == 0); // wait for command complete
|
|
outpw(REG_GE2D_INTSTS, 1); // clear interrupt status
|
|
}
|
|
|
|
/**
|
|
* @brief Screen-to-Host BitBlt with SRCCOPY (through data port).
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] buf is pointer of HostBLT data
|
|
* @return none
|
|
*/
|
|
void ge2dHostBlt_Read(int x, int y, int width, int height, void *buf)
|
|
{
|
|
UINT32 cmd32, dest_pitch, dest_start, dest_dimension;
|
|
int transfer_count, i, j;
|
|
UINT32 *ptr32;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("host_read_blt()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x, y, x + width - 1, y + height - 1);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430001;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
ptr32 = (UINT32 *)buf;
|
|
for (i = 0; i < height; i++)
|
|
{
|
|
transfer_count = (width * (GFX_BPP / 8) + 3) / 4; // 4-byte count
|
|
|
|
while (transfer_count >= 8)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000400) == 0);
|
|
for (j = 0; j < 8; j++)
|
|
{
|
|
*ptr32++ = inpw(REG_GE2D_GEHBDW0);
|
|
}
|
|
transfer_count -= 8;
|
|
}
|
|
|
|
if (transfer_count > 0)
|
|
{
|
|
while (((inpw(REG_GE2D_MISCTL) & 0x0000f000) >> 12) != transfer_count);
|
|
for (j = 0; j < transfer_count; j++)
|
|
{
|
|
*ptr32++ = inpw(REG_GE2D_GEHBDW0);
|
|
}
|
|
}
|
|
}
|
|
|
|
while ((inpw(REG_GE2D_INTSTS) & 0x01) == 0); // wait for command complete
|
|
|
|
outpw(REG_GE2D_INTSTS, 1); // clear interrupt status
|
|
}
|
|
|
|
/**
|
|
* @brief Host-to-Screen SpriteBlt with SRCCOPY.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] buf is pointer of HostBLT data
|
|
* @return none
|
|
*/
|
|
void ge2dHostBlt_Sprite(int x, int y, int width, int height, void *buf)
|
|
{
|
|
UINT32 cmd32, dest_pitch, dest_start, dest_dimension;
|
|
int transfer_count, i, j;
|
|
UINT32 *ptr32, data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("host_sprite_blt()\n");
|
|
sysprintf("(%d,%d)-(%d,%d)\n", x, y, x + width - 1, y + height - 1);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430020;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
ptr32 = (UINT32 *)buf;
|
|
for (i = 0; i < height; i++)
|
|
{
|
|
transfer_count = width * (GFX_BPP / 8) / 4; // 4-byte count
|
|
|
|
while (transfer_count > 8)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < 8; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
transfer_count -= 8;
|
|
}
|
|
|
|
if (transfer_count > 0)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < transfer_count; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
}
|
|
}
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Captured the specified photo data from display memory, then displayed on display memory by rotation angle
|
|
* @param[in] srcx source x position
|
|
* @param[in] srcy source y position
|
|
* @param[in] destx destination x position
|
|
* @param[in] desty destination y position
|
|
* @param[in] width is display width
|
|
* @param[in] height is display height
|
|
* @param[in] ctl is drawing direction
|
|
* @return none
|
|
*/
|
|
void ge2dRotation(int srcx, int srcy, int destx, int desty, int width, int height, int ctl)
|
|
{
|
|
UINT32 cmd32, dest_start, src_start, dimension, pitch;
|
|
void *tmpscreen, *orig_dest_start00;
|
|
|
|
tmpscreen = (void *)rt_malloc(width * height * GFX_BPP / 8);
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("rotation_image()\n");
|
|
sysprintf("(%d,%d)=>(%d,%d)\n", srcx, srcy, destx, desty);
|
|
sysprintf("width=%d height=%d\n", width, height);
|
|
#endif
|
|
|
|
rt_memset(tmpscreen, 0, width * height * GFX_BPP / 8);
|
|
|
|
orig_dest_start00 = (void *)inpw(REG_GE2D_XYDORG);
|
|
outpw(REG_GE2D_XYDORG, (int)tmpscreen); //captured photo to another position
|
|
outpw(REG_GE2D_XYSORG, (int)GFX_START_ADDR);
|
|
|
|
ge2dBitblt_SourceToDestination(srcx, srcy, 0, 0, width, height, GFX_WIDTH, width);
|
|
|
|
src_start = dest_start = dimension = cmd32 = pitch = 0;
|
|
|
|
outpw(REG_GE2D_XYDORG, (int)orig_dest_start00);
|
|
outpw(REG_GE2D_XYSORG, (int)tmpscreen);
|
|
|
|
pitch = GFX_WIDTH << 16 | width;
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = 0 << 16 | 0; // captured photo at (0,0) position
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
cmd32 = 0xcc030000 | (ctl << 1);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
/* set rotation reference point xy register, then nothing happened */
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
rt_free(tmpscreen);
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief OffScreen-to-OnScreen SpriteBlt with SRCCOPY.
|
|
* @param[in] destx destination x position
|
|
* @param[in] desty destination y position
|
|
* @param[in] sprite_width is sprite width
|
|
* @param[in] sprite_height is sprite height
|
|
* @param[in] buf is pointer of origin data
|
|
* @return none
|
|
*/
|
|
void ge2dSpriteBlt_Screen(int destx, int desty, int sprite_width, int sprite_height, void *buf)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_sprite_blt():\n");
|
|
sysprintf("buf=%08x, x=%d y=%d width=%d height=%d\n", buf, destx, desty, sprite_width, sprite_height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430000;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | sprite_width; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = 0; // start from (0,0) of sprite
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = desty << 16 | destx;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = sprite_height << 16 | sprite_width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
outpw(REG_GE2D_XYSORG, (UINT32)buf);
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief OffScreen-to-OnScreen SpriteBlt with SRCCOPY.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] sprite_sx sprite x position
|
|
* @param[in] sprite_sy sprite y position
|
|
* @param[in] width is width
|
|
* @param[in] height is height
|
|
* @param[in] sprite_width is sprite width
|
|
* @param[in] sprite_height is sprite height
|
|
* @param[in] buf is pointer of origin data
|
|
* @return none
|
|
* @note The sprite starting address can be programmed.
|
|
*/
|
|
void ge2dSpriteBltx_Screen(int x, int y, int sprite_sx, int sprite_sy, int width, int height, int sprite_width, int sprite_height, void *buf)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_sprite_bltx(): (%d,%d)\n", x, y);
|
|
sysprintf("sprite width=%d height=%d\n", sprite_width, sprite_height);
|
|
sysprintf("x=%d y=%d width=%d height=%d\n", sprite_sx, sprite_sy, width, height);
|
|
#endif
|
|
|
|
cmd32 = 0xcc430000;
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | sprite_width; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
outpw(REG_GE2D_XYSORG, (UINT32)buf);
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR);
|
|
|
|
src_start = sprite_sy << 16 | sprite_sx;
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief OffScreen-to-OnScreen SpriteBlt with ROP.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] sprite_width is sprite width
|
|
* @param[in] sprite_height is sprite height
|
|
* @param[in] buf is pointer of origin data
|
|
* @param[in] rop is ROP operation code
|
|
* @return none
|
|
* @note The sprite always starts from (0,0) for the BLT.
|
|
*/
|
|
void ge2dSpriteBlt_ScreenRop(int x, int y, int sprite_width, int sprite_height, void *buf, int rop)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_sprite_rop_blt():\n");
|
|
sysprintf("x=%d y=%d width=%d height=%d\n", x, y, sprite_width, sprite_height);
|
|
sysprintf("rop=0x%x\n", rop);
|
|
#endif
|
|
|
|
cmd32 = 0x00430000 | (rop << 24);
|
|
|
|
if (_PatternType == TYPE_MONO)
|
|
{
|
|
cmd32 |= 0x00000010; // default is TYPE_COLOR
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | sprite_width; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = 0; // start from (0,0) of sprite
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = sprite_height << 16 | sprite_width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
outpw(REG_GE2D_XYSORG, (UINT32)buf);
|
|
outpw(REG_GE2D_XYDORG, (int) GFX_START_ADDR); //smf
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
if ((rop == 0x00) || (rop == 0xff))
|
|
{
|
|
cmd32 = (cmd32 & 0xffff0fff) | 0x00009000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief OffScreen-to-OnScreen SpriteBlt with ROP.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] sprite_sx sprite x position
|
|
* @param[in] sprite_sy sprite y position
|
|
* @param[in] width is width
|
|
* @param[in] height is height
|
|
* @param[in] sprite_width is sprite width
|
|
* @param[in] sprite_height is sprite height
|
|
* @param[in] buf is pointer of origin data
|
|
* @param[in] rop is ROP operation code
|
|
* @return none
|
|
* @note The sprite always starts from (0,0) for the BLT.
|
|
*/
|
|
void ge2dSpriteBltx_ScreenRop(int x, int y, int sprite_sx, int sprite_sy, int width, int height, int sprite_width, int sprite_height, void *buf, int rop)
|
|
{
|
|
UINT32 cmd32, pitch, dest_start, src_start, dimension;
|
|
UINT32 data32, alpha;
|
|
|
|
#ifdef DEBUG
|
|
sysprintf("screen_sprite_rop_bltx():\n");
|
|
sysprintf("x=%d y=%d width=%d height=%d\n", x, y, sprite_width, sprite_height);
|
|
sysprintf("rop=0x%x\n", rop);
|
|
#endif
|
|
|
|
cmd32 = 0x00430000 | (rop << 24);
|
|
|
|
if (_PatternType == TYPE_MONO)
|
|
{
|
|
cmd32 |= 0x00000010; // default is TYPE_COLOR
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
pitch = GFX_WIDTH << 16 | sprite_width; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
src_start = sprite_sy << 16 | sprite_sx;
|
|
outpw(REG_GE2D_SRCSPA, src_start);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dimension);
|
|
|
|
outpw(REG_GE2D_XYSORG, (UINT32)buf);
|
|
outpw(REG_GE2D_XYDORG, (int)GFX_START_ADDR); //smf
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
if (_DrawMode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00008000; // color transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
else if (_DrawMode == MODE_DEST_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00009000; // destination pixels control transparency
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_TRNSCOLR, _ColorKey);
|
|
outpw(REG_GE2D_TCMSK, _ColorKeyMask);
|
|
}
|
|
|
|
if (_EnableAlpha)
|
|
{
|
|
cmd32 |= 0x00200000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
data32 = inpw(REG_GE2D_MISCTL) & 0x0000ffff;
|
|
alpha = (UINT32)((_AlphaKs << 8) | _AlphaKd);
|
|
data32 |= (alpha << 16);
|
|
|
|
outpw(REG_GE2D_MISCTL, data32);
|
|
}
|
|
|
|
if ((rop == 0x00) || (rop == 0xff))
|
|
{
|
|
cmd32 = (cmd32 & 0xffff0fff) | 0x00009000;
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief OffScreen-to-OnScreen TextBLT.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] width is width
|
|
* @param[in] height is height
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @param[in] opt is transparent is enable or not
|
|
* @param[in] buf is pointer of origin data
|
|
* @return none
|
|
* @note Fetch the monochrome source data from off-screen memory to the desired destination area
|
|
*/
|
|
void ge2dColorExpansionBlt(int x, int y, int width, int height, int fore_color, int back_color, int opt, void *buf)
|
|
{
|
|
UINT32 cmd32, dest_pitch, src_pitch, pitch, dest_start, dest_dimension;
|
|
UINT32 fore_color32, back_color32;
|
|
|
|
fore_color32 = make_color(fore_color);
|
|
back_color32 = make_color(back_color);
|
|
|
|
cmd32 = 0xcc430080;
|
|
if (opt == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00004000; // mono transparency
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_FGCOLR, fore_color32);
|
|
outpw(REG_GE2D_BGCOLR, back_color32);
|
|
|
|
dest_pitch = GFX_WIDTH; // pitch in pixels
|
|
src_pitch = width; // pitch in pixels
|
|
|
|
pitch = (dest_pitch << 16) | src_pitch;
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
outpw(REG_GE2D_XYSORG, (int)buf);
|
|
outpw(REG_GE2D_SRCSPA, 0); // always start from (0,0)
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
if (_ClipEnable)
|
|
{
|
|
cmd32 |= 0x00000200;
|
|
if (_OutsideClip)
|
|
{
|
|
cmd32 |= 0x00000100;
|
|
}
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
outpw(REG_GE2D_CLPBTL, _ClipTL);
|
|
outpw(REG_GE2D_CLPBBR, _ClipBR);
|
|
}
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Host-to-Screen TextBLT through data port.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] width is width
|
|
* @param[in] height is height
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @param[in] opt is transparent is enable or not
|
|
* @param[in] buf is pointer of origin data
|
|
* @return none
|
|
*/
|
|
void ge2dHostColorExpansionBlt(int x, int y, int width, int height, int fore_color, int back_color, int opt, void *buf)
|
|
{
|
|
UINT32 cmd32, dest_pitch, dest_start, dest_dimension;
|
|
UINT32 fore_color32, back_color32;
|
|
UINT32 *ptr32, data32;
|
|
int transfer_count, i, j;
|
|
|
|
fore_color32 = make_color(fore_color);
|
|
back_color32 = make_color(back_color);
|
|
|
|
cmd32 = 0xcc4300a0;
|
|
if (opt == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00004000; // mono transparency
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_FGCOLR, fore_color32);
|
|
outpw(REG_GE2D_BGCOLR, back_color32);
|
|
|
|
dest_pitch = GFX_WIDTH << 16; // pitch in pixel
|
|
outpw(REG_GE2D_SDPITCH, dest_pitch);
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
outpw(REG_GE2D_SRCSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
ptr32 = (UINT32 *)buf;
|
|
for (i = 0; i < height; i++)
|
|
{
|
|
transfer_count = (width + 31) / 32; // 32 pixels unit
|
|
|
|
while (transfer_count > 8)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < 8; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
transfer_count -= 8;
|
|
}
|
|
|
|
if (transfer_count > 0)
|
|
{
|
|
while ((inpw(REG_GE2D_MISCTL) & 0x00000800) == 0); // check empty
|
|
for (j = 0; j < transfer_count; j++)
|
|
{
|
|
data32 = *ptr32++;
|
|
outpw(REG_GE2D_GEHBDW0, data32);
|
|
}
|
|
}
|
|
}
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Set the 8x8 mono pattern for following BitBLT functions.
|
|
* @param[in] opt is index for build-in pattern
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @return none
|
|
*/
|
|
void ge2dInitMonoPattern(int opt, int fore_color, int back_color)
|
|
{
|
|
UINT32 color32;
|
|
|
|
/*
|
|
** If hardware pattern definition is a little different from software.
|
|
** Need to do the BYTE swap before programming the pattern registers.
|
|
*/
|
|
|
|
outpw(REG_GE2D_PTNA, MonoPatternData[opt].PatternA);
|
|
outpw(REG_GE2D_PTNB, MonoPatternData[opt].PatternB);
|
|
|
|
color32 = make_color(fore_color);
|
|
outpw(REG_GE2D_FGCOLR, color32);
|
|
|
|
color32 = make_color(back_color);
|
|
outpw(REG_GE2D_BGCOLR, color32);
|
|
|
|
_PatternType = TYPE_MONO;
|
|
}
|
|
|
|
/**
|
|
* @brief Set the 8x8 mono pattern for following BitBLT functions.
|
|
* @param[in] PatternA is pattern A
|
|
* @param[in] PatternB is pattern B
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @return none
|
|
*/
|
|
void ge2dInitMonoInputPattern(UINT32 PatternA, UINT32 PatternB, int fore_color, int back_color)
|
|
{
|
|
UINT32 color32;
|
|
|
|
/*
|
|
** If hardware pattern definition is a little different from software.
|
|
** Need to do the BYTE swap before programming the pattern registers.
|
|
*/
|
|
|
|
outpw(REG_GE2D_PTNA, PatternA);
|
|
outpw(REG_GE2D_PTNB, PatternB);
|
|
|
|
color32 = make_color(fore_color);
|
|
outpw(REG_GE2D_FGCOLR, color32);
|
|
|
|
color32 = make_color(back_color);
|
|
outpw(REG_GE2D_BGCOLR, color32);
|
|
|
|
_PatternType = TYPE_MONO;
|
|
}
|
|
|
|
/**
|
|
* @brief Set the 8x8 color pattern for following BitBLT functions.
|
|
* @param[in] patformat is format of pattern, value could be
|
|
* - \ref RGB888
|
|
* - \ref RGB565
|
|
* - \ref RGB332
|
|
* @param[in] patdata is pointer of input pattern image
|
|
* @return none
|
|
* @note This function transfers those forms:
|
|
* RGB888 to RGB565 or RGB332
|
|
* RGB565 to RGB332 or RGB888
|
|
* RGB332 to RGB565 or RGB888
|
|
*/
|
|
void ge2dInitColorPattern(int patformat, void *patdata)
|
|
{
|
|
UINT8 *ptr_pat;
|
|
UINT8 *ptr8, r8, g8, b8;
|
|
UINT16 *ptr16, r16, g16, b16, g16_1, g16_2;
|
|
UINT32 *ptr32, r32, g32, b32, g32_1, g32_2;
|
|
int idx;
|
|
|
|
ptr_pat = (UINT8 *)patdata;
|
|
if (patformat == RGB888)
|
|
{
|
|
if (GFX_BPP == 8)
|
|
{
|
|
ptr8 = (UINT8 *)GFX_PAT_ADDR;
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
b8 = (UINT8)(*ptr_pat++) & 0xc0; // 2 bits
|
|
g8 = (UINT8)(*ptr_pat++) & 0xe0; // 3 bits
|
|
r8 = (UINT8)(*ptr_pat++) & 0xe0; // 3 bits
|
|
ptr_pat++;
|
|
*ptr8++ = r8 | (g8 >> 3) | (b8 >> 6);
|
|
}
|
|
}
|
|
else if (GFX_BPP == 16)
|
|
{
|
|
ptr16 = (UINT16 *)GFX_PAT_ADDR;
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
b16 = (UINT16)(*ptr_pat++) & 0x000f8; // 5 bits
|
|
g16 = (UINT16)(*ptr_pat++) & 0x000fc; // 6 bits
|
|
r16 = (UINT16)(*ptr_pat++) & 0x000f8; // 5 bits
|
|
ptr_pat++;
|
|
*ptr16++ = (r16 << 8) | (g16 << 3) | (b16 >> 3);
|
|
}
|
|
}
|
|
else if (GFX_BPP == 32)
|
|
{
|
|
ptr32 = (UINT32 *)GFX_PAT_ADDR;
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
b32 = (UINT32)(*ptr_pat++);
|
|
g32 = (UINT32)(*ptr_pat++);
|
|
r32 = (UINT32)(*ptr_pat++);
|
|
ptr_pat++;
|
|
*ptr32++ = (r32 << 16) | (g32 << 8) | b32;
|
|
}
|
|
}
|
|
}
|
|
else if (patformat == RGB565)
|
|
{
|
|
if (GFX_BPP == 8)
|
|
{
|
|
ptr8 = (UINT8 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
b8 = (UINT8)(*ptr_pat++) & 0x00018; // 2 bits
|
|
g8 = (UINT8)(*ptr_pat) & 0x00007; // 3 bits
|
|
r8 = (UINT8)(*ptr_pat++) & 0x000e0; // 3bits
|
|
*ptr8++ = r8 | (g8 << 2) | (b8 >> 3);
|
|
}
|
|
}
|
|
else if (GFX_BPP == 16)
|
|
{
|
|
ptr16 = (UINT16 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
*ptr16++ = (*ptr_pat) | (*(ptr_pat + 1)) << 8;
|
|
ptr_pat += 2;
|
|
}
|
|
}
|
|
else if (GFX_BPP == 32)
|
|
{
|
|
ptr32 = (UINT32 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
b32 = (UINT8)(*ptr_pat) & 0x1f; // 5 bits
|
|
g32_1 = (UINT8)(*ptr_pat++) & 0xe0; // front 3 bits
|
|
g32_2 = (UINT8)(*ptr_pat) & 0x07; // back 3 bits
|
|
g32 = ((g32_1 >> 5) | (g32_2 << 3)) << 2;
|
|
r32 = (UINT8)(*ptr_pat++) & 0xf8; // 5 bits
|
|
*ptr32++ = 0 << 24 | (r32 << 16) | (g32 << 8) | (b32 << 3);
|
|
}
|
|
}
|
|
}
|
|
else if (patformat == RGB332)
|
|
{
|
|
if (GFX_BPP == 8)
|
|
{
|
|
ptr8 = (UINT8 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
*ptr8++ = *ptr_pat;
|
|
ptr_pat++;
|
|
}
|
|
}
|
|
else if (GFX_BPP == 16)
|
|
{
|
|
ptr16 = (UINT16 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
r16 = (UINT8)(*ptr_pat) & 0xe0; // 3 bits
|
|
g16_1 = (UINT8)(*ptr_pat) & 0x10;
|
|
g16_2 = (UINT8)(*ptr_pat) & 0x0c;
|
|
g16 = (g16_1 >> 2) | (g16_2 >> 2);
|
|
b16 = (UINT8)(*ptr_pat++) & 0x3; // 2 bits
|
|
*ptr16++ = (r16 << 8) | (g16 << 8) | (b16 << 3);
|
|
}
|
|
}
|
|
else if (GFX_BPP == 32)
|
|
{
|
|
ptr32 = (UINT32 *)GFX_PAT_ADDR;
|
|
|
|
for (idx = 0; idx < 64; idx++)
|
|
{
|
|
r32 = (UINT8)(*ptr_pat) & 0xe0; // 3 bits
|
|
g32 = (UINT8)(*ptr_pat) & 0x1c; // 3 bits
|
|
b32 = (UINT8)(*ptr_pat++) & 0x3; // 2 bits
|
|
*ptr32++ = 0 << 24 | (r32 << 15) | (g32 << 11) | (b32 << 6);
|
|
}
|
|
}
|
|
}
|
|
|
|
_PatternType = TYPE_COLOR;
|
|
}
|
|
|
|
/**
|
|
* @brief Display font character.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] asc_code is ascii code
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @param[in] draw_mode is transparent is enable or not
|
|
* @param[in] font_id is selection of 8x8 or 8x16 font
|
|
* @return none
|
|
*/
|
|
void ge2dFont_PutChar(int x, int y, char asc_code, int fore_color, int back_color, int draw_mode, int font_id)
|
|
{
|
|
int cmd32, dest_pitch, src_pitch, pitch, dest_start, dest_dimension;
|
|
UINT32 width, height;
|
|
UINT32 fore_color32, back_color32;
|
|
UINT8 *fptr;
|
|
UINT8 *temp_buf[32 * 32], *ptr8;
|
|
int idx;
|
|
|
|
fore_color32 = make_color(fore_color);
|
|
back_color32 = make_color(back_color);
|
|
|
|
cmd32 = 0xcc430080;
|
|
|
|
if (draw_mode == MODE_TRANSPARENT)
|
|
{
|
|
cmd32 |= 0x00004000; // mono transparency
|
|
}
|
|
|
|
outpw(REG_GE2D_CTL, cmd32);
|
|
|
|
outpw(REG_GE2D_FGCOLR, fore_color32);
|
|
outpw(REG_GE2D_BGCOLR, back_color32);
|
|
|
|
if (font_id == F8x16)
|
|
{
|
|
fptr = (UINT8 *)&FontData16[asc_code][0];
|
|
src_pitch = 32;
|
|
width = 32;
|
|
height = 16;
|
|
|
|
ptr8 = (UINT8 *)&temp_buf[0];
|
|
for (idx = 0; idx < 16; idx++)
|
|
{
|
|
*ptr8++ = *fptr++;
|
|
*ptr8++ = 0;
|
|
*ptr8++ = 0;
|
|
*ptr8++ = 0;
|
|
}
|
|
fptr = (UINT8 *)&temp_buf[0];
|
|
}
|
|
else /* F8x8 */
|
|
{
|
|
fptr = (UINT8 *)&FontData8[asc_code][0];
|
|
src_pitch = 32;
|
|
width = 32;
|
|
height = 8;
|
|
ptr8 = (UINT8 *)&temp_buf[0];
|
|
for (idx = 0; idx < 8; idx++)
|
|
{
|
|
*ptr8++ = *fptr++;
|
|
*ptr8++ = 0;
|
|
*ptr8++ = 0;
|
|
*ptr8++ = 0;
|
|
}
|
|
fptr = (UINT8 *)&temp_buf[0];
|
|
}
|
|
|
|
dest_pitch = GFX_WIDTH; // pitch in pixels
|
|
|
|
pitch = (dest_pitch << 16) | src_pitch;
|
|
outpw(REG_GE2D_SDPITCH, pitch);
|
|
|
|
outpw(REG_GE2D_XYSORG, (int)fptr);
|
|
outpw(REG_GE2D_SRCSPA, 0); // always start from (0,0)
|
|
|
|
dest_start = y << 16 | x;
|
|
outpw(REG_GE2D_DSTSPA, dest_start);
|
|
|
|
dest_dimension = height << 16 | width;
|
|
outpw(REG_GE2D_RTGLSZ, dest_dimension);
|
|
|
|
outpw(REG_GE2D_TRG, 1);
|
|
|
|
NU_GE2D_COND_WAIT();
|
|
|
|
NU_GE2D_UNLOCK();
|
|
}
|
|
|
|
/**
|
|
* @brief Display font string.
|
|
* @param[in] x x position
|
|
* @param[in] y y position
|
|
* @param[in] str is pointer of display string
|
|
* @param[in] fore_color is color of foreground
|
|
* @param[in] back_color is color of background
|
|
* @param[in] draw_mode is transparent is enable or not
|
|
* @param[in] font_id is selection of 8x8 or 8x16 font
|
|
* @return none
|
|
*/
|
|
void ge2dFont_PutString(int x, int y, char *str, int fore_color, int back_color, int draw_mode, int font_id)
|
|
{
|
|
char *ptr;
|
|
int idx, sx;
|
|
|
|
ptr = str;
|
|
sx = x;
|
|
for (idx = 0; idx < rt_strlen(str); idx++)
|
|
{
|
|
ge2dFont_PutChar(sx, y, *ptr++, fore_color, back_color, draw_mode, font_id);
|
|
sx += 8; //char width
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hardware GE2D Initialization
|
|
*/
|
|
int rt_hw_ge2d_init(void)
|
|
{
|
|
g_sNuGe2d.lock = rt_mutex_create("ge2d_lock", RT_IPC_FLAG_PRIO);
|
|
RT_ASSERT(g_sNuGe2d.lock != RT_NULL);
|
|
|
|
#if defined(DEF_COND_WAIT)
|
|
rt_kprintf("with_cond_wait\n");
|
|
g_sNuGe2d.signal = rt_sem_create("ge2d_wait", 0, RT_IPC_FLAG_FIFO);
|
|
RT_ASSERT(g_sNuGe2d.signal != RT_NULL);
|
|
|
|
/* Install ISR & Respond the IRQ */
|
|
rt_hw_interrupt_install(g_sNuGe2d.irqn, nu_ge2d_isr, &g_sNuGe2d, g_sNuGe2d.name);
|
|
rt_hw_interrupt_umask(g_sNuGe2d.irqn);
|
|
#endif
|
|
|
|
/* Enable GE2D engine clock */
|
|
nu_sys_ipclk_enable(GE2DCKEN);
|
|
|
|
return 0;
|
|
}
|
|
|
|
INIT_DEVICE_EXPORT(rt_hw_ge2d_init);
|