dc.cpp

一个完全的4级灰度的嵌入式CDC显示类。支持DC的全部操作。对于嵌入式开发是一个非常好的工具。

void CDC::LineTo(INT16 iX, INT16 iY)
{
    HwLine(m_iCurX, m_iCurY, iX, iY,
               m_iPenColor, m_iDrawMode, m_iPenWidth, m_iLineStyle);
    m_iCurX = iX;
    m_iCurY = iY;
}

void CDC::SetPixel(INT16 iX, INT16 iY)
{
    ::HwSetPixel(iX, iY, m_iPenColor, m_iDrawMode, m_iPenWidth);
}
void CDC::PaintRect(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    ::HwPaintRect(iLeft, iTop, iRight, iBottom, m_iPenColor);
}
void CDC::EraseRect(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    ::HwPaintRect(iLeft, iTop, iRight, iBottom, m_iBackColor);
}
void CDC::FrameRect(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    ::HwLine(iLeft, iTop, iRight, iTop, m_iPenColor, m_iDrawMode, m_iPenWidth, m_iLineStyle); 
    ::HwLine(iLeft, iTop, iLeft, iBottom, m_iPenColor, m_iDrawMode, m_iPenWidth, m_iLineStyle); 
    ::HwLine(iLeft, iBottom, iRight, iBottom, m_iPenColor, m_iDrawMode, m_iPenWidth, m_iLineStyle); 
    ::HwLine(iRight, iBottom, iRight, iTop, m_iPenColor, m_iDrawMode, m_iPenWidth, m_iLineStyle); 
}
void CDC::PutImage(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom, UINT8 * pImgBuf, UINT8 iPutAttr)
{
    ::HwWriteImage(iLeft, iTop, iRight, iBottom, iPutAttr, pImgBuf); 
}
void CDC::PaintRect(CRect &src)
{
    ::HwPaintRect(src.left, src.top, src.right, src.bottom, m_iPenColor);
}
void CDC::EraseRect(CRect &src)
{
    ::HwPaintRect(src.left, src.top, src.right, src.bottom, m_iBackColor);
}
void CDC::FrameRect(CRect &src)
{
    FrameRect(src.left, src.top, src.right, src.bottom);
}
void CDC::Draw3dRect(INT16 x0, INT16 y0, INT16 x1, INT16 y1, UINT8 cTopLeft, UINT8 cBottomRight)
{
    ::HwLine(x0, y0, x1, y0, cTopLeft, DRAWMODE_REP, 1, 0);
    ::HwLine(x0, y0, x0, y1, cTopLeft, DRAWMODE_REP, 1, 0);
    ::HwLine(x1, y1, x1, y0, cBottomRight, DRAWMODE_REP, 1, 0);
    ::HwLine(x1, y1, x0, y1, cBottomRight, DRAWMODE_REP, 1, 0);
}
void CDC::Draw3dRect(CRect &srRec, UINT8 cTopLeft, UINT8 cBottomRight)
{
    Draw3dRect(srRec.left, srRec.top, srRec.right, srRec.bottom, cTopLeft, cBottomRight);
}
void CDC::ClearDevice(UINT8 iColor)
{
    ::HwClearDevice(iColor);
}

ScreenBuf * CDC::SaveScreen(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    ScreenBuf *pBuf = (ScreenBuf *)SysMalloc(sizeof(ScreenBuf));
    if(!pBuf)
        return NULL;
    UINT16 size = HwImageSize(iLeft, iTop, iRight, iBottom);
    pBuf->pBuffer = (UINT8 *)SysMalloc(size);
    if(!pBuf->pBuffer)
    {
        SysFree(pBuf); 
        return NULL;
    }
    memset(pBuf->pBuffer, 0, size);
    pBuf->x0 = iLeft;
    pBuf->y0 = iTop;
    pBuf->x1 = iRight;
    pBuf->y1 = iBottom;
    ::HwReadImage(iLeft, iTop, iRight, iBottom, pBuf->pBuffer);
    return pBuf;

}
 
ScreenBuf * CDC::SaveScreen(CRect &srRec)
{
    return SaveScreen(srRec.left, srRec.top, srRec.right, srRec.bottom);
}

void CDC::WriteScreen(ScreenBuf *pScrBuf, UINT8 iPutAttr)
{
    ::HwWriteImage(pScrBuf->x0, pScrBuf->y0, 
                   pScrBuf->x1, pScrBuf->y1, 
                   iPutAttr, pScrBuf->pBuffer);
}

void CDC::PutScreen(ScreenBuf * &pScrBuf, UINT8 iPutAttr)	// wangfei 03-29
{
    ::HwWriteImage(pScrBuf->x0, pScrBuf->y0, 
                   pScrBuf->x1, pScrBuf->y1, 
                   iPutAttr, pScrBuf->pBuffer);
    SysFree(pScrBuf->pBuffer);
    SysFree(pScrBuf);
	pScrBuf = NULL;
}
void CDC::InvertRect(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    ::HwInvertRect(iLeft, iTop, iRight, iBottom);
} 
void CDC::InvertRect(CRect &srRec)
{
    ::HwInvertRect(srRec.left, srRec.top, srRec.right, srRec.bottom);
}
void CDC::TextOut(INT16 iX, INT16 iY, char *pText, INT16 iLen)
{
    ::HwPutString(iX, iY, m_iBackColor, m_iPenColor, m_iDrawMode, (UINT8 *)pText, iLen); 
}

void CDC::DrawText(CRect &srRect, char *pStr)
{
	INT16	x, y;
    UINT8 *pText = (UINT8 *)pStr;

    if (m_iHalign == HALIGN_CENTER)
		x = (srRect.left + srRect.right) / 2 - GetTextExtent(pStr) / 2;
	else if (m_iHalign == HALIGN_RIGHT)
		x = srRect.right - GetTextExtent(pStr);
	else
		x = srRect.left;

	if (m_iValign == VALIGN_MID)
		y = (srRect.top + srRect.bottom) / 2 - CHAR_HEIGHT / 2;
	else if (m_iValign == VALIGN_BOTTOM)
		y = srRect.bottom - CHAR_HEIGHT;
	else
		y = srRect.top;

    while(*pText && y <= srRect.bottom - CHAR_HEIGHT+1 && pStr)
    {
        if(ISCC(*pText))
         {
			if(x < srRect.left)
			{
				x+= HZ_WIDTH;
				pText +=2;
			}
            else if(x + HZ_WIDTH-1 <= srRect.right)
            {
              ::HwPutHz(x, y, m_iBackColor, m_iPenColor, m_iDrawMode, MAKEWORD(*(pText+1), *pText));
              x+= HZ_WIDTH;
              pText +=2;
            }
            else
            {
                x = srRect.left;
                y += CHAR_HEIGHT;
            }
         }
         else
         {
			 if(x < srRect.left)
			 {
				x+= ASC_WIDTH;
				pText++;
			 }
             else if(x + ASC_WIDTH-1 < srRect.right && *pText != 0x0D )// hqf
             {
              ::HwPutAsc(x, y, m_iBackColor, m_iPenColor, m_iDrawMode, *pText);
              x+= ASC_WIDTH;
              pText++;
             }
             else
             {
               x = srRect.left;
               y += CHAR_HEIGHT;
               if(*pText == 0x0D)  // hqf
                   pText +=2;
             }
         }
    }
}

void CDC::DrawText(INT16 iX, INT16 iY, char *pText)
{
 ::HwDrawText(iX, iY, m_iBackColor, m_iPenColor, m_iDrawMode, m_iHalign, m_iValign, pText);
}

INT16 CDC::GetTextExtent(char *pText)
{
    return HwGetTextExtern(pText);
}

INT16 CDC::GetTextHeight(INT16 iLeft, INT16  iRight, char *pStr)
{
 
    INT16 x = iLeft;
    INT16 y = 0; 
    UINT8 *pText = (UINT8 *)pStr;
    while(*pText && pStr)
    {
        if(ISCC(*pText))
         {
            if(x + HZ_WIDTH-1 <= iRight)
            {
              x+= HZ_WIDTH;
              pText +=2;
            }
            else
            {
                x = iLeft;
                y += CHAR_HEIGHT;
            }
         }
         else
         {
             if(x + ASC_WIDTH-1 < iRight && *pText != '\n')
             {
              x+= ASC_WIDTH;
              pText++;
             }
             else 
             {
               x = iLeft;
               y += CHAR_HEIGHT;
               if(*pText == '\n')
                   pText++;
             }
         }
    }
    return y + CHAR_HEIGHT;
}

void CDC::Draw3dButton(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom, char *pCaption)
{
	::HwPaintRect(iLeft, iTop, iRight, iBottom, LGRAY);
    ::HwDrawText((iLeft + iRight)/2 +1, (iTop + iBottom)/2+1, 
                 LGRAY, BLACK, DRAWMODE_REP, HALIGN_CENTER, 
                 VALIGN_MID, pCaption);
    Draw3dRect(iLeft, iTop, iRight, iBottom);
	//Draw3dRect(iLeft+1, iTop+1, iRight-1, iBottom-1);
}

void CDC::Draw3dButton(CRect &srRec, char *pCaption)
{
  Draw3dButton(srRec.left, srRec.top, srRec.right, srRec.bottom, pCaption);
}

void CDC::PutIcon(INT16 x, INT16 y, UINT32 iIcon)
{
	UINT16 *temp;

	if (iIcon > BMPTOTAL  || iIcon == 0)
		return;
	temp = (UINT16 *)gICON_ADDR(iIcon);
	if(*(temp + 3)== COMPRESS_LZW)
	{ 
		BYTE *pImage;
		CLZWDecode lzwDec;

		lzwDec.Decode((BYTE *)(temp + 6), &pImage);
	    ::HwWriteImage(x, y, x+gICON_WIDTH(iIcon)-1, y+gICON_HEIGHT(iIcon)-1, m_iDrawMode, (UINT8*)(pImage));
		lzwDec.ReleaseBuf(pImage);
	}
	if(*(temp + 3)== COMPRESS_NO)
	{
	   ::HwWriteImage(x, y, x+gICON_WIDTH(iIcon)-1, y+gICON_HEIGHT(iIcon)-1, m_iDrawMode, (UINT8*)(gICON_ADDR(iIcon) + 12));
	}

//    if(iIcon && iIcon <= BMPTOTAL)
//     ::HwWriteImage(x, y, x+gICON_WIDTH(iIcon)-1,  y+gICON_HEIGHT(iIcon)-1, m_iDrawMode, (UINT8*)(gICON_ADDR(iIcon)+12));
}

void CDC::GetImage(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom, UINT8 * pImagBuf)
{
    ::HwReadImage(iLeft, iTop, iRight, iBottom, pImagBuf); 
}

UINT16 CDC::ImageSize(INT16 iLeft, INT16 iTop, INT16 iRight, INT16 iBottom)
{
    return ::HwImageSize(iLeft,iTop, iRight, iBottom); 
}

UINT16 CDC::ImageSize(CRect &srRec)
{
    return ::HwImageSize(srRec.left, srRec.top, srRec.right, srRec.bottom);
}

void CDC::PutImage(CRect &srRec, UINT8 * pImgBuf, UINT8 iPutAttr)
{ 
    PutImage(srRec.left, srRec.top, srRec.right, srRec.bottom, pImgBuf, iPutAttr);
}
   
void CDC::GetImage(CRect &srRec, UINT8 *pImgBuf)
{
    GetImage(srRec.left, srRec.top, srRec.right, srRec.bottom, pImgBuf);
}

void CDC::PutChar(INT16 x, INT16 y, UINT16 iChar)
{
    if(iChar)
    {
        if(ISCC(HIBYTE(iChar)))
            ::HwPutHz(x, y, m_iBackColor, m_iPenColor, m_iDrawMode, iChar);
        else
            ::HwPutAsc(x, y, m_iBackColor, m_iPenColor, m_iDrawMode, LOBYTE(iChar));
    }
}

//画椭圆
void CDC::Ellipse(INT16 x0, INT16 y0, INT16 x1, INT16 y1)
{
    ::HwEllipse(x0, y0, x1, y1, m_iPenColor, m_iDrawMode, m_iPenWidth);
}

void CDC::Ellipse(CRect &srRec)
{
    Ellipse(srRec.left, srRec.top, srRec.right, srRec.bottom);
}
/*
BOOL CDC::FloodFill(INT16 x, INT16 y)
{
    return HwFloodFill(x, y, m_iPenColor);
}
*/
//end of CDC

//下面的数据用于1 bit到2 bit字节转换时查表以加快转换速度
const UINT16 g_iOneBit2TwoBitMap[256] =
{
    0x0000, 0x0003, 0x000C, 0x000F, 0x0030, 0x0033, 0x003C, 0x003F, 
    0x00C0, 0x00C3, 0x00CC, 0x00CF, 0x00F0, 0x00F3, 0x00FC, 0x00FF, 
    0x0300, 0x0303, 0x030C, 0x030F, 0x0330, 0x0333, 0x033C, 0x033F, 
    0x03C0, 0x03C3, 0x03CC, 0x03CF, 0x03F0, 0x03F3, 0x03FC, 0x03FF, 
    0x0C00, 0x0C03, 0x0C0C, 0x0C0F, 0x0C30, 0x0C33, 0x0C3C, 0x0C3F, 
    0x0CC0, 0x0CC3, 0x0CCC, 0x0CCF, 0x0CF0, 0x0CF3, 0x0CFC, 0x0CFF, 
    0x0F00, 0x0F03, 0x0F0C, 0x0F0F, 0x0F30, 0x0F33, 0x0F3C, 0x0F3F, 
    0x0FC0, 0x0FC3, 0x0FCC, 0x0FCF, 0x0FF0, 0x0FF3, 0x0FFC, 0x0FFF, 
    0x3000, 0x3003, 0x300C, 0x300F, 0x3030, 0x3033, 0x303C, 0x303F, 
    0x30C0, 0x30C3, 0x30CC, 0x30CF, 0x30F0, 0x30F3, 0x30FC, 0x30FF, 
    0x3300, 0x3303, 0x330C, 0x330F, 0x3330, 0x3333, 0x333C, 0x333F, 
    0x33C0, 0x33C3, 0x33CC, 0x33CF, 0x33F0, 0x33F3, 0x33FC, 0x33FF, 
    0x3C00, 0x3C03, 0x3C0C, 0x3C0F, 0x3C30, 0x3C33, 0x3C3C, 0x3C3F, 
    0x3CC0, 0x3CC3, 0x3CCC, 0x3CCF, 0x3CF0, 0x3CF3, 0x3CFC, 0x3CFF, 
    0x3F00, 0x3F03, 0x3F0C, 0x3F0F, 0x3F30, 0x3F33, 0x3F3C, 0x3F3F, 
    0x3FC0, 0x3FC3, 0x3FCC, 0x3FCF, 0x3FF0, 0x3FF3, 0x3FFC, 0x3FFF, 
    0xC000, 0xC003, 0xC00C, 0xC00F, 0xC030, 0xC033, 0xC03C, 0xC03F, 
    0xC0C0, 0xC0C3, 0xC0CC, 0xC0CF, 0xC0F0, 0xC0F3, 0xC0FC, 0xC0FF, 
    0xC300, 0xC303, 0xC30C, 0xC30F, 0xC330, 0xC333, 0xC33C, 0xC33F, 
    0xC3C0, 0xC3C3, 0xC3CC, 0xC3CF, 0xC3F0, 0xC3F3, 0xC3FC, 0xC3FF, 
    0xCC00, 0xCC03, 0xCC0C, 0xCC0F, 0xCC30, 0xCC33, 0xCC3C, 0xCC3F, 
    0xCCC0, 0xCCC3, 0xCCCC, 0xCCCF, 0xCCF0, 0xCCF3, 0xCCFC, 0xCCFF, 
    0xCF00, 0xCF03, 0xCF0C, 0xCF0F, 0xCF30, 0xCF33, 0xCF3C, 0xCF3F, 
    0xCFC0, 0xCFC3, 0xCFCC, 0xCFCF, 0xCFF0, 0xCFF3, 0xCFFC, 0xCFFF, 
    0xF000, 0xF003, 0xF00C, 0xF00F, 0xF030, 0xF033, 0xF03C, 0xF03F, 
    0xF0C0, 0xF0C3, 0xF0CC, 0xF0CF, 0xF0F0, 0xF0F3, 0xF0FC, 0xF0FF, 
    0xF300, 0xF303, 0xF30C, 0xF30F, 0xF330, 0xF333, 0xF33C, 0xF33F, 
    0xF3C0, 0xF3C3, 0xF3CC, 0xF3CF, 0xF3F0, 0xF3F3, 0xF3FC, 0xF3FF, 
    0xFC00, 0xFC03, 0xFC0C, 0xFC0F, 0xFC30, 0xFC33, 0xFC3C, 0xFC3F, 
    0xFCC0, 0xFCC3, 0xFCCC, 0xFCCF, 0xFCF0, 0xFCF3, 0xFCFC, 0xFCFF, 
    0xFF00, 0xFF03, 0xFF0C, 0xFF0F, 0xFF30, 0xFF33, 0xFF3C, 0xFF3F, 
    0xFFC0, 0xFFC3, 0xFFCC, 0xFFCF, 0xFFF0, 0xFFF3, 0xFFFC, 0xFFFF
} ;

//下面的数据用于2 bit到1 bit字节转换时查表以加快转换速度
//把一个两bit字节转到一个bit中的高四位
const  UINT8 g_iTwoBit2OneBitHeight[256] =
{
    0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 
    0x20, 0x20, 0x30, 0x30, 0x20, 0x20, 0x30, 0x30, 
    0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 
    0x20, 0x20, 0x30, 0x30, 0x20, 0x20, 0x30, 0x30, 
    0x40, 0x40, 0x50, 0x50, 0x40, 0x40, 0x50, 0x50, 
    0x60, 0x60, 0x70, 0x70, 0x60, 0x60, 0x70, 0x70, 
    0x40, 0x40, 0x50, 0x50, 0x40, 0x40, 0x50, 0x50, 
    0x60, 0x60, 0x70, 0x70, 0x60, 0x60, 0x70, 0x70, 
    0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 
    0x20, 0x20, 0x30, 0x30, 0x20, 0x20, 0x30, 0x30, 
    0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 
    0x20, 0x20, 0x30, 0x30, 0x20, 0x20, 0x30, 0x30, 
    0x40, 0x40, 0x50, 0x50, 0x40, 0x40, 0x50, 0x50, 
    0x60, 0x60, 0x70, 0x70, 0x60, 0x60, 0x70, 0x70, 
    0x40, 0x40, 0x50, 0x50, 0x40, 0x40, 0x50, 0x50, 
    0x60, 0x60, 0x70, 0x70, 0x60, 0x60, 0x70, 0x70, 
    0x80, 0x80, 0x90, 0x90, 0x80, 0x80, 0x90, 0x90, 
    0xA0, 0xA0, 0xB0, 0xB0, 0xA0, 0xA0, 0xB0, 0xB0, 
    0x80, 0x80, 0x90, 0x90, 0x80, 0x80, 0x90, 0x90, 
    0xA0, 0xA0, 0xB0, 0xB0, 0xA0, 0xA0, 0xB0, 0xB0, 
    0xC0, 0xC0, 0xD0, 0xD0, 0xC0, 0xC0, 0xD0, 0xD0, 
    0xE0, 0xE0, 0xF0, 0xF0, 0xE0, 0xE0, 0xF0, 0xF0, 
    0xC0, 0xC0, 0xD0, 0xD0, 0xC0, 0xC0, 0xD0, 0xD0, 
    0xE0, 0xE0, 0xF0, 0xF0, 0xE0, 0xE0, 0xF0, 0xF0, 
    0x80, 0x80, 0x90, 0x90, 0x80, 0x80, 0x90, 0x90, 
    0xA0, 0xA0, 0xB0, 0xB0, 0xA0, 0xA0, 0xB0, 0xB0, 
    0x80, 0x80, 0x90, 0x90, 0x80, 0x80, 0x90, 0x90, 
    0xA0, 0xA0, 0xB0, 0xB0, 0xA0, 0xA0, 0xB0, 0xB0, 
    0xC0, 0xC0, 0xD0, 0xD0, 0xC0, 0xC0, 0xD0, 0xD0, 
    0xE0, 0xE0, 0xF0, 0xF0, 0xE0, 0xE0, 0xF0, 0xF0, 
    0xC0, 0xC0, 0xD0, 0xD0, 0xC0, 0xC0, 0xD0, 0xD0, 
    0xE0, 0xE0, 0xF0, 0xF0, 0xE0, 0xE0, 0xF0, 0xF0 
}; 
//把一个两bit字节转到一个bit中的低四位
const  UINT8 g_iTwoBit2OneBitLow[256] =
{
    0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 
    0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 
    0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 
    0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 
    0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 
    0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 
    0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 
    0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 
    0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 
    0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 
    0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 
    0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 
    0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 
    0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 
    0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 
    0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 
    0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 
    0x0A, 0x0A, 0x0B, 0x0B, 0x0A, 0x0A, 0x0B, 0x0B, 
    0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 
    0x0A, 0x0A, 0x0B, 0x0B, 0x0A, 0x0A, 0x0B, 0x0B, 
    0x0C, 0x0C, 0x0D, 0x0D, 0x0C, 0x0C, 0x0D, 0x0D, 
    0x0E, 0x0E, 0x0F, 0x0F, 0x0E, 0x0E, 0x0F, 0x0F, 
    0x0C, 0x0C, 0x0D, 0x0D, 0x0C, 0x0C, 0x0D, 0x0D, 
    0x0E, 0x0E, 0x0F, 0x0F, 0x0E, 0x0E, 0x0F, 0x0F, 
    0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 
    0x0A, 0x0A, 0x0B, 0x0B, 0x0A, 0x0A, 0x0B, 0x0B, 
    0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 
    0x0A, 0x0A, 0x0B, 0x0B, 0x0A, 0x0A, 0x0B, 0x0B, 
    0x0C, 0x0C, 0x0D, 0x0D, 0x0C, 0x0C, 0x0D, 0x0D, 
    0x0E, 0x0E, 0x0F, 0x0F, 0x0E, 0x0E, 0x0F, 0x0F, 
    0x0C, 0x0C, 0x0D, 0x0D, 0x0C, 0x0C, 0x0D, 0x0D, 
    0x0E, 0x0E, 0x0F, 0x0F, 0x0E, 0x0E, 0x0F, 0x0F
};
// dc.cpp end