T168_Backup\T168_111\appl\Graphic文件：

最新推荐文章于 2024-07-19 15:45:46 发布

qq_33772147

最新推荐文章于 2024-07-19 15:45:46 发布

阅读量836

点赞数 17

文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_33772147/article/details/136818004

版权

BMP.c //

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define BMP_C

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include "Common.h"
#include "XFileSys.h"
#include "XGraphic.h"
#include "BMP.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/******************02-08-99 10:44********************/
/* decode BMP                                       */
/*                                                   */
/* 1. 2 color                                       */
/* 2. 256 color change to 2 color                   */
/*                                                   */
/****************************************************/
typedef struct
{
   WORD   wIdentWord;
   DWORD   dFileSize;
   WORD   wRev;
   WORD   wRev1;
   DWORD   dOffset;

   DWORD   dSize;
   DWORD   dWidth;
   DWORD   dHeight;
   WORD   wPlanes;
   WORD   wBitCount;
   DWORD   dCompression;
   DWORD   dSizeImage;
   DWORD   dXPelsPerMeter;
   DWORD   dYPelsPerMeter;
   DWORD   dClrUsed;
   DWORD   dClrImportant;
}_BMP_Header;

typedef struct
{
   INT iImageWidth;
   INT iImageHeight;
   INT iUseWidth;
   INT iUseHeight;
   INT iImageWidthByte;
   INT iDataWidthByte;
   INT iUseWidthByte;
   BYTE abPalette[256];
   BYTE bEndFlag;
   BYTE bShiftBit;
   BYTE bShiftBit1;
    BYTE bShiftData;
   BYTE bRemoveData;
    BYTE bRemoveMaskBit;
   BYTE bShiftMaskData;
   BYTE bRemoveMaskData;
}_BMP_Data;

/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

INT BMPmain(_BMPAttr *sBMPattr);
INT BITMAP(_BMPAttr *sBMPAttr);
INT get_lineB8(BYTE *pbBuf, _BMP_Data *sBMP_Data);
INT decode_BMP1(_BMPAttr *sBMPAttr);
INT decode_BMP8(_BMPAttr *sBMPAttr);

/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

_FileHandle *FBMP;
_BMP_Header sBMP_Header;
BYTE abBMP_Buffer[1024], abBuf[1024 + 0x3F];

/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
INT get_lineB8(BYTE *pbBuf, _BMP_Data *sBMP_Data)
{
   INT i;
   BYTE *pbPtr, *pbPalette, bBit;

   *pbBuf = 0;
   bBit = 0x80;
   pbPalette = sBMP_Data->abPalette;

if ( Fread(abBMP_Buffer, sizeof(BYTE), sBMP_Data->iUseWidth, FBMP) != sBMP_Data->iUseWidth )
return _ERROR;

   pbPtr = abBMP_Buffer;
   for ( i = 0 ; i < sBMP_Data->iUseWidth ; i++ )
   {
       if ( *(pbPalette + *pbPtr) == 1 )
           *pbBuf |= bBit;

pbPtr += 1;
bBit >>= 1;

       if ( bBit == 0 )
       {
           bBit = 0x80;
           pbBuf += 1;
           *pbBuf = 0;
       }
   }

   if ( (sBMP_Data->iDataWidthByte - sBMP_Data->iUseWidth) > 0 )
   {
       i = sBMP_Data->iDataWidthByte - sBMP_Data->iUseWidth;
       if ( Fread(abBMP_Buffer, sizeof(BYTE), i, FBMP) != i )
           return _ERROR;
   }
   return _SUCCESS;
}

INT decode_BMP8(_BMPAttr *sBMPAttr)
{
   BYTE *pbImagePtr, *pbTemp, *pbPalette, bData;
   INT i, j;
   DWORD dOffset;
   _BMP_Data sBMP_Data;

   if ( (sBMP_Data.iImageWidth = sBMP_Header.dWidth) <= 0 )
       return _ERROR;
   if ( (sBMP_Data.iImageHeight = sBMP_Header.dHeight) <= 0 )
       return _ERROR;

if ( Fread(abBMP_Buffer, sizeof(BYTE), 1024, FBMP) != 1024 ) // 256 * 4 = 1024
return _ERROR;

   // Get Palette
   pbTemp = abBMP_Buffer;
   pbPalette = sBMP_Data.abPalette;
   for ( i = 0 ; i < 256 ; i++ )
   {
       if ( ((*pbTemp+0) + (*pbTemp+1) + (*pbTemp+2)) > 384 ) // 256 * 3 / 2 = 384
           *pbPalette = 0;
       else
           *pbPalette = 1;

       pbPalette += 1;
       pbTemp += 4;
   }

   // ImageWidthByte & DataWidthByte
   sBMP_Data.iImageWidthByte = sBMP_Data.iImageWidth;
   sBMP_Data.iDataWidthByte = sBMP_Data.iImageWidth;
   i = sBMP_Data.iDataWidthByte % 4;
   if ( i != 0 )
       sBMP_Data.iDataWidthByte += (4 - i);

   // UseWidth & UseWidthByte
   if ( (sBMPAttr->sCoord.iX + sBMP_Data.iImageWidth) > sBMPAttr->psImageBuffer->iWidth )
   {
       sBMP_Data.bEndFlag = 1;
       sBMP_Data.iUseWidth = sBMPAttr->psImageBuffer->iWidth - sBMPAttr->sCoord.iX;
       if ( sBMP_Data.iUseWidth <= 0 )
           return _SUCCESS;

       if ( (sBMP_Data.iUseWidth % 8) > 0 )
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8 + 1;
       else
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8;
   }
   else
   {
       sBMP_Data.bEndFlag = 0;
       sBMP_Data.iUseWidth = sBMP_Data.iImageWidth;

       if ( (sBMP_Data.iImageWidth % 8) > 0 )
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8 + 1;
       else
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8;
   }

   // Shift Bit
   sBMP_Data.bShiftBit = (BYTE)(sBMPAttr->sCoord.iX % 8);
   sBMP_Data.bShiftBit1 = 8 - sBMP_Data.bShiftBit;

   // UseHeight
   if ( (sBMPAttr->sCoord.iY + sBMP_Data.iImageHeight) > sBMPAttr->psImageBuffer->iHeight )
   {
       sBMP_Data.iUseHeight = sBMPAttr->psImageBuffer->iHeight - sBMPAttr->sCoord.iY;
       if ( sBMP_Data.iUseHeight <= 0 )
           return _SUCCESS;
   }
   else
   {
       sBMP_Data.iUseHeight = sBMP_Data.iImageHeight;
   }

   // The Last Line
   //if ( (i = sBMPAttr->sCoord.iY + sBMP_Data.iUseHeight) > sBMPAttr->psImageBuffer->iLastLine )
   //   sBMPAttr->psImageBuffer->iLastLine = i;
   ModifyImgSection(sBMPAttr->sCoord.iY, sBMP_Data.iUseHeight, sBMPAttr->psImageBuffer);

// Image Offset
dOffset = (DWORD)(sBMPAttr->psImageBuffer->iByteWidth *
(sBMPAttr->sCoord.iY + sBMP_Data.iUseHeight - 1) + sBMPAttr->sCoord.iX / 8);

   if ((sBMP_Data.iImageHeight - sBMP_Data.iUseHeight) > 0 )
   {
       // sizeof(sBMP_Header) - 2 + 4 * 256 = 54 + 1024 = 1078
       if ( Fseek(FBMP, 1078 + (sBMP_Data.iImageHeight - sBMP_Data.iUseHeight)
                           * sBMP_Data.iDataWidthByte, SEEK_SET) != 0 )
           return _ERROR;
   }

   // Get Data & Put Data
   sBMP_Data.bShiftData = 0;
   if ( sBMP_Data.bShiftBit == 0 )
   {
       for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
       {
           if ( get_lineB8(abBuf, &sBMP_Data) == _ERROR )
               return _ERROR;

           pbTemp = abBuf;
           pbImagePtr = sBMPAttr->psImageBuffer->pBuffer + dOffset;
           for ( i = 0 ; i < sBMP_Data.iUseWidthByte ; i++ )
           {
               *pbImagePtr |= *pbTemp;
               pbImagePtr += 1;
               pbTemp += 1;
           }
           dOffset -= sBMPAttr->psImageBuffer->iByteWidth;
       }
   }
   else
   {
       for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
       {
           if ( get_lineB8(abBuf, &sBMP_Data) == _ERROR )
               return _ERROR;

           pbTemp = abBuf;
           pbImagePtr = sBMPAttr->psImageBuffer->pBuffer + dOffset;
           for ( i = 0 ; i < sBMP_Data.iUseWidthByte ; i++ )
           {
               bData = *pbTemp;
               *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;
           }

if ( sBMP_Data.bEndFlag == 0 )
*pbImagePtr |= sBMP_Data.bShiftData;

           sBMP_Data.bShiftData = 0;
           dOffset -= sBMPAttr->psImageBuffer->iByteWidth;
       }
   }
   return _SUCCESS;
}

INT decode_BMP1(_BMPAttr *sBMPAttr)
{
   _BMP_Data sBMP_Data;
   BYTE *pbImagePtr, *pbTemp, bData;
   DWORD dOffset;
   INT i, j;

if ( Fread(abBuf, sizeof(BYTE), 8, FBMP) != 8 )
return _ERROR;

   if ( (sBMP_Data.iImageWidth = sBMP_Header.dWidth) <= 0 )
       return _ERROR;
   if ( (sBMP_Data.iImageHeight = sBMP_Header.dHeight) <= 0 )
       return _ERROR;

   // ImageWidthByte & Remove Bit
   if ( sBMP_Data.iImageWidth % 8 == 0 )
   {
       sBMP_Data.iImageWidthByte = sBMP_Data.iImageWidth / 8;
       sBMP_Data.bRemoveData = 0xFF;
   }
   else
   {
       sBMP_Data.iImageWidthByte = sBMP_Data.iImageWidth / 8 + 1;
       sBMP_Data.bRemoveData = 0xFF << (8 - sBMP_Data.iImageWidth % 8);
   }

   // DataWidthByte
   i = sBMP_Data.iImageWidthByte % 4;
   if ( i == 0 )
       sBMP_Data.iDataWidthByte = sBMP_Data.iImageWidthByte;
   else
       sBMP_Data.iDataWidthByte = sBMP_Data.iImageWidthByte + (4 - i);

       if ( (sBMP_Data.iUseWidth % 8 ) > 0 )
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8 + 1;
       else
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8;
   }
   else
   {
       sBMP_Data.bEndFlag = 0;
       sBMP_Data.iUseWidthByte = sBMP_Data.iImageWidthByte;
   }

   // Shift Bit
   sBMP_Data.bShiftBit = (BYTE)(sBMPAttr->sCoord.iX % 8);
   sBMP_Data.bShiftBit1 = 8 - sBMP_Data.bShiftBit;

dOffset = (DWORD)(sBMPAttr->psImageBuffer->iByteWidth *
(sBMPAttr->sCoord.iY + sBMP_Data.iUseHeight - 1) + sBMPAttr->sCoord.iX / 8);

   if ((sBMP_Data.iImageHeight - sBMP_Data.iUseHeight) > 0 )
   {
       Fseek(FBMP, sizeof(sBMP_Header) - 2 + 8 + (sBMP_Data.iImageHeight - sBMP_Data.iUseHeight)
                   * sBMP_Data.iDataWidthByte, SEEK_SET);
   }

#if defined(TSPL_VER_1)   // AND
   sBMP_Data.bRemoveMaskBit = ( sBMPAttr->sCoord.iX + sBMP_Data.iImageWidth ) % 8;
   if ( sBMP_Data.bRemoveMaskBit == 0 )
       sBMP_Data.bRemoveMaskData = 0;
   else
       sBMP_Data.bRemoveMaskData = 0xFF >> sBMP_Data.bRemoveMaskBit;
#endif

   // Get Data & Put Data
   sBMP_Data.bShiftData = 0;
   if ( sBMP_Data.bShiftBit == 0 )
   {
       for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
       {
           if ( Fread(abBuf, sizeof(BYTE), sBMP_Data.iUseWidthByte, FBMP) != sBMP_Data.iUseWidthByte )
               return _ERROR;

pbTemp = abBuf;
pbImagePtr = sBMPAttr->psImageBuffer->pBuffer + dOffset;

#if defined(TSPL_VER_1)   // AND
           for ( i = 0; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               *pbImagePtr++ = ~(*pbTemp++);

           i += 1;
           if ( i == sBMP_Data.iImageWidthByte )
           {
               *pbImagePtr &= sBMP_Data.bRemoveMaskData;
               *pbImagePtr |= ((~(*pbTemp)) & sBMP_Data.bRemoveData);
           }
           else
               *pbImagePtr = ~(*pbTemp);
#else
           for ( i = 0; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               *pbImagePtr++ |= ~(*pbTemp++);

           i += 1;
           if ( i == sBMP_Data.iImageWidthByte )
               *pbImagePtr |= ((~(*pbTemp)) & sBMP_Data.bRemoveData);
           else
               *pbImagePtr |= ~(*pbTemp);
#endif
           if ( sBMP_Data.iUseWidthByte < sBMP_Data.iDataWidthByte )
           {
               i = sBMP_Data.iDataWidthByte - sBMP_Data.iUseWidthByte;
               if ( Fread(abBuf, sizeof(BYTE), i, FBMP) != i )
                   return _ERROR;
           }
           dOffset -= sBMPAttr->psImageBuffer->iByteWidth;
       }
   }
   else
   {

#if defined(TSPL_VER_1)   // AND
       sBMP_Data.bShiftMaskData = 0xFF << sBMP_Data.bShiftBit1;
       if ( (sBMP_Data.bShiftBit + sBMP_Data.iImageWidth) <= 8 )
           sBMP_Data.bRemoveMaskData |= sBMP_Data.bShiftMaskData;
#endif
       for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
       {
           if ( Fread(abBuf, sizeof(BYTE), sBMP_Data.iUseWidthByte, FBMP) != sBMP_Data.iUseWidthByte )
               return _ERROR;

pbTemp = abBuf;
pbImagePtr = sBMPAttr->psImageBuffer->pBuffer + dOffset;

#if defined(TSPL_VER_1)   // AND
           if ( sBMP_Data.iUseWidthByte != 1 )
           {
               bData = ~(*pbTemp);
               *pbImagePtr &= sBMP_Data.bShiftMaskData;
               *pbImagePtr |= (bData >> sBMP_Data.bShiftBit);
               sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;

               for ( i = 1 ; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   bData = ~(*pbTemp);
                   *pbImagePtr = ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                   sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                   pbImagePtr += 1;
                   pbTemp += 1;
               }
           }
           else   // sBMP_Data.iUseWidthByte == 1
               i = 0;

           i += 1;
           if ( i == sBMP_Data.iImageWidthByte )       // sBMP_Data.bEndFlag == 0
           {
               bData = (~(*pbTemp)) & sBMP_Data.bRemoveData;
               if (sBMP_Data.bShiftBit1 >= (sBMP_Data.iImageWidth % 8) && (sBMP_Data.iImageWidth % 8) != 0)
               {
                   *pbImagePtr &= sBMP_Data.bRemoveMaskData;
                   *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               }
               else
               {
                   if ( sBMP_Data.iUseWidthByte != 1 )
                       *pbImagePtr = ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                   else
                   {
                       *pbImagePtr &= sBMP_Data.bShiftMaskData;
                       *pbImagePtr |= (bData >> sBMP_Data.bShiftBit);
                   }
                   sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                   pbImagePtr += 1;

                   if ( sBMP_Data.bEndFlag == 0 )
                   {
                       *pbImagePtr &= sBMP_Data.bRemoveMaskData;
                       *pbImagePtr |= sBMP_Data.bShiftData;
                   }
               }
           }
           else                                       // sBMP_Data.bEndFlag == 1
           {
               bData = ~(*pbTemp);
               *pbImagePtr &= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
           }
#else
           for ( i = 0 ; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
           {
               bData = ~(*pbTemp);
               *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;
           }
           i += 1;
           if ( i == sBMP_Data.iImageWidthByte )       // sBMP_Data.bEndFlag == 0
               bData = (~(*pbTemp)) & sBMP_Data.bRemoveData;
           else                                       // sBMP_Data.bEndFlag == 1
               bData = ~(*pbTemp);

           *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
           sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
           pbImagePtr += 1;

if ( sBMP_Data.bEndFlag == 0 )
*pbImagePtr |= sBMP_Data.bShiftData;
#endif

           if ( sBMP_Data.iUseWidthByte < sBMP_Data.iDataWidthByte )
           {
               i = sBMP_Data.iDataWidthByte - sBMP_Data.iUseWidthByte;
               if ( Fread(abBuf, sizeof(BYTE), i, FBMP) != i )
                   return _ERROR;
           }
           sBMP_Data.bShiftData = 0;
           dOffset -= sBMPAttr->psImageBuffer->iByteWidth;
       }
   }
   return _SUCCESS;
}

INT BMPmain(_BMPAttr *sBMPAttr)
{
BYTE *pbTemp;

   while ( 1 )
   {
       if ( ( FBMP = Fopen(DRAM_DEVICE, (CHAR *)sBMPAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FBMP = Fopen(FLASH_DEVICE, (CHAR *)sBMPAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FBMP = Fopen(CARD_DEVICE, (CHAR *)sBMPAttr->pbFileName, "r") ) != _NULL ){}
       if ( FBMP == _NULL )
           break;

       /* get the header -- Start */
       pbTemp = (BYTE *)&sBMP_Header;
       if ( Fread(pbTemp, sizeof(BYTE), 2, FBMP) != 2 )
           break;
       pbTemp += 4;

#if defined(BIG_ENDIAN)
       sBMP_Header.wIdentWord = (sBMP_Header.wIdentWord >> 8) + (sBMP_Header.wIdentWord << 8);
#endif
       if ( sBMP_Header.wIdentWord != 0x4D42 )
           break;
       if ( Fread(pbTemp, sizeof(BYTE), sizeof(sBMP_Header) - 4, FBMP) != sizeof(sBMP_Header) - 4 )
           break;

#if defined(BIG_ENDIAN)
       sBMP_Header.dWidth = (sBMP_Header.dWidth >> 24) + ((sBMP_Header.dWidth >> 8)&0x0000FF00) +
                                   ((sBMP_Header.dWidth << 8)&0x00FF0000) + (sBMP_Header.dWidth << 24);
       sBMP_Header.dHeight = (sBMP_Header.dHeight >> 24) + ((sBMP_Header.dHeight >> 8)&0x0000FF00) +
                                   ((sBMP_Header.dHeight << 8)&0x00FF0000) + (sBMP_Header.dHeight << 24);
       sBMP_Header.wBitCount = (sBMP_Header.wBitCount >> 8) + (sBMP_Header.wBitCount << 8);
#endif
       /* get the header -- End */

ModifyImgSection( sBMPAttr->sCoord.iY, sBMP_Header.dHeight, sBMPAttr->psImageBuffer);

       switch (sBMP_Header.wBitCount)
       {
           case 0x01:    // 2 color
           {
               if ( decode_BMP1(sBMPAttr) == _ERROR )
               {
                   Fclose(FBMP);
                   return _ERROR;
               }
               break;
           }
           case 0x08:    // 256 color
           {
               if ( decode_BMP8(sBMPAttr) == _ERROR )
               {
                   Fclose(FBMP);
                   return _ERROR;
               }
               break;
           }
           default:       // not support the mode
               break;
       }
       Fclose(FBMP);
       return _SUCCESS;
   }
   Fclose(FBMP);
   return _ERROR;
}

INT BITMAP(_BMPAttr *psBMPAttr)
{
   BYTE *pbImagePtr, bData;
   INT i, j;
   DWORD dOffset;
   _BMP_Data sBMP_Data;

   if ( (sBMP_Data.iImageWidth = psBMPAttr->iImageWidth) <= 0 )
       return _ERROR;
   if ( (sBMP_Data.iImageHeight = psBMPAttr->iImageHeight) <= 0 )
       return _ERROR;

   // ImageWidthByte
   if ( sBMP_Data.iImageWidth % 8 == 0 )
   {
       sBMP_Data.iImageWidthByte = sBMP_Data.iImageWidth / 8;
       sBMP_Data.bRemoveData = 0xFF;
   }
   else
   {
       sBMP_Data.iImageWidthByte = sBMP_Data.iImageWidth / 8 + 1;
       sBMP_Data.bRemoveData = 0xFF << (8 - sBMP_Data.iImageWidth % 8);
   }

   // UseWidth & UseWidthByte
   if ( (psBMPAttr->sCoord.iX + sBMP_Data.iImageWidth) > psBMPAttr->psImageBuffer->iWidth )
   {
       sBMP_Data.bEndFlag = 1;
       sBMP_Data.iUseWidth = psBMPAttr->psImageBuffer->iWidth - psBMPAttr->sCoord.iX;
       if ( sBMP_Data.iUseWidth <= 0 )
           return _ERROR;

       if ( (sBMP_Data.iUseWidth % 8 ) > 0 )
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8 + 1;
       else
           sBMP_Data.iUseWidthByte = sBMP_Data.iUseWidth / 8;
   }
   else
   {
       sBMP_Data.bEndFlag = 0;
       sBMP_Data.iUseWidthByte = sBMP_Data.iImageWidthByte;
   }

   // Shift Bit
//   sBMP_Data.bShiftBit = (BYTE)(psBMPAttr->sCoord.iX % 8); // ch_20220523
   sBMP_Data.bShiftBit = (BYTE)(abs(psBMPAttr->sCoord.iX) % 8); // ch_20220523
   sBMP_Data.bShiftBit1 = 8 - sBMP_Data.bShiftBit;

   // UseHeight
   if ( (psBMPAttr->sCoord.iY + sBMP_Data.iImageHeight) > psBMPAttr->psImageBuffer->iHeight )
   {
       sBMP_Data.iUseHeight = psBMPAttr->psImageBuffer->iHeight - psBMPAttr->sCoord.iY;

       if ( sBMP_Data.iUseHeight <= 0 )
           return _ERROR;
   }
   else
       sBMP_Data.iUseHeight = sBMP_Data.iImageHeight;

ModifyImgSection( psBMPAttr->sCoord.iY, sBMP_Data.iUseHeight, psBMPAttr->psImageBuffer);

// Image Offset
dOffset = (DWORD)(psBMPAttr->psImageBuffer->iByteWidth * psBMPAttr->sCoord.iY + psBMPAttr->sCoord.iX / 8);

   // Decode Data & Put Data
   sBMP_Data.bShiftData = 0;
   if ( psBMPAttr->iMode == 1 ) // OR
   {
       if ( sBMP_Data.bShiftBit == 0 )
       {
           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;
               for ( i = 0; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   *pbImagePtr |= (~ psBMPAttr->ReadByte());
                   pbImagePtr += 1;
               }

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte )
                   *pbImagePtr |= ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
               else
                   *pbImagePtr |= (~ psBMPAttr->ReadByte());

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

               dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
       else
       {
           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;
               for ( i = 0 ; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   bData = (~ psBMPAttr->ReadByte());
                   *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                   sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                   pbImagePtr += 1;
               }

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte ) // sBMP_Data.bEndFlag == 0
                   bData = ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
               else // sBMP_Data.bEndFlag == 1
                   bData = (~ psBMPAttr->ReadByte());

               *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               if ( sBMP_Data.bEndFlag != 0 )
                   *(psBMPAttr->psImageBuffer->pBuffer + dOffset + psBMPAttr->psImageBuffer->iByteWidth) |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
               pbImagePtr += 1;

if ( sBMP_Data.bEndFlag == 0 )
*pbImagePtr |= sBMP_Data.bShiftData;

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

               sBMP_Data.bShiftData = 0;
               dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
   }
   else if ( psBMPAttr->iMode == 0 )   // AND
   {
       sBMP_Data.bRemoveMaskBit = (psBMPAttr->sCoord.iX + sBMP_Data.iImageWidth) % 8;
       if ( sBMP_Data.bRemoveMaskBit == 0 )
           sBMP_Data.bRemoveMaskData = 0;
       else
           sBMP_Data.bRemoveMaskData = 0xFF >> sBMP_Data.bRemoveMaskBit;

       if ( sBMP_Data.bShiftBit == 0 )
       {
           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;
               for ( i = 0; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   *pbImagePtr = (~ psBMPAttr->ReadByte());
                   pbImagePtr += 1;
               }

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte )
               {
                   *pbImagePtr &= sBMP_Data.bRemoveMaskData;
                   *pbImagePtr |= ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
               }
               else
                   *pbImagePtr = (~ psBMPAttr->ReadByte());

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

                dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
       else
       {
           sBMP_Data.bShiftMaskData = 0xFF << sBMP_Data.bShiftBit1;
           if ( (sBMP_Data.bShiftBit + sBMP_Data.iImageWidth) <= 8 )
               sBMP_Data.bRemoveMaskData |= sBMP_Data.bShiftMaskData;

           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;

               if ( sBMP_Data.iUseWidthByte != 1 )
               {
                   bData = (~ psBMPAttr->ReadByte());
                   *pbImagePtr &= sBMP_Data.bShiftMaskData;
                   *pbImagePtr |= (bData >> sBMP_Data.bShiftBit);
                   sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                   pbImagePtr += 1;

                   for ( i = 1 ; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
                   {
                       bData = (~ psBMPAttr->ReadByte());
                       *pbImagePtr = ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                       sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                       pbImagePtr += 1;
                   }
               }
               else // sBMP_Data.iUseWidthByte == 1
                   i = 0;

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte )
               {
                   bData = ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
                   if ((sBMP_Data.bShiftBit1 >= (sBMP_Data.iImageWidth % 8)) &&
                       ((sBMP_Data.iImageWidth % 8) != 0))
                   {
                       *pbImagePtr &= sBMP_Data.bRemoveMaskData;
                       *pbImagePtr |= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                   }
                   else
                   {
                       if ( sBMP_Data.iUseWidthByte != 1 )
                           *pbImagePtr = ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                       else
                       {
                           *pbImagePtr &= sBMP_Data.bShiftMaskData;
                           *pbImagePtr |= (bData >> sBMP_Data.bShiftBit);
                       }
                       sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                       pbImagePtr += 1;

                       if ( sBMP_Data.bEndFlag == 0 )
                       {
                       *pbImagePtr &= sBMP_Data.bRemoveMaskData;
                           *pbImagePtr |= sBMP_Data.bShiftData;
                       }
                   }
               }
               else // sBMP_Data.bEndFlag == 1
               {
                   bData = (~ psBMPAttr->ReadByte());
                   *pbImagePtr &= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               }

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

               sBMP_Data.bShiftData = 0;
               dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
   }
   else if ( psBMPAttr->iMode == 2 ) // XOR
   {
       if ( sBMP_Data.bShiftBit == 0 )
       {
           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;
               for ( i = 0; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   *pbImagePtr ^= (~ psBMPAttr->ReadByte());
                   pbImagePtr += 1;
               }

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte )
                   *pbImagePtr ^= ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
               else
                   *pbImagePtr ^= (~ psBMPAttr->ReadByte());

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

               dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
       else
       {
           for ( j = 0 ; j < sBMP_Data.iUseHeight ; j++ )
           {
               pbImagePtr = psBMPAttr->psImageBuffer->pBuffer + dOffset;
               for ( i = 0 ; i < sBMP_Data.iUseWidthByte - 1 ; i++ )
               {
                   bData = (~ psBMPAttr->ReadByte());
                   *pbImagePtr ^= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
                   sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
                   pbImagePtr += 1;
               }

               i += 1;
               if ( i == sBMP_Data.iImageWidthByte ) // sBMP_Data.bEndFlag == 0
                   bData = ((~ psBMPAttr->ReadByte()) & sBMP_Data.bRemoveData);
               else // sBMP_Data.bEndFlag == 1
                   bData = (~ psBMPAttr->ReadByte());

               *pbImagePtr ^= ((bData >> sBMP_Data.bShiftBit) | sBMP_Data.bShiftData);
               sBMP_Data.bShiftData = bData << sBMP_Data.bShiftBit1;
               pbImagePtr += 1;

if ( sBMP_Data.bEndFlag == 0 )
*pbImagePtr ^= sBMP_Data.bShiftData;

for ( ; i < sBMP_Data.iImageWidthByte ; i++ )
(~ psBMPAttr->ReadByte());

               sBMP_Data.bShiftData = 0;
               dOffset += psBMPAttr->psImageBuffer->iByteWidth;
           }
       }
   }
   return _SUCCESS;
}

INT BMP_Info(_BMPAttr *psBMPAttr)
{
   BYTE *pbTemp;
   while( 1 )
   {
       if ( ( FBMP = Fopen(DRAM_DEVICE, (CHAR *)psBMPAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FBMP = Fopen(FLASH_DEVICE, (CHAR *)psBMPAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FBMP = Fopen(CARD_DEVICE, (CHAR *)psBMPAttr->pbFileName, "r") ) != _NULL ){}
       if ( FBMP == _NULL )
           break;

       /* get the header -- Start */
       pbTemp = (BYTE *)&sBMP_Header;
       if ( Fread(pbTemp, sizeof(BYTE), 2, FBMP) != 2 )
           break;
       pbTemp += 4;

#if defined(BIG_ENDIAN)
       psBMPAttr->iTotalWidth = (sBMP_Header.dWidth >> 24) + ((sBMP_Header.dWidth >> 8)&0x0000FF00) +
                                       ((sBMP_Header.dWidth << 8)&0x00FF0000) + (sBMP_Header.dWidth << 24);
       psBMPAttr->iTotalHeight = (sBMP_Header.dHeight >> 24) + ((sBMP_Header.dHeight >> 8)&0x0000FF00) +
                                       ((sBMP_Header.dHeight << 8)&0x00FF0000) + (sBMP_Header.dHeight << 24);
#elif defined(LITTLE_ENDIAN)
       psBMPAttr->iTotalWidth = sBMP_Header.dWidth;
       psBMPAttr->iTotalHeight = sBMP_Header.dHeight;
#endif
       Fclose(FBMP);
       return _SUCCESS;
   }
   Fclose(FBMP);
   return _ERROR;
}

BMP.h //////

#ifndef BMP_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define BMP_H

/* None */

#include "XImgMgr.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/

typedef struct
{
   _ImgBuf        *psImageBuffer;
   _Coord    sCoord;
   INT     iRotation;
   INT              iTotalWidth;
   INT              iTotalHeight;
   INT     iImageWidth;
   INT     iImageHeight;
   INT              iMode;
   CHAR           (*ReadByte)(VOID);       // Get Data Function
   BYTE    *pbFileName;
}_BMPAttr;

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

INT BITMAP(_BMPAttr *);
INT BMPmain(_BMPAttr *);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

ImgUtil.c //

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define IMAGEUTIL_H

#include <stdlib.h>
#include <string.h>

#include "Common.h"
#include "XGraphic.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

STATIC CONST BYTE DupleTab[256 * 2] =
{
   0x00, 0x00, 0x00, 0x03, 0x00, 0x0C, 0x00, 0x0F, 0x00, 0x30, 0x00, 0x33, 0x00, 0x3C, 0x00, 0x3F,
   0x00, 0xC0, 0x00, 0xC3, 0x00, 0xCC, 0x00, 0xCF, 0x00, 0xF0, 0x00, 0xF3, 0x00, 0xFC, 0x00, 0xFF,
   0x03, 0x00, 0x03, 0x03, 0x03, 0x0C, 0x03, 0x0F, 0x03, 0x30, 0x03, 0x33, 0x03, 0x3C, 0x03, 0x3F,
   0x03, 0xC0, 0x03, 0xC3, 0x03, 0xCC, 0x03, 0xCF, 0x03, 0xF0, 0x03, 0xF3, 0x03, 0xFC, 0x03, 0xFF,
   0x0C, 0x00, 0x0C, 0x03, 0x0C, 0x0C, 0x0C, 0x0F, 0x0C, 0x30, 0x0C, 0x33, 0x0C, 0x3C, 0x0C, 0x3F,
   0x0C, 0xC0, 0x0C, 0xC3, 0x0C, 0xCC, 0x0C, 0xCF, 0x0C, 0xF0, 0x0C, 0xF3, 0x0C, 0xFC, 0x0C, 0xFF,
   0x0F, 0x00, 0x0F, 0x03, 0x0F, 0x0C, 0x0F, 0x0F, 0x0F, 0x30, 0x0F, 0x33, 0x0F, 0x3C, 0x0F, 0x3F,
   0x0F, 0xC0, 0x0F, 0xC3, 0x0F, 0xCC, 0x0F, 0xCF, 0x0F, 0xF0, 0x0F, 0xF3, 0x0F, 0xFC, 0x0F, 0xFF,
   0x30, 0x00, 0x30, 0x03, 0x30, 0x0C, 0x30, 0x0F, 0x30, 0x30, 0x30, 0x33, 0x30, 0x3C, 0x30, 0x3F,
   0x30, 0xC0, 0x30, 0xC3, 0x30, 0xCC, 0x30, 0xCF, 0x30, 0xF0, 0x30, 0xF3, 0x30, 0xFC, 0x30, 0xFF,
   0x33, 0x00, 0x33, 0x03, 0x33, 0x0C, 0x33, 0x0F, 0x33, 0x30, 0x33, 0x33, 0x33, 0x3C, 0x33, 0x3F,
   0x33, 0xC0, 0x33, 0xC3, 0x33, 0xCC, 0x33, 0xCF, 0x33, 0xF0, 0x33, 0xF3, 0x33, 0xFC, 0x33, 0xFF,
   0x3C, 0x00, 0x3C, 0x03, 0x3C, 0x0C, 0x3C, 0x0F, 0x3C, 0x30, 0x3C, 0x33, 0x3C, 0x3C, 0x3C, 0x3F,
   0x3C, 0xC0, 0x3C, 0xC3, 0x3C, 0xCC, 0x3C, 0xCF, 0x3C, 0xF0, 0x3C, 0xF3, 0x3C, 0xFC, 0x3C, 0xFF,
   0x3F, 0x00, 0x3F, 0x03, 0x3F, 0x0C, 0x3F, 0x0F, 0x3F, 0x30, 0x3F, 0x33, 0x3F, 0x3C, 0x3F, 0x3F,
   0x3F, 0xC0, 0x3F, 0xC3, 0x3F, 0xCC, 0x3F, 0xCF, 0x3F, 0xF0, 0x3F, 0xF3, 0x3F, 0xFC, 0x3F, 0xFF,
   0xC0, 0x00, 0xC0, 0x03, 0xC0, 0x0C, 0xC0, 0x0F, 0xC0, 0x30, 0xC0, 0x33, 0xC0, 0x3C, 0xC0, 0x3F,
   0xC0, 0xC0, 0xC0, 0xC3, 0xC0, 0xCC, 0xC0, 0xCF, 0xC0, 0xF0, 0xC0, 0xF3, 0xC0, 0xFC, 0xC0, 0xFF,
   0xC3, 0x00, 0xC3, 0x03, 0xC3, 0x0C, 0xC3, 0x0F, 0xC3, 0x30, 0xC3, 0x33, 0xC3, 0x3C, 0xC3, 0x3F,
   0xC3, 0xC0, 0xC3, 0xC3, 0xC3, 0xCC, 0xC3, 0xCF, 0xC3, 0xF0, 0xC3, 0xF3, 0xC3, 0xFC, 0xC3, 0xFF,
   0xCC, 0x00, 0xCC, 0x03, 0xCC, 0x0C, 0xCC, 0x0F, 0xCC, 0x30, 0xCC, 0x33, 0xCC, 0x3C, 0xCC, 0x3F,
   0xCC, 0xC0, 0xCC, 0xC3, 0xCC, 0xCC, 0xCC, 0xCF, 0xCC, 0xF0, 0xCC, 0xF3, 0xCC, 0xFC, 0xCC, 0xFF,
   0xCF, 0x00, 0xCF, 0x03, 0xCF, 0x0C, 0xCF, 0x0F, 0xCF, 0x30, 0xCF, 0x33, 0xCF, 0x3C, 0xCF, 0x3F,
   0xCF, 0xC0, 0xCF, 0xC3, 0xCF, 0xCC, 0xCF, 0xCF, 0xCF, 0xF0, 0xCF, 0xF3, 0xCF, 0xFC, 0xCF, 0xFF,
   0xF0, 0x00, 0xF0, 0x03, 0xF0, 0x0C, 0xF0, 0x0F, 0xF0, 0x30, 0xF0, 0x33, 0xF0, 0x3C, 0xF0, 0x3F,
   0xF0, 0xC0, 0xF0, 0xC3, 0xF0, 0xCC, 0xF0, 0xCF, 0xF0, 0xF0, 0xF0, 0xF3, 0xF0, 0xFC, 0xF0, 0xFF,
   0xF3, 0x00, 0xF3, 0x03, 0xF3, 0x0C, 0xF3, 0x0F, 0xF3, 0x30, 0xF3, 0x33, 0xF3, 0x3C, 0xF3, 0x3F,
   0xF3, 0xC0, 0xF3, 0xC3, 0xF3, 0xCC, 0xF3, 0xCF, 0xF3, 0xF0, 0xF3, 0xF3, 0xF3, 0xFC, 0xF3, 0xFF,
   0xFC, 0x00, 0xFC, 0x03, 0xFC, 0x0C, 0xFC, 0x0F, 0xFC, 0x30, 0xFC, 0x33, 0xFC, 0x3C, 0xFC, 0x3F,
   0xFC, 0xC0, 0xFC, 0xC3, 0xFC, 0xCC, 0xFC, 0xCF, 0xFC, 0xF0, 0xFC, 0xF3, 0xFC, 0xFC, 0xFC, 0xFF,
   0xFF, 0x00, 0xFF, 0x03, 0xFF, 0x0C, 0xFF, 0x0F, 0xFF, 0x30, 0xFF, 0x33, 0xFF, 0x3C, 0xFF, 0x3F,
   0xFF, 0xC0, 0xFF, 0xC3, 0xFF, 0xCC, 0xFF, 0xCF, 0xFF, 0xF0, 0xFF, 0xF3, 0xFF, 0xFC, 0xFF, 0xFF,
};

STATIC CONST BYTE TripleTab[256 * 3] =
{
   0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x38,0x00,0x00,0x3F,0x00,0x01,0xC0,0x00,0x01,0xC7,0x00,0x01,0xF8,0x00,0x01,0xFF,
   0x00,0x0E,0x00,0x00,0x0E,0x07,0x00,0x0E,0x38,0x00,0x0E,0x3F,0x00,0x0F,0xC0,0x00,0x0F,0xC7,0x00,0x0F,0xF8,0x00,0x0F,0xFF,
   0x00,0x70,0x00,0x00,0x70,0x07,0x00,0x70,0x38,0x00,0x70,0x3F,0x00,0x71,0xC0,0x00,0x71,0xC7,0x00,0x71,0xF8,0x00,0x71,0xFF,
   0x00,0x7E,0x00,0x00,0x7E,0x07,0x00,0x7E,0x38,0x00,0x7E,0x3F,0x00,0x7F,0xC0,0x00,0x7F,0xC7,0x00,0x7F,0xF8,0x00,0x7F,0xFF,
   0x03,0x80,0x00,0x03,0x80,0x07,0x03,0x80,0x38,0x03,0x80,0x3F,0x03,0x81,0xC0,0x03,0x81,0xC7,0x03,0x81,0xF8,0x03,0x81,0xFF,
   0x03,0x8E,0x00,0x03,0x8E,0x07,0x03,0x8E,0x38,0x03,0x8E,0x3F,0x03,0x8F,0xC0,0x03,0x8F,0xC7,0x03,0x8F,0xF8,0x03,0x8F,0xFF,
   0x03,0xF0,0x00,0x03,0xF0,0x07,0x03,0xF0,0x38,0x03,0xF0,0x3F,0x03,0xF1,0xC0,0x03,0xF1,0xC7,0x03,0xF1,0xF8,0x03,0xF1,0xFF,
   0x03,0xFE,0x00,0x03,0xFE,0x07,0x03,0xFE,0x38,0x03,0xFE,0x3F,0x03,0xFF,0xC0,0x03,0xFF,0xC7,0x03,0xFF,0xF8,0x03,0xFF,0xFF,
   0x1C,0x00,0x00,0x1C,0x00,0x07,0x1C,0x00,0x38,0x1C,0x00,0x3F,0x1C,0x01,0xC0,0x1C,0x01,0xC7,0x1C,0x01,0xF8,0x1C,0x01,0xFF,
   0x1C,0x0E,0x00,0x1C,0x0E,0x07,0x1C,0x0E,0x38,0x1C,0x0E,0x3F,0x1C,0x0F,0xC0,0x1C,0x0F,0xC7,0x1C,0x0F,0xF8,0x1C,0x0F,0xFF,
   0x1C,0x70,0x00,0x1C,0x70,0x07,0x1C,0x70,0x38,0x1C,0x70,0x3F,0x1C,0x71,0xC0,0x1C,0x71,0xC7,0x1C,0x71,0xF8,0x1C,0x71,0xFF,
   0x1C,0x7E,0x00,0x1C,0x7E,0x07,0x1C,0x7E,0x38,0x1C,0x7E,0x3F,0x1C,0x7F,0xC0,0x1C,0x7F,0xC7,0x1C,0x7F,0xF8,0x1C,0x7F,0xFF,
   0x1F,0x80,0x00,0x1F,0x80,0x07,0x1F,0x80,0x38,0x1F,0x80,0x3F,0x1F,0x81,0xC0,0x1F,0x81,0xC7,0x1F,0x81,0xF8,0x1F,0x81,0xFF,
   0x1F,0x8E,0x00,0x1F,0x8E,0x07,0x1F,0x8E,0x38,0x1F,0x8E,0x3F,0x1F,0x8F,0xC0,0x1F,0x8F,0xC7,0x1F,0x8F,0xF8,0x1F,0x8F,0xFF,
   0x1F,0xF0,0x00,0x1F,0xF0,0x07,0x1F,0xF0,0x38,0x1F,0xF0,0x3F,0x1F,0xF1,0xC0,0x1F,0xF1,0xC7,0x1F,0xF1,0xF8,0x1F,0xF1,0xFF,
   0x1F,0xFE,0x00,0x1F,0xFE,0x07,0x1F,0xFE,0x38,0x1F,0xFE,0x3F,0x1F,0xFF,0xC0,0x1F,0xFF,0xC7,0x1F,0xFF,0xF8,0x1F,0xFF,0xFF,
   0xE0,0x00,0x00,0xE0,0x00,0x07,0xE0,0x00,0x38,0xE0,0x00,0x3F,0xE0,0x01,0xC0,0xE0,0x01,0xC7,0xE0,0x01,0xF8,0xE0,0x01,0xFF,
   0xE0,0x0E,0x00,0xE0,0x0E,0x07,0xE0,0x0E,0x38,0xE0,0x0E,0x3F,0xE0,0x0F,0xC0,0xE0,0x0F,0xC7,0xE0,0x0F,0xF8,0xE0,0x0F,0xFF,
   0xE0,0x70,0x00,0xE0,0x70,0x07,0xE0,0x70,0x38,0xE0,0x70,0x3F,0xE0,0x71,0xC0,0xE0,0x71,0xC7,0xE0,0x71,0xF8,0xE0,0x71,0xFF,
   0xE0,0x7E,0x00,0xE0,0x7E,0x07,0xE0,0x7E,0x38,0xE0,0x7E,0x3F,0xE0,0x7F,0xC0,0xE0,0x7F,0xC7,0xE0,0x7F,0xF8,0xE0,0x7F,0xFF,
   0xE3,0x80,0x00,0xE3,0x80,0x07,0xE3,0x80,0x38,0xE3,0x80,0x3F,0xE3,0x81,0xC0,0xE3,0x81,0xC7,0xE3,0x81,0xF8,0xE3,0x81,0xFF,
   0xE3,0x8E,0x00,0xE3,0x8E,0x07,0xE3,0x8E,0x38,0xE3,0x8E,0x3F,0xE3,0x8F,0xC0,0xE3,0x8F,0xC7,0xE3,0x8F,0xF8,0xE3,0x8F,0xFF,
   0xE3,0xF0,0x00,0xE3,0xF0,0x07,0xE3,0xF0,0x38,0xE3,0xF0,0x3F,0xE3,0xF1,0xC0,0xE3,0xF1,0xC7,0xE3,0xF1,0xF8,0xE3,0xF1,0xFF,
   0xE3,0xFE,0x00,0xE3,0xFE,0x07,0xE3,0xFE,0x38,0xE3,0xFE,0x3F,0xE3,0xFF,0xC0,0xE3,0xFF,0xC7,0xE3,0xFF,0xF8,0xE3,0xFF,0xFF,
   0xFC,0x00,0x00,0xFC,0x00,0x07,0xFC,0x00,0x38,0xFC,0x00,0x3F,0xFC,0x01,0xC0,0xFC,0x01,0xC7,0xFC,0x01,0xF8,0xFC,0x01,0xFF,
   0xFC,0x0E,0x00,0xFC,0x0E,0x07,0xFC,0x0E,0x38,0xFC,0x0E,0x3F,0xFC,0x0F,0xC0,0xFC,0x0F,0xC7,0xFC,0x0F,0xF8,0xFC,0x0F,0xFF,
   0xFC,0x70,0x00,0xFC,0x70,0x07,0xFC,0x70,0x38,0xFC,0x70,0x3F,0xFC,0x71,0xC0,0xFC,0x71,0xC7,0xFC,0x71,0xF8,0xFC,0x71,0xFF,
   0xFC,0x7E,0x00,0xFC,0x7E,0x07,0xFC,0x7E,0x38,0xFC,0x7E,0x3F,0xFC,0x7F,0xC0,0xFC,0x7F,0xC7,0xFC,0x7F,0xF8,0xFC,0x7F,0xFF,
   0xFF,0x80,0x00,0xFF,0x80,0x07,0xFF,0x80,0x38,0xFF,0x80,0x3F,0xFF,0x81,0xC0,0xFF,0x81,0xC7,0xFF,0x81,0xF8,0xFF,0x81,0xFF,
   0xFF,0x8E,0x00,0xFF,0x8E,0x07,0xFF,0x8E,0x38,0xFF,0x8E,0x3F,0xFF,0x8F,0xC0,0xFF,0x8F,0xC7,0xFF,0x8F,0xF8,0xFF,0x8F,0xFF,
   0xFF,0xF0,0x00,0xFF,0xF0,0x07,0xFF,0xF0,0x38,0xFF,0xF0,0x3F,0xFF,0xF1,0xC0,0xFF,0xF1,0xC7,0xFF,0xF1,0xF8,0xFF,0xF1,0xFF,
   0xFF,0xFE,0x00,0xFF,0xFE,0x07,0xFF,0xFE,0x38,0xFF,0xFE,0x3F,0xFF,0xFF,0xC0,0xFF,0xFF,0xC7,0xFF,0xFF,0xF8,0xFF,0xFF,0xFF,
};

STATIC CONST BYTE QuintupleTab[256 * 5] =
{
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x03,0xE0,0x00,0x00,0x00,0x03,0xFF,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0x00,0x7C,0x1F,0x00,0x00,0x00,0x7F,0xE0,0x00,0x00,0x00,0x7F,0xFF,
   0x00,0x00,0x0F,0x80,0x00,0x00,0x00,0x0F,0x80,0x1F,0x00,0x00,0x0F,0x83,0xE0,0x00,0x00,0x0F,0x83,0xFF,0x00,0x00,0x0F,0xFC,0x00,0x00,0x00,0x0F,0xFC,0x1F,0x00,0x00,0x0F,0xFF,0xE0,0x00,0x00,0x0F,0xFF,0xFF,
   0x00,0x01,0xF0,0x00,0x00,0x00,0x01,0xF0,0x00,0x1F,0x00,0x01,0xF0,0x03,0xE0,0x00,0x01,0xF0,0x03,0xFF,0x00,0x01,0xF0,0x7C,0x00,0x00,0x01,0xF0,0x7C,0x1F,0x00,0x01,0xF0,0x7F,0xE0,0x00,0x01,0xF0,0x7F,0xFF,
   0x00,0x01,0xFF,0x80,0x00,0x00,0x01,0xFF,0x80,0x1F,0x00,0x01,0xFF,0x83,0xE0,0x00,0x01,0xFF,0x83,0xFF,0x00,0x01,0xFF,0xFC,0x00,0x00,0x01,0xFF,0xFC,0x1F,0x00,0x01,0xFF,0xFF,0xE0,0x00,0x01,0xFF,0xFF,0xFF,
   0x00,0x3E,0x00,0x00,0x00,0x00,0x3E,0x00,0x00,0x1F,0x00,0x3E,0x00,0x03,0xE0,0x00,0x3E,0x00,0x03,0xFF,0x00,0x3E,0x00,0x7C,0x00,0x00,0x3E,0x00,0x7C,0x1F,0x00,0x3E,0x00,0x7F,0xE0,0x00,0x3E,0x00,0x7F,0xFF,
   0x00,0x3E,0x0F,0x80,0x00,0x00,0x3E,0x0F,0x80,0x1F,0x00,0x3E,0x0F,0x83,0xE0,0x00,0x3E,0x0F,0x83,0xFF,0x00,0x3E,0x0F,0xFC,0x00,0x00,0x3E,0x0F,0xFC,0x1F,0x00,0x3E,0x0F,0xFF,0xE0,0x00,0x3E,0x0F,0xFF,0xFF,
   0x00,0x3F,0xF0,0x00,0x00,0x00,0x3F,0xF0,0x00,0x1F,0x00,0x3F,0xF0,0x03,0xE0,0x00,0x3F,0xF0,0x03,0xFF,0x00,0x3F,0xF0,0x7C,0x00,0x00,0x3F,0xF0,0x7C,0x1F,0x00,0x3F,0xF0,0x7F,0xE0,0x00,0x3F,0xF0,0x7F,0xFF,
   0x00,0x3F,0xFF,0x80,0x00,0x00,0x3F,0xFF,0x80,0x1F,0x00,0x3F,0xFF,0x83,0xE0,0x00,0x3F,0xFF,0x83,0xFF,0x00,0x3F,0xFF,0xFC,0x00,0x00,0x3F,0xFF,0xFC,0x1F,0x00,0x3F,0xFF,0xFF,0xE0,0x00,0x3F,0xFF,0xFF,0xFF,
   0x07,0xC0,0x00,0x00,0x00,0x07,0xC0,0x00,0x00,0x1F,0x07,0xC0,0x00,0x03,0xE0,0x07,0xC0,0x00,0x03,0xFF,0x07,0xC0,0x00,0x7C,0x00,0x07,0xC0,0x00,0x7C,0x1F,0x07,0xC0,0x00,0x7F,0xE0,0x07,0xC0,0x00,0x7F,0xFF,
   0x07,0xC0,0x0F,0x80,0x00,0x07,0xC0,0x0F,0x80,0x1F,0x07,0xC0,0x0F,0x83,0xE0,0x07,0xC0,0x0F,0x83,0xFF,0x07,0xC0,0x0F,0xFC,0x00,0x07,0xC0,0x0F,0xFC,0x1F,0x07,0xC0,0x0F,0xFF,0xE0,0x07,0xC0,0x0F,0xFF,0xFF,
   0x07,0xC1,0xF0,0x00,0x00,0x07,0xC1,0xF0,0x00,0x1F,0x07,0xC1,0xF0,0x03,0xE0,0x07,0xC1,0xF0,0x03,0xFF,0x07,0xC1,0xF0,0x7C,0x00,0x07,0xC1,0xF0,0x7C,0x1F,0x07,0xC1,0xF0,0x7F,0xE0,0x07,0xC1,0xF0,0x7F,0xFF,
   0x07,0xC1,0xFF,0x80,0x00,0x07,0xC1,0xFF,0x80,0x1F,0x07,0xC1,0xFF,0x83,0xE0,0x07,0xC1,0xFF,0x83,0xFF,0x07,0xC1,0xFF,0xFC,0x00,0x07,0xC1,0xFF,0xFC,0x1F,0x07,0xC1,0xFF,0xFF,0xE0,0x07,0xC1,0xFF,0xFF,0xFF,
   0x07,0xFE,0x00,0x00,0x00,0x07,0xFE,0x00,0x00,0x1F,0x07,0xFE,0x00,0x03,0xE0,0x07,0xFE,0x00,0x03,0xFF,0x07,0xFE,0x00,0x7C,0x00,0x07,0xFE,0x00,0x7C,0x1F,0x07,0xFE,0x00,0x7F,0xE0,0x07,0xFE,0x00,0x7F,0xFF,
   0x07,0xFE,0x0F,0x80,0x00,0x07,0xFE,0x0F,0x80,0x1F,0x07,0xFE,0x0F,0x83,0xE0,0x07,0xFE,0x0F,0x83,0xFF,0x07,0xFE,0x0F,0xFC,0x00,0x07,0xFE,0x0F,0xFC,0x1F,0x07,0xFE,0x0F,0xFF,0xE0,0x07,0xFE,0x0F,0xFF,0xFF,
   0x07,0xFF,0xF0,0x00,0x00,0x07,0xFF,0xF0,0x00,0x1F,0x07,0xFF,0xF0,0x03,0xE0,0x07,0xFF,0xF0,0x03,0xFF,0x07,0xFF,0xF0,0x7C,0x00,0x07,0xFF,0xF0,0x7C,0x1F,0x07,0xFF,0xF0,0x7F,0xE0,0x07,0xFF,0xF0,0x7F,0xFF,
   0x07,0xFF,0xFF,0x80,0x00,0x07,0xFF,0xFF,0x80,0x1F,0x07,0xFF,0xFF,0x83,0xE0,0x07,0xFF,0xFF,0x83,0xFF,0x07,0xFF,0xFF,0xFC,0x00,0x07,0xFF,0xFF,0xFC,0x1F,0x07,0xFF,0xFF,0xFF,0xE0,0x07,0xFF,0xFF,0xFF,0xFF,
   0xF8,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x1F,0xF8,0x00,0x00,0x03,0xE0,0xF8,0x00,0x00,0x03,0xFF,0xF8,0x00,0x00,0x7C,0x00,0xF8,0x00,0x00,0x7C,0x1F,0xF8,0x00,0x00,0x7F,0xE0,0xF8,0x00,0x00,0x7F,0xFF,
   0xF8,0x00,0x0F,0x80,0x00,0xF8,0x00,0x0F,0x80,0x1F,0xF8,0x00,0x0F,0x83,0xE0,0xF8,0x00,0x0F,0x83,0xFF,0xF8,0x00,0x0F,0xFC,0x00,0xF8,0x00,0x0F,0xFC,0x1F,0xF8,0x00,0x0F,0xFF,0xE0,0xF8,0x00,0x0F,0xFF,0xFF,
   0xF8,0x01,0xF0,0x00,0x00,0xF8,0x01,0xF0,0x00,0x1F,0xF8,0x01,0xF0,0x03,0xE0,0xF8,0x01,0xF0,0x03,0xFF,0xF8,0x01,0xF0,0x7C,0x00,0xF8,0x01,0xF0,0x7C,0x1F,0xF8,0x01,0xF0,0x7F,0xE0,0xF8,0x01,0xF0,0x7F,0xFF,
   0xF8,0x01,0xFF,0x80,0x00,0xF8,0x01,0xFF,0x80,0x1F,0xF8,0x01,0xFF,0x83,0xE0,0xF8,0x01,0xFF,0x83,0xFF,0xF8,0x01,0xFF,0xFC,0x00,0xF8,0x01,0xFF,0xFC,0x1F,0xF8,0x01,0xFF,0xFF,0xE0,0xF8,0x01,0xFF,0xFF,0xFF,
   0xF8,0x3E,0x00,0x00,0x00,0xF8,0x3E,0x00,0x00,0x1F,0xF8,0x3E,0x00,0x03,0xE0,0xF8,0x3E,0x00,0x03,0xFF,0xF8,0x3E,0x00,0x7C,0x00,0xF8,0x3E,0x00,0x7C,0x1F,0xF8,0x3E,0x00,0x7F,0xE0,0xF8,0x3E,0x00,0x7F,0xFF,
   0xF8,0x3E,0x0F,0x80,0x00,0xF8,0x3E,0x0F,0x80,0x1F,0xF8,0x3E,0x0F,0x83,0xE0,0xF8,0x3E,0x0F,0x83,0xFF,0xF8,0x3E,0x0F,0xFC,0x00,0xF8,0x3E,0x0F,0xFC,0x1F,0xF8,0x3E,0x0F,0xFF,0xE0,0xF8,0x3E,0x0F,0xFF,0xFF,
   0xF8,0x3F,0xF0,0x00,0x00,0xF8,0x3F,0xF0,0x00,0x1F,0xF8,0x3F,0xF0,0x03,0xE0,0xF8,0x3F,0xF0,0x03,0xFF,0xF8,0x3F,0xF0,0x7C,0x00,0xF8,0x3F,0xF0,0x7C,0x1F,0xF8,0x3F,0xF0,0x7F,0xE0,0xF8,0x3F,0xF0,0x7F,0xFF,
   0xF8,0x3F,0xFF,0x80,0x00,0xF8,0x3F,0xFF,0x80,0x1F,0xF8,0x3F,0xFF,0x83,0xE0,0xF8,0x3F,0xFF,0x83,0xFF,0xF8,0x3F,0xFF,0xFC,0x00,0xF8,0x3F,0xFF,0xFC,0x1F,0xF8,0x3F,0xFF,0xFF,0xE0,0xF8,0x3F,0xFF,0xFF,0xFF,
   0xFF,0xC0,0x00,0x00,0x00,0xFF,0xC0,0x00,0x00,0x1F,0xFF,0xC0,0x00,0x03,0xE0,0xFF,0xC0,0x00,0x03,0xFF,0xFF,0xC0,0x00,0x7C,0x00,0xFF,0xC0,0x00,0x7C,0x1F,0xFF,0xC0,0x00,0x7F,0xE0,0xFF,0xC0,0x00,0x7F,0xFF,
   0xFF,0xC0,0x0F,0x80,0x00,0xFF,0xC0,0x0F,0x80,0x1F,0xFF,0xC0,0x0F,0x83,0xE0,0xFF,0xC0,0x0F,0x83,0xFF,0xFF,0xC0,0x0F,0xFC,0x00,0xFF,0xC0,0x0F,0xFC,0x1F,0xFF,0xC0,0x0F,0xFF,0xE0,0xFF,0xC0,0x0F,0xFF,0xFF,
   0xFF,0xC1,0xF0,0x00,0x00,0xFF,0xC1,0xF0,0x00,0x1F,0xFF,0xC1,0xF0,0x03,0xE0,0xFF,0xC1,0xF0,0x03,0xFF,0xFF,0xC1,0xF0,0x7C,0x00,0xFF,0xC1,0xF0,0x7C,0x1F,0xFF,0xC1,0xF0,0x7F,0xE0,0xFF,0xC1,0xF0,0x7F,0xFF,
   0xFF,0xC1,0xFF,0x80,0x00,0xFF,0xC1,0xFF,0x80,0x1F,0xFF,0xC1,0xFF,0x83,0xE0,0xFF,0xC1,0xFF,0x83,0xFF,0xFF,0xC1,0xFF,0xFC,0x00,0xFF,0xC1,0xFF,0xFC,0x1F,0xFF,0xC1,0xFF,0xFF,0xE0,0xFF,0xC1,0xFF,0xFF,0xFF,
   0xFF,0xFE,0x00,0x00,0x00,0xFF,0xFE,0x00,0x00,0x1F,0xFF,0xFE,0x00,0x03,0xE0,0xFF,0xFE,0x00,0x03,0xFF,0xFF,0xFE,0x00,0x7C,0x00,0xFF,0xFE,0x00,0x7C,0x1F,0xFF,0xFE,0x00,0x7F,0xE0,0xFF,0xFE,0x00,0x7F,0xFF,
   0xFF,0xFE,0x0F,0x80,0x00,0xFF,0xFE,0x0F,0x80,0x1F,0xFF,0xFE,0x0F,0x83,0xE0,0xFF,0xFE,0x0F,0x83,0xFF,0xFF,0xFE,0x0F,0xFC,0x00,0xFF,0xFE,0x0F,0xFC,0x1F,0xFF,0xFE,0x0F,0xFF,0xE0,0xFF,0xFE,0x0F,0xFF,0xFF,
   0xFF,0xFF,0xF0,0x00,0x00,0xFF,0xFF,0xF0,0x00,0x1F,0xFF,0xFF,0xF0,0x03,0xE0,0xFF,0xFF,0xF0,0x03,0xFF,0xFF,0xFF,0xF0,0x7C,0x00,0xFF,0xFF,0xF0,0x7C,0x1F,0xFF,0xFF,0xF0,0x7F,0xE0,0xFF,0xFF,0xF0,0x7F,0xFF,
   0xFF,0xFF,0xFF,0x80,0x00,0xFF,0xFF,0xFF,0x80,0x1F,0xFF,0xFF,0xFF,0x83,0xE0,0xFF,0xFF,0xFF,0x83,0xFF,0xFF,0xFF,0xFF,0xFC,0x00,0xFF,0xFF,0xFF,0xFC,0x1F,0xFF,0xFF,0xFF,0xFF,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,
};

STATIC CONST BYTE SeptupleTab[256 * 7] =
{
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00,0x3F,0x80,0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,
   0x00,0x00,0x00,0x00,0x1F,0xC0,0x00,0x00,0x00,0x00,0x00,0x1F,0xC0,0x7F,0x00,0x00,0x00,0x00,0x1F,0xFF,0x80,0x00,0x00,0x00,0x00,0x1F,0xFF,0xFF,
   0x00,0x00,0x00,0x0F,0xE0,0x00,0x00,0x00,0x00,0x00,0x0F,0xE0,0x00,0x7F,0x00,0x00,0x00,0x0F,0xE0,0x3F,0x80,0x00,0x00,0x00,0x0F,0xE0,0x3F,0xFF,
   0x00,0x00,0x00,0x0F,0xFF,0xC0,0x00,0x00,0x00,0x00,0x0F,0xFF,0xC0,0x7F,0x00,0x00,0x00,0x0F,0xFF,0xFF,0x80,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xFF,
   0x00,0x00,0x07,0xF0,0x00,0x00,0x00,0x00,0x00,0x07,0xF0,0x00,0x00,0x7F,0x00,0x00,0x07,0xF0,0x00,0x3F,0x80,0x00,0x00,0x07,0xF0,0x00,0x3F,0xFF,
   0x00,0x00,0x07,0xF0,0x1F,0xC0,0x00,0x00,0x00,0x07,0xF0,0x1F,0xC0,0x7F,0x00,0x00,0x07,0xF0,0x1F,0xFF,0x80,0x00,0x00,0x07,0xF0,0x1F,0xFF,0xFF,
   0x00,0x00,0x07,0xFF,0xE0,0x00,0x00,0x00,0x00,0x07,0xFF,0xE0,0x00,0x7F,0x00,0x00,0x07,0xFF,0xE0,0x3F,0x80,0x00,0x00,0x07,0xFF,0xE0,0x3F,0xFF,
   0x00,0x00,0x07,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x07,0xFF,0xFF,0xC0,0x7F,0x00,0x00,0x07,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x07,0xFF,0xFF,0xFF,0xFF,
   0x00,0x03,0xF8,0x00,0x00,0x00,0x00,0x00,0x03,0xF8,0x00,0x00,0x00,0x7F,0x00,0x03,0xF8,0x00,0x00,0x3F,0x80,0x00,0x03,0xF8,0x00,0x00,0x3F,0xFF,
   0x00,0x03,0xF8,0x00,0x1F,0xC0,0x00,0x00,0x03,0xF8,0x00,0x1F,0xC0,0x7F,0x00,0x03,0xF8,0x00,0x1F,0xFF,0x80,0x00,0x03,0xF8,0x00,0x1F,0xFF,0xFF,
   0x00,0x03,0xF8,0x0F,0xE0,0x00,0x00,0x00,0x03,0xF8,0x0F,0xE0,0x00,0x7F,0x00,0x03,0xF8,0x0F,0xE0,0x3F,0x80,0x00,0x03,0xF8,0x0F,0xE0,0x3F,0xFF,
   0x00,0x03,0xF8,0x0F,0xFF,0xC0,0x00,0x00,0x03,0xF8,0x0F,0xFF,0xC0,0x7F,0x00,0x03,0xF8,0x0F,0xFF,0xFF,0x80,0x00,0x03,0xF8,0x0F,0xFF,0xFF,0xFF,
   0x00,0x03,0xFF,0xF0,0x00,0x00,0x00,0x00,0x03,0xFF,0xF0,0x00,0x00,0x7F,0x00,0x03,0xFF,0xF0,0x00,0x3F,0x80,0x00,0x03,0xFF,0xF0,0x00,0x3F,0xFF,
   0x00,0x03,0xFF,0xF0,0x1F,0xC0,0x00,0x00,0x03,0xFF,0xF0,0x1F,0xC0,0x7F,0x00,0x03,0xFF,0xF0,0x1F,0xFF,0x80,0x00,0x03,0xFF,0xF0,0x1F,0xFF,0xFF,
   0x00,0x03,0xFF,0xFF,0xE0,0x00,0x00,0x00,0x03,0xFF,0xFF,0xE0,0x00,0x7F,0x00,0x03,0xFF,0xFF,0xE0,0x3F,0x80,0x00,0x03,0xFF,0xFF,0xE0,0x3F,0xFF,
   0x00,0x03,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x03,0xFF,0xFF,0xFF,0xC0,0x7F,0x00,0x03,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x03,0xFF,0xFF,0xFF,0xFF,0xFF,
   0x01,0xFC,0x00,0x00,0x00,0x00,0x00,0x01,0xFC,0x00,0x00,0x00,0x00,0x7F,0x01,0xFC,0x00,0x00,0x00,0x3F,0x80,0x01,0xFC,0x00,0x00,0x00,0x3F,0xFF,
   0x01,0xFC,0x00,0x00,0x1F,0xC0,0x00,0x01,0xFC,0x00,0x00,0x1F,0xC0,0x7F,0x01,0xFC,0x00,0x00,0x1F,0xFF,0x80,0x01,0xFC,0x00,0x00,0x1F,0xFF,0xFF,
   0x01,0xFC,0x00,0x0F,0xE0,0x00,0x00,0x01,0xFC,0x00,0x0F,0xE0,0x00,0x7F,0x01,0xFC,0x00,0x0F,0xE0,0x3F,0x80,0x01,0xFC,0x00,0x0F,0xE0,0x3F,0xFF,
   0x01,0xFC,0x00,0x0F,0xFF,0xC0,0x00,0x01,0xFC,0x00,0x0F,0xFF,0xC0,0x7F,0x01,0xFC,0x00,0x0F,0xFF,0xFF,0x80,0x01,0xFC,0x00,0x0F,0xFF,0xFF,0xFF,
   0x01,0xFC,0x07,0xF0,0x00,0x00,0x00,0x01,0xFC,0x07,0xF0,0x00,0x00,0x7F,0x01,0xFC,0x07,0xF0,0x00,0x3F,0x80,0x01,0xFC,0x07,0xF0,0x00,0x3F,0xFF,
   0x01,0xFC,0x07,0xF0,0x1F,0xC0,0x00,0x01,0xFC,0x07,0xF0,0x1F,0xC0,0x7F,0x01,0xFC,0x07,0xF0,0x1F,0xFF,0x80,0x01,0xFC,0x07,0xF0,0x1F,0xFF,0xFF,
   0x01,0xFC,0x07,0xFF,0xE0,0x00,0x00,0x01,0xFC,0x07,0xFF,0xE0,0x00,0x7F,0x01,0xFC,0x07,0xFF,0xE0,0x3F,0x80,0x01,0xFC,0x07,0xFF,0xE0,0x3F,0xFF,
   0x01,0xFC,0x07,0xFF,0xFF,0xC0,0x00,0x01,0xFC,0x07,0xFF,0xFF,0xC0,0x7F,0x01,0xFC,0x07,0xFF,0xFF,0xFF,0x80,0x01,0xFC,0x07,0xFF,0xFF,0xFF,0xFF,
   0x01,0xFF,0xF8,0x00,0x00,0x00,0x00,0x01,0xFF,0xF8,0x00,0x00,0x00,0x7F,0x01,0xFF,0xF8,0x00,0x00,0x3F,0x80,0x01,0xFF,0xF8,0x00,0x00,0x3F,0xFF,
   0x01,0xFF,0xF8,0x00,0x1F,0xC0,0x00,0x01,0xFF,0xF8,0x00,0x1F,0xC0,0x7F,0x01,0xFF,0xF8,0x00,0x1F,0xFF,0x80,0x01,0xFF,0xF8,0x00,0x1F,0xFF,0xFF,
   0x01,0xFF,0xF8,0x0F,0xE0,0x00,0x00,0x01,0xFF,0xF8,0x0F,0xE0,0x00,0x7F,0x01,0xFF,0xF8,0x0F,0xE0,0x3F,0x80,0x01,0xFF,0xF8,0x0F,0xE0,0x3F,0xFF,
   0x01,0xFF,0xF8,0x0F,0xFF,0xC0,0x00,0x01,0xFF,0xF8,0x0F,0xFF,0xC0,0x7F,0x01,0xFF,0xF8,0x0F,0xFF,0xFF,0x80,0x01,0xFF,0xF8,0x0F,0xFF,0xFF,0xFF,
   0x01,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x01,0xFF,0xFF,0xF0,0x00,0x00,0x7F,0x01,0xFF,0xFF,0xF0,0x00,0x3F,0x80,0x01,0xFF,0xFF,0xF0,0x00,0x3F,0xFF,
   0x01,0xFF,0xFF,0xF0,0x1F,0xC0,0x00,0x01,0xFF,0xFF,0xF0,0x1F,0xC0,0x7F,0x01,0xFF,0xFF,0xF0,0x1F,0xFF,0x80,0x01,0xFF,0xFF,0xF0,0x1F,0xFF,0xFF,
   0x01,0xFF,0xFF,0xFF,0xE0,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xE0,0x00,0x7F,0x01,0xFF,0xFF,0xFF,0xE0,0x3F,0x80,0x01,0xFF,0xFF,0xFF,0xE0,0x3F,0xFF,
   0x01,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xC0,0x7F,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
   0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0x00,0x00,0x7F,0xFE,0x00,0x00,0x00,0x00,0x3F,0x80,0xFE,0x00,0x00,0x00,0x00,0x3F,0xFF,
   0xFE,0x00,0x00,0x00,0x1F,0xC0,0x00,0xFE,0x00,0x00,0x00,0x1F,0xC0,0x7F,0xFE,0x00,0x00,0x00,0x1F,0xFF,0x80,0xFE,0x00,0x00,0x00,0x1F,0xFF,0xFF,
   0xFE,0x00,0x00,0x0F,0xE0,0x00,0x00,0xFE,0x00,0x00,0x0F,0xE0,0x00,0x7F,0xFE,0x00,0x00,0x0F,0xE0,0x3F,0x80,0xFE,0x00,0x00,0x0F,0xE0,0x3F,0xFF,
   0xFE,0x00,0x00,0x0F,0xFF,0xC0,0x00,0xFE,0x00,0x00,0x0F,0xFF,0xC0,0x7F,0xFE,0x00,0x00,0x0F,0xFF,0xFF,0x80,0xFE,0x00,0x00,0x0F,0xFF,0xFF,0xFF,
   0xFE,0x00,0x07,0xF0,0x00,0x00,0x00,0xFE,0x00,0x07,0xF0,0x00,0x00,0x7F,0xFE,0x00,0x07,0xF0,0x00,0x3F,0x80,0xFE,0x00,0x07,0xF0,0x00,0x3F,0xFF,
   0xFE,0x00,0x07,0xF0,0x1F,0xC0,0x00,0xFE,0x00,0x07,0xF0,0x1F,0xC0,0x7F,0xFE,0x00,0x07,0xF0,0x1F,0xFF,0x80,0xFE,0x00,0x07,0xF0,0x1F,0xFF,0xFF,
   0xFE,0x00,0x07,0xFF,0xE0,0x00,0x00,0xFE,0x00,0x07,0xFF,0xE0,0x00,0x7F,0xFE,0x00,0x07,0xFF,0xE0,0x3F,0x80,0xFE,0x00,0x07,0xFF,0xE0,0x3F,0xFF,
   0xFE,0x00,0x07,0xFF,0xFF,0xC0,0x00,0xFE,0x00,0x07,0xFF,0xFF,0xC0,0x7F,0xFE,0x00,0x07,0xFF,0xFF,0xFF,0x80,0xFE,0x00,0x07,0xFF,0xFF,0xFF,0xFF,
   0xFE,0x03,0xF8,0x00,0x00,0x00,0x00,0xFE,0x03,0xF8,0x00,0x00,0x00,0x7F,0xFE,0x03,0xF8,0x00,0x00,0x3F,0x80,0xFE,0x03,0xF8,0x00,0x00,0x3F,0xFF,
   0xFE,0x03,0xF8,0x00,0x1F,0xC0,0x00,0xFE,0x03,0xF8,0x00,0x1F,0xC0,0x7F,0xFE,0x03,0xF8,0x00,0x1F,0xFF,0x80,0xFE,0x03,0xF8,0x00,0x1F,0xFF,0xFF,
   0xFE,0x03,0xF8,0x0F,0xE0,0x00,0x00,0xFE,0x03,0xF8,0x0F,0xE0,0x00,0x7F,0xFE,0x03,0xF8,0x0F,0xE0,0x3F,0x80,0xFE,0x03,0xF8,0x0F,0xE0,0x3F,0xFF,
   0xFE,0x03,0xF8,0x0F,0xFF,0xC0,0x00,0xFE,0x03,0xF8,0x0F,0xFF,0xC0,0x7F,0xFE,0x03,0xF8,0x0F,0xFF,0xFF,0x80,0xFE,0x03,0xF8,0x0F,0xFF,0xFF,0xFF,
   0xFE,0x03,0xFF,0xF0,0x00,0x00,0x00,0xFE,0x03,0xFF,0xF0,0x00,0x00,0x7F,0xFE,0x03,0xFF,0xF0,0x00,0x3F,0x80,0xFE,0x03,0xFF,0xF0,0x00,0x3F,0xFF,
   0xFE,0x03,0xFF,0xF0,0x1F,0xC0,0x00,0xFE,0x03,0xFF,0xF0,0x1F,0xC0,0x7F,0xFE,0x03,0xFF,0xF0,0x1F,0xFF,0x80,0xFE,0x03,0xFF,0xF0,0x1F,0xFF,0xFF,
   0xFE,0x03,0xFF,0xFF,0xE0,0x00,0x00,0xFE,0x03,0xFF,0xFF,0xE0,0x00,0x7F,0xFE,0x03,0xFF,0xFF,0xE0,0x3F,0x80,0xFE,0x03,0xFF,0xFF,0xE0,0x3F,0xFF,
   0xFE,0x03,0xFF,0xFF,0xFF,0xC0,0x00,0xFE,0x03,0xFF,0xFF,0xFF,0xC0,0x7F,0xFE,0x03,0xFF,0xFF,0xFF,0xFF,0x80,0xFE,0x03,0xFF,0xFF,0xFF,0xFF,0xFF,
   0xFF,0xFC,0x00,0x00,0x00,0x00,0x00,0xFF,0xFC,0x00,0x00,0x00,0x00,0x7F,0xFF,0xFC,0x00,0x00,0x00,0x3F,0x80,0xFF,0xFC,0x00,0x00,0x00,0x3F,0xFF,
   0xFF,0xFC,0x00,0x00,0x1F,0xC0,0x00,0xFF,0xFC,0x00,0x00,0x1F,0xC0,0x7F,0xFF,0xFC,0x00,0x00,0x1F,0xFF,0x80,0xFF,0xFC,0x00,0x00,0x1F,0xFF,0xFF,
   0xFF,0xFC,0x00,0x0F,0xE0,0x00,0x00,0xFF,0xFC,0x00,0x0F,0xE0,0x00,0x7F,0xFF,0xFC,0x00,0x0F,0xE0,0x3F,0x80,0xFF,0xFC,0x00,0x0F,0xE0,0x3F,0xFF,
   0xFF,0xFC,0x00,0x0F,0xFF,0xC0,0x00,0xFF,0xFC,0x00,0x0F,0xFF,0xC0,0x7F,0xFF,0xFC,0x00,0x0F,0xFF,0xFF,0x80,0xFF,0xFC,0x00,0x0F,0xFF,0xFF,0xFF,
   0xFF,0xFC,0x07,0xF0,0x00,0x00,0x00,0xFF,0xFC,0x07,0xF0,0x00,0x00,0x7F,0xFF,0xFC,0x07,0xF0,0x00,0x3F,0x80,0xFF,0xFC,0x07,0xF0,0x00,0x3F,0xFF,
   0xFF,0xFC,0x07,0xF0,0x1F,0xC0,0x00,0xFF,0xFC,0x07,0xF0,0x1F,0xC0,0x7F,0xFF,0xFC,0x07,0xF0,0x1F,0xFF,0x80,0xFF,0xFC,0x07,0xF0,0x1F,0xFF,0xFF,
   0xFF,0xFC,0x07,0xFF,0xE0,0x00,0x00,0xFF,0xFC,0x07,0xFF,0xE0,0x00,0x7F,0xFF,0xFC,0x07,0xFF,0xE0,0x3F,0x80,0xFF,0xFC,0x07,0xFF,0xE0,0x3F,0xFF,
   0xFF,0xFC,0x07,0xFF,0xFF,0xC0,0x00,0xFF,0xFC,0x07,0xFF,0xFF,0xC0,0x7F,0xFF,0xFC,0x07,0xFF,0xFF,0xFF,0x80,0xFF,0xFC,0x07,0xFF,0xFF,0xFF,0xFF,
   0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xF8,0x00,0x00,0x3F,0x80,0xFF,0xFF,0xF8,0x00,0x00,0x3F,0xFF,
   0xFF,0xFF,0xF8,0x00,0x1F,0xC0,0x00,0xFF,0xFF,0xF8,0x00,0x1F,0xC0,0x7F,0xFF,0xFF,0xF8,0x00,0x1F,0xFF,0x80,0xFF,0xFF,0xF8,0x00,0x1F,0xFF,0xFF,
   0xFF,0xFF,0xF8,0x0F,0xE0,0x00,0x00,0xFF,0xFF,0xF8,0x0F,0xE0,0x00,0x7F,0xFF,0xFF,0xF8,0x0F,0xE0,0x3F,0x80,0xFF,0xFF,0xF8,0x0F,0xE0,0x3F,0xFF,
   0xFF,0xFF,0xF8,0x0F,0xFF,0xC0,0x00,0xFF,0xFF,0xF8,0x0F,0xFF,0xC0,0x7F,0xFF,0xFF,0xF8,0x0F,0xFF,0xFF,0x80,0xFF,0xFF,0xF8,0x0F,0xFF,0xFF,0xFF,
   0xFF,0xFF,0xFF,0xF0,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xF0,0x00,0x00,0x7F,0xFF,0xFF,0xFF,0xF0,0x00,0x3F,0x80,0xFF,0xFF,0xFF,0xF0,0x00,0x3F,0xFF,
   0xFF,0xFF,0xFF,0xF0,0x1F,0xC0,0x00,0xFF,0xFF,0xFF,0xF0,0x1F,0xC0,0x7F,0xFF,0xFF,0xFF,0xF0,0x1F,0xFF,0x80,0xFF,0xFF,0xFF,0xF0,0x1F,0xFF,0xFF,
   0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xE0,0x3F,0x80,0xFF,0xFF,0xFF,0xFF,0xE0,0x3F,0xFF,
   0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
};

STATIC CONST BYTE MaskDataR[9] = { 0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00 };
STATIC CONST BYTE MaskDataL[9] = { 0x00,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00 };

STATIC CONST BYTE InvertData[256] =
{
   0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
   0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
   0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
   0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
   0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
   0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
   0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
   0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
   0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
   0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
   0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
   0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
   0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
   0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
   0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
   0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF
};

/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
INT LineMultiple(BYTE *Source, BYTE *Target, INT XDots, INT XMul, INT YMul, INT Delta)
{
   BYTE Buffer[10], Buffer2[10];
   BYTE *TempPtr;
   INT XLength, Len;
   INT i, j;

Len = (XDots + 7) / 8;

   TempPtr = Target;
   switch (XMul)
   {
       case 1:
           memcpy(Target, Source, Len);
           break;
       case 2:
           for (i = 0; i < Len; i++)
           {
               memcpy(TempPtr, (BYTE *)&DupleTab[*(Source + i) * 2], XMul);
               TempPtr += XMul;
           }
           break;
       case 3:
           for (i = 0; i < Len; i++)
           {
               memcpy(TempPtr, (BYTE *)&TripleTab[*(Source + i) * 3], XMul);
               TempPtr += XMul;
           }
           break;
       case 4:
           for (i = 0; i < Len; i++)
           {
               memcpy(Buffer, (BYTE *)&DupleTab[*(Source + i ) * 2], 2);

               memcpy(TempPtr, (BYTE *)&DupleTab[(*Buffer) * 2], 2);
               TempPtr += 2;
               memcpy(TempPtr, (BYTE *)&DupleTab[*(Buffer + 1) * 2], 2);
               TempPtr += 2;
           }
           break;
       case 5:
           for (i = 0; i < Len; i++)
           {
               memcpy(TempPtr, (BYTE *)&QuintupleTab[*(Source + i) * 5], XMul);
               TempPtr += XMul;
           }
           break;
       case 6:
           for (i = 0; i < Len; i++)
           {
               memcpy(Buffer, (BYTE *)&DupleTab[*(Source + i) * 2], 2);

               memcpy(TempPtr, (BYTE *)&TripleTab[(*Buffer) * 3], 3);
               TempPtr += 3;
               memcpy(TempPtr, (BYTE *)&TripleTab[*(Buffer + 1) * 3], 3);
               TempPtr += 3;
           }
           break;
       case 7:
           for (i = 0; i < Len; i++)
           {
               memcpy(TempPtr, (BYTE *)&SeptupleTab[*(Source + i) * 7], XMul);
               TempPtr += XMul;
           }
           break;
       case 8:
           for (i = 0; i < Len; i++)
           {
               memcpy(Buffer, (BYTE *)&DupleTab[*(Source + i) * 2], 2);

               memcpy(Buffer2, (BYTE *)&DupleTab[(*Buffer) *2 ], 2 );
               memcpy(Buffer2 + 2, (BYTE *)&DupleTab[(*(Buffer + 1)) *2], 2);
               for (j = 0; j < 4; j++)
               {
                   memcpy(TempPtr, (BYTE *)&DupleTab[ (*(Buffer2 + j)) * 2], 2);
                   TempPtr += 2;
               }
           }
           break;
       case 9:
           for (i = 0; i < Len; i++)
           {
               memcpy(Buffer, (BYTE *)&TripleTab[*(Source + i) * 3], 3);

               for (j = 0; j < 3; j++)
               {
                   memcpy(TempPtr, (BYTE *)&TripleTab[*(Buffer + j) * 3], 3);
                   TempPtr += 3;
               }
           }
           break;
       case 10:
           for (i = 0; i < Len; i++)
           {
               memcpy(Buffer, (BYTE *)&DupleTab[*(Source + i) * 2], 2);

               for (j = 0; j < 2; j++)
               {
                   memcpy(TempPtr, (BYTE *)&QuintupleTab[*(Buffer + j) * 5], 5);
                   TempPtr += 5;
               }
           }
           break;
       default:
           return FALSE;
   }
   XLength = (XDots * XMul + 7) / 8;
   memset(Target + XLength, 0, Delta);

   XLength += Delta;
   for (i = 1; i < YMul; i++)
       memcpy(Target + XLength * i, Target, XLength);

return XLength * YMul;
}

STATIC VOID EightBit(BYTE *pTraget, BYTE *pSource, BYTE *pShiftData, INT SourceWidth, INT Shitf_Start, INT End_Shift, INT Up_Shift)
{
BYTE bTemp , bTempArray[8] , bMask;
INT i,j;

for ( i=0 ; i<End_Shift ; i++ )
* ( bTempArray + i) = *( pSource + i * SourceWidth );

   if ( Shitf_Start == 0 )
   {
       bMask = 0x80;
       End_Shift -= 1;

       for ( i=0 ; i<Up_Shift ; i++ )
       {
           bTemp = 0;
           for ( j = End_Shift ; j>=0 ; j-- )
           {
               bTemp >>= 1;
               bTemp |= *( bTempArray + j ) & bMask;
               *( bTempArray + j ) <<= 1;
           }
           *( pTraget + i ) = bTemp;
       }
   }
   else
   {
       bMask = 0x80;
       End_Shift -= 1;

       for ( i=0 ; i<Up_Shift ; i++ )
       {
           bTemp = 0;
           for ( j = End_Shift ; j>=0 ; j-- )
           {
               bTemp >>= 1;
               bTemp |= *( bTempArray + j ) & bMask;
               *( bTempArray + j ) <<= 1;
           }
           *( pTraget + i ) = *( pShiftData + i );
           *( pShiftData + i ) = bTemp <<(8 - Shitf_Start );
           *( pTraget + i ) |= ( bTemp >> Shitf_Start ) ;
       }
   }
}

VOID NorOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, INT bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data, shift_data, temp_data;
INT i, j;

wWidth = ( wWidth + 7 ) /8;

   i = 0;
   j = 0;
   if ( bShiftBit )
   {
       shift_data = 0;
       pImageTarget += wOffset;
       while ( j != wHeight )
       {
           data = *(pImageSource + i);

           temp_data = data<<(8 - bShiftBit);
           data = data >> bShiftBit;
           data = data | shift_data;
           shift_data = temp_data;

           *(pImageTarget + i ) |= data;

           i++;
           if ( i == wWidth )
           {
               *(pImageTarget + i) |= shift_data;

               i = 0;
               j++;

               shift_data = 0;
               pImageTarget += wWidByte;
               pImageSource += SourceWidByte;
           }
       }
   }
   else
   {
       pImageTarget += wOffset;
       while ( j != wHeight )
       {
           *(pImageTarget + i ) |= *(pImageSource + i);
           i++;

           if ( i == wWidth )
           {
               i = 0;
               j++;
               pImageTarget += wWidByte;
               pImageSource += SourceWidByte;
           }
       }
   }
}

VOID NorXOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, INT bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
   BYTE data, shift_data, temp_data , temp_data_end;
   INT i, j ,full_width;
   INT end_Shift;

   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   wWidth = ( wWidth + 7 ) / 8;

           pImageTarget += wWidByte;
           pImageSource += SourceWidByte;
       }
   }
   else
   {
       for ( j=0 ; j<wHeight ; j++ )
       {
           // put full image
           for ( i=0 ; i< ( wWidth-1 ) ; i++ )
               *(pImageTarget + i ) ^= *(pImageSource + i);

           // put right mask image
           if ( end_Shift )
           {
               temp_data_end = ( *(pImageTarget + i ) ) & MaskDataL[end_Shift];
               *(pImageTarget + i ) ^= *(pImageSource + i);
               *(pImageTarget + i ) &= MaskDataR[ 8 - end_Shift];
               *(pImageTarget + i ) |= temp_data_end;
           }
           else
               *(pImageTarget + i ) ^= *(pImageSource + i);

           pImageTarget += wWidByte;
           pImageSource += SourceWidByte;
       }
   }
}

VOID NorOW(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, INT bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
   BYTE data, shift_data, temp_data , temp_data_end;
   INT i, j ,full_width;
   INT end_Shift;

   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   wWidth = ( wWidth + 7 ) / 8;

   pImageTarget += wOffset;
   if ( bShiftBit )
   {
       for ( j=0 ;j<wHeight ; j++ )
       {
           shift_data = 0;
           if ( full_width == 0 )
               temp_data_end = *pImageTarget & MaskDataL[end_Shift];

           for ( i=0 ; i < wWidth ; i++ )
           {
               temp_data = *(pImageSource + i) << (8 - bShiftBit);
               data = ( *(pImageSource + i) >> bShiftBit ) | shift_data;
               shift_data = temp_data;

               //put left image
               if ( i == 0 )
               {
                   temp_data = *pImageTarget & MaskDataR[ 8 - bShiftBit ];
                   *pImageTarget = data;
                   *pImageTarget &= MaskDataL[ bShiftBit ];
                   *pImageTarget |= temp_data;
               }
               else if ( ( i == full_width ) && end_Shift )
               {
                   temp_data_end = ( *(pImageTarget + i ) ) & MaskDataL[end_Shift];
                   *(pImageTarget + i ) = data;
                   *(pImageTarget + i ) &= MaskDataR[ 8 - end_Shift];
                   *(pImageTarget + i ) |= temp_data_end;
               }
               else
                   *(pImageTarget + i ) = data;
           }
           // put right mask
           if ( end_Shift && ( wWidth <= full_width ))
           {
               temp_data_end = ( *(pImageTarget + full_width ) ) & MaskDataL[end_Shift];
               *(pImageTarget + full_width ) = shift_data;
               *(pImageTarget + full_width ) &= MaskDataR[ 8 - end_Shift];
               *(pImageTarget + full_width ) |= temp_data_end;
           }
           else if ( end_Shift && !full_width )
           {
               *pImageTarget &= MaskDataR[ 8 - end_Shift];
               *pImageTarget |= temp_data_end;
           }
           pImageTarget += wWidByte;
           pImageSource += SourceWidByte;
       }
   }
   else
   {
       for ( j=0 ; j<wHeight ; j++ )
       {
           // put full image
           for ( i=0 ; i< ( wWidth-1 ) ; i++ )
               *(pImageTarget + i ) = *(pImageSource + i);

           // put right mask image
           if ( end_Shift )
           {
               temp_data_end = ( *(pImageTarget + i ) ) & MaskDataL[end_Shift];
               *(pImageTarget + i ) = *(pImageSource + i);
               *(pImageTarget + i ) &= MaskDataR[ 8 - end_Shift];
               *(pImageTarget + i ) |= temp_data_end;
           }
           else
               *(pImageTarget + i ) = *(pImageSource + i);

           pImageTarget += wWidByte;
           pImageSource += SourceWidByte;
       }
   }
}

VOID DownOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data, shift_data , temp_data , temp_data_start , temp_data_end,end_Shift;
INT i, j , full_width;

   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   i = ( bShiftBit + wWidth + 7 ) /8;
   wWidth = ( wWidth + 7 ) / 8;

   pImageTarget += wOffset + i - 1;

   pImageSource += ( wWidth * ( wHeight - 1 ) );


   if ( end_Shift == 0 )
   {
       for ( j=0 ;j<wHeight ; j++ )
       {
           for ( i=0 ; i< ( wWidth-1) ; i++ )
               *(pImageTarget - i ) |= InvertData[ *(pImageSource + i) ];
           if ( bShiftBit )
           {
               temp_data_end = ( *(pImageTarget - i ) ) & MaskDataR[8 - bShiftBit];
               *(pImageTarget - i ) |= InvertData[ *(pImageSource + i) ];
               *(pImageTarget - i ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - i ) |= temp_data_end;
           }
           else
               *(pImageTarget - i ) |= InvertData[ *(pImageSource + i)];

           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
   else
   {
       shift_data = 0;
       for ( j=0 ;j<wHeight ; j++ )
       {
           if ( full_width == 0 )
               temp_data_end = *pImageTarget & MaskDataR[ 8 - bShiftBit];
           for ( i=0 ; i <wWidth ; i++ )
           {
               data = InvertData[ *(pImageSource + i)];
               temp_data = data >> end_Shift;
               data = ( data << ( 8 - end_Shift ) ) | shift_data;
               shift_data = temp_data;

               if ( i == 0 )
               {
                   temp_data_start = *pImageTarget & MaskDataL[ end_Shift ];
                   *pImageTarget |= data;
                   *pImageTarget &= MaskDataR[ 8 - end_Shift ];
                   *pImageTarget |= temp_data_start;
               }
               else if ( ( i == full_width ) && bShiftBit )
               {
                   temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
                   *(pImageTarget - full_width ) |= data;
                   *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
                   *(pImageTarget - full_width ) |= temp_data_end;
               }
               else
                   *(pImageTarget - i ) |= data;
           }

           if ( ( bShiftBit ) && ( wWidth <= full_width ))
           {
               temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
               *(pImageTarget - full_width ) |= shift_data;
               *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - full_width ) |= temp_data_end;
           }
           else if ( bShiftBit && !full_width )
           {
               *pImageTarget &= MaskDataL[ bShiftBit];
               *pImageTarget |= temp_data_end;
           }
           shift_data = 0;
           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
}

VOID DownXOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data, shift_data , temp_data , temp_data_start , temp_data_end,end_Shift;
INT i, j , full_width;

   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   i = ( bShiftBit + wWidth + 7 ) /8;
   wWidth = ( wWidth + 7 ) / 8;

   pImageTarget += wOffset + i - 1;

   pImageSource += ( wWidth * ( wHeight - 1 ) );


   if ( end_Shift == 0 )
   {
       for ( j=0 ;j<wHeight ; j++ )
       {
           for ( i=0 ; i< ( wWidth-1) ; i++ )
               *(pImageTarget - i ) ^= InvertData[ *(pImageSource + i) ];
           if ( bShiftBit )
           {
               temp_data_end = ( *(pImageTarget - i ) ) & MaskDataR[8 - bShiftBit];
               *(pImageTarget - i ) ^= InvertData[ *(pImageSource + i) ];
               *(pImageTarget - i ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - i ) |= temp_data_end;
           }
           else
               *(pImageTarget - i ) ^= InvertData[ *(pImageSource + i)];

           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
   else
   {
       shift_data = 0;
       for ( j=0 ;j<wHeight ; j++ )
       {
           if ( full_width == 0 )
               temp_data_end = *pImageTarget & MaskDataR[ 8 - bShiftBit];
           for ( i=0 ; i <wWidth ; i++ )
           {
               data = InvertData[ *(pImageSource + i)];
               temp_data = data >> end_Shift;
               data = ( data << ( 8 - end_Shift ) ) | shift_data;
               shift_data = temp_data;

               if ( i == 0 )
               {
                   temp_data_start = *pImageTarget & MaskDataL[ end_Shift ];
                   *pImageTarget ^= data;
                   *pImageTarget &= MaskDataR[ 8 - end_Shift ];
                   *pImageTarget |= temp_data_start;
               }
               else if ( ( i == full_width ) && bShiftBit )
               {
                   temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
                   *(pImageTarget - full_width ) ^= data;
                   *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
                   *(pImageTarget - full_width ) |= temp_data_end;
               }
               else
                   *(pImageTarget - i ) ^= data;
           }

           if ( ( bShiftBit ) && ( wWidth <= full_width ))
           {
               temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
               *(pImageTarget - full_width ) ^= shift_data;
               *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - full_width ) |= temp_data_end;
           }
           else if ( bShiftBit && !full_width )
           {
               *pImageTarget &= MaskDataL[ bShiftBit];
               *pImageTarget |= temp_data_end;
           }
           shift_data = 0;
           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
}

VOID DownOW(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data, shift_data , temp_data , temp_data_start , temp_data_end,end_Shift;
INT i, j , full_width;

   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   i = ( bShiftBit + wWidth + 7 ) /8;
   wWidth = ( wWidth + 7 ) / 8;

   pImageTarget += wOffset + i - 1;

   pImageSource += ( wWidth * ( wHeight - 1 ) );


   if ( end_Shift == 0 )
   {
       for ( j=0 ;j<wHeight ; j++ )
       {
           for ( i=0 ; i< ( wWidth-1) ; i++ )
               *(pImageTarget - i ) = InvertData[ *(pImageSource + i) ];
           if ( bShiftBit )
           {
               temp_data_end = ( *(pImageTarget - i ) ) & MaskDataR[8 - bShiftBit];
               *(pImageTarget - i ) = InvertData[ *(pImageSource + i) ];
               *(pImageTarget - i ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - i ) |= temp_data_end;
           }
           else
               *(pImageTarget - i ) = InvertData[ *(pImageSource + i)];

           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
   else
   {
       shift_data = 0;
       for ( j=0 ;j<wHeight ; j++ )
       {
           if ( full_width == 0 )
               temp_data_end = *pImageTarget & MaskDataR[ 8 - bShiftBit];
           for ( i=0 ; i <wWidth ; i++ )
           {
               data = InvertData[ *(pImageSource + i)];
               temp_data = data >> end_Shift;
               data = ( data << ( 8 - end_Shift ) ) | shift_data;
               shift_data = temp_data;

               if ( i == 0 )
               {
                   temp_data_start = *pImageTarget & MaskDataL[ end_Shift ];
                   *pImageTarget = data;
                   *pImageTarget &= MaskDataR[ 8 - end_Shift ];
                   *pImageTarget |= temp_data_start;
               }
               else if ( ( i == full_width ) && bShiftBit )
               {
                   temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
                   *(pImageTarget - full_width ) = data;
                   *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
                   *(pImageTarget - full_width ) |= temp_data_end;
               }
               else
                   *(pImageTarget - i ) = data;
           }

           if ( ( bShiftBit ) && ( wWidth <= full_width ))
           {
               temp_data_end = ( *(pImageTarget - full_width ) ) & MaskDataR[ 8 - bShiftBit];
               *(pImageTarget - full_width ) = shift_data;
               *(pImageTarget - full_width ) &= MaskDataL[ bShiftBit];
               *(pImageTarget - full_width ) |= temp_data_end;
           }
           else if ( bShiftBit && !full_width )
           {
               *pImageTarget &= MaskDataL[ bShiftBit];
               *pImageTarget |= temp_data_end;
           }

           shift_data = 0;
           pImageTarget += wWidByte;
           pImageSource -= SourceWidByte;
       }
   }
}

VOID LeftOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

   font_wide = ( wHeight + 7 ) /8;
   Up_Shift = wHeight % 8;
   if ( Up_Shift == 0 )
       Up_Shift = 8;
   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   wWidth = ( wWidth + 7 ) / 8;

pImageTarget += ( wOffset + wWidByte * (wHeight - 1 ) );

   if ( bShiftBit == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && end_Shift != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) |= data[k];
                       *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                       *( pImageTarget   - k * wWidByte + j ) |= data[k];
               }
           }
           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget + j * wWidByte ) & MaskDataL[end_Shift];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) |= data[k];
                       *( pImageTarget   - k * wWidByte ) &= MaskDataL[ bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   if ( ( j == full_width ) && ( end_Shift != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) |= data[k];
                           *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget   - k * wWidByte + j ) |= data[k];
                   }
               }
           }

           if ( ( end_Shift != 0 ) &&( wWidth <= full_width ))
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) |= shift_data[k];
                   *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) |= temp_data;
               }
           }
           else if ( ( end_Shift != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget - k * wWidByte ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget - k * wWidByte ) |= temp_data;
               }
           }
           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }

}
}

VOID LeftXOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

pImageTarget += ( wOffset + wWidByte * (wHeight - 1 ) );

   if ( bShiftBit == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && end_Shift != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) ^= data[k];
                       *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                       *( pImageTarget   - k * wWidByte + j ) ^= data[k];
               }
           }
           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget - j * wWidByte ) & MaskDataL[end_Shift];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) ^= data[k];
                       *( pImageTarget   - k * wWidByte ) &= MaskDataL[ bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   if ( ( j == full_width ) && ( end_Shift != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) ^= data[k];
                           *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget   - k * wWidByte + j ) ^= data[k];
                   }
               }

           }

           if ( ( end_Shift != 0 ) &&( wWidth <= full_width ))
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) ^= shift_data[k];
                   *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) |= temp_data;
               }
           }
           else if ( ( end_Shift != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget - k * wWidByte ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget - k * wWidByte ) |= temp_data;
               }
           }
           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }

}
}

VOID LeftOW(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

   if ( bShiftBit == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && end_Shift != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) = data[k];
                       *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                       *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                       *( pImageTarget   - k * wWidByte + j ) = data[k];
               }
           }
           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget + j * wWidByte ) & MaskDataL[end_Shift];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   - k * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) = data[k];
                       *( pImageTarget   - k * wWidByte ) &= MaskDataL[ bShiftBit ];
                       *( pImageTarget   - k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , bShiftBit , 8 , l);
                   if ( ( j == full_width ) && ( end_Shift != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) = data[k];
                           *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                           *( pImageTarget   - k * wWidByte + j ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget   - k * wWidByte + j ) = data[k];
                   }
               }

           }

           if ( ( end_Shift != 0 ) &&( wWidth <= full_width ))
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   - k * wWidByte + j ) & MaskDataL[end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) = shift_data[k];
                   *( pImageTarget   - k * wWidByte + j ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget   - k * wWidByte + j ) |= temp_data;
               }
           }
           else if ( ( end_Shift != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget - k * wWidByte ) &= MaskDataR[ 8 - end_Shift];
                   *( pImageTarget - k * wWidByte ) |= temp_data;
               }
           }

           pImageSource += 1;
           pImageTarget -= wWidByte * 8;
       }

}
}

VOID RightOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

   font_wide = ( wHeight + 7 ) /8;
   i = ( bShiftBit + wWidth + 7 ) /8;
   Up_Shift = wHeight % 8;
   if ( Up_Shift == 0 )
       Up_Shift = 8;
   end_Shift = ( wWidth + bShiftBit ) % 8;
   full_width = ( wWidth + bShiftBit ) / 8;
   wWidth = ( wWidth + 7 ) / 8;

   pImageTarget += ( wOffset + i - 1 );

   if ( end_Shift == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && bShiftBit != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte - j ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   + k * wWidByte - j ) |= InvertData[ data[k] ];
                       *( pImageTarget   + k * wWidByte - j ) &= MaskDataL[ bShiftBit];
                       *( pImageTarget   + k * wWidByte - j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       *( pImageTarget   + k * wWidByte - j ) |= InvertData[ data[k] ] ;
                   }
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget   + j * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte ) & MaskDataL[ end_Shift ];
                       *( pImageTarget   + k * wWidByte ) |= InvertData[ data[k] ];
                       *( pImageTarget   + k * wWidByte ) &= MaskDataR[ 8 - end_Shift ];
                       *( pImageTarget   + k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   if ( ( j == full_width ) && ( bShiftBit != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                           *( pImageTarget   + k * wWidByte - full_width ) |= InvertData[ data[k] ];
                           *( pImageTarget   + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                           *( pImageTarget   + k * wWidByte - full_width ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget   + k * wWidByte - j ) |= InvertData[ data[k] ];
                   }
               }

           }

           if ( ( bShiftBit != 0 ) && ( wWidth <= full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                   *( pImageTarget   + k * wWidByte - full_width ) |= InvertData[ shift_data[k] ];
                   *( pImageTarget   + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget   + k * wWidByte - full_width ) |= temp_data;
               }
           }
           else if ( ( bShiftBit != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget + k * wWidByte ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget + k * wWidByte ) |= temp_data;
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }

}
}

VOID RightXOR(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

   if ( end_Shift == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && bShiftBit != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte - j ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   + k * wWidByte - j ) ^= InvertData[ data[k] ];
                       *( pImageTarget   + k * wWidByte - j ) &= MaskDataL[ bShiftBit];
                       *( pImageTarget   + k * wWidByte - j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       *( pImageTarget   + k * wWidByte - j ) ^= InvertData[ data[k] ] ;
                   }
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget + j * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte ) & MaskDataL[ end_Shift ];
                       *( pImageTarget + k * wWidByte ) ^= InvertData[ data[k] ];
                       *( pImageTarget + k * wWidByte ) &= MaskDataR[ 8 - end_Shift ];
                       *( pImageTarget + k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   if ( ( j == full_width ) && ( bShiftBit != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                           *( pImageTarget   + k * wWidByte - full_width ) ^= InvertData[ data[k] ];
                           *( pImageTarget   + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                           *( pImageTarget   + k * wWidByte - full_width ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget   + k * wWidByte - j ) ^= InvertData[ data[k] ];
                   }
               }

           }

           if ( ( bShiftBit != 0 ) && ( wWidth <= full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                   *( pImageTarget   + k * wWidByte - full_width ) ^= InvertData[ shift_data[k] ];
                   *( pImageTarget   + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget   + k * wWidByte - full_width ) |= temp_data;
               }
           }
           else if ( ( bShiftBit != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget + k * wWidByte ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget + k * wWidByte ) |= temp_data;
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }

}
}

VOID RightOW(INT wWidth, INT wHeight, INT SourceWidByte, INT wWidByte, INT wOffset, BYTE bShiftBit, BYTE *pImageSource, BYTE *pImageTarget)
{
BYTE data[9], shift_data[9], temp_array[9], temp_data, end_Shift;
INT i, j, k, l, full_width, font_wide, Up_Shift;

   memset(data, 0, sizeof(data));
   memset(shift_data, 0, sizeof(shift_data));
   memset(temp_array, 0, sizeof(temp_array));

pImageTarget += ( wOffset + i - 1 );

   if ( end_Shift == 0 )
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == ( wWidth - 1 ) && bShiftBit != 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte - j ) & MaskDataR[ 8 - bShiftBit ];
                       *( pImageTarget   + k * wWidByte - j ) = InvertData[ data[k] ];
                       *( pImageTarget   + k * wWidByte - j ) &= MaskDataL[ bShiftBit];
                       *( pImageTarget   + k * wWidByte - j ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       *( pImageTarget   + k * wWidByte - j ) = InvertData[ data[k] ] ;
                   }
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }
   }
   else
   {
       for ( i=0 ; i< font_wide ; i++ )
       {
           if ( i == ( font_wide - 1 ) )
               l = Up_Shift ;
           else
               l = 8;

           if ( full_width == 0 )
           {
               for ( j=0 ; j<l ; j++ )
                   temp_array[j] = *( pImageTarget + j * wWidByte ) & MaskDataR[ 8 - bShiftBit ];
           }
           for ( j=0 ; j<wWidth ; j++ )
           {
               if ( j == 0 )
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   for ( k=0 ; k<l ; k++ )
                   {
                       temp_data = *( pImageTarget   + k * wWidByte ) & MaskDataL[ end_Shift ];
                       *( pImageTarget + k * wWidByte ) = InvertData[ data[k] ];
                       *( pImageTarget + k * wWidByte ) &= MaskDataR[ 8 - end_Shift ];
                       *( pImageTarget + k * wWidByte ) |= temp_data;
                   }
               }
               else
               {
                   EightBit ( data , pImageSource + j * 8 * SourceWidByte ,shift_data, SourceWidByte , ( 8 - end_Shift )% 8 , 8 , l);
                   if ( ( j == full_width ) && ( bShiftBit != 0 ) )
                   {
                       for ( k=0 ; k<l ; k++ )
                       {
                           temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                           *( pImageTarget + k * wWidByte - full_width ) = InvertData[ data[k] ];
                           *( pImageTarget + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                           *( pImageTarget + k * wWidByte - full_width ) |= temp_data;
                       }
                   }
                   else
                   {
                       for ( k=0 ; k<l ; k++ )
                           *( pImageTarget + k * wWidByte - j ) = InvertData[ data[k] ];
                   }
               }

           }

           if ( ( bShiftBit != 0 ) && ( wWidth <= full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = *( pImageTarget   + k * wWidByte - full_width ) & MaskDataR[ 8 - bShiftBit ];
                   *( pImageTarget   + k * wWidByte - full_width ) = InvertData[ shift_data[k] ];
                   *( pImageTarget   + k * wWidByte - full_width ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget   + k * wWidByte - full_width ) |= temp_data;
               }
           }
           else if ( ( bShiftBit != 0 ) && ( !full_width ) )
           {
               for ( k=0 ; k<l ; k++ )
               {
                   temp_data = temp_array[k];
                   *( pImageTarget + k * wWidByte ) &= MaskDataL[ bShiftBit];
                   *( pImageTarget + k * wWidByte ) |= temp_data;
               }
           }
           pImageSource += 1;
           pImageTarget += wWidByte * 8;
       }

}
}

VOID PutImage(_ImgBuf *Dst, _ImgBuf *Src, INT X, INT Y, INT Rotate, _ePutWay PutWay)
{
   BYTE *SrcImg = Src->pBuffer;
   INT Height, Width, WidthByte;
   INT Offset, ShiftBit;

   if (Rotate == 90 || Rotate == 270)
   {
       Height = Src->iWidth;
       Width = Src->iHeight;
       if (Src->iByteWidth > (Src->iWidth + 7) / 8)
       {
           if (Rotate == 270)
               Y -= 1;
           Height += 1;
       }
       WidthByte = (Height + 7) / 8;
   }
    else
    {
       Height = Src->iHeight;
       Width = Src->iWidth;
       if (Src->iByteWidth > (Src->iWidth + 7) / 8)
       {
           if (Rotate == 180)
               X -= 1;
           Width += 1;
       }
       WidthByte = (Width + 7) / 8;
   }

   if (X < 0)
   {
       if (Rotate == 0)
           return;
       if (Rotate == 270)
           SrcImg += WidthByte * (0 - X);
       Width -= (0 - X);
       X = 0;
   }
   if (Y < 0)
   {
       if (Rotate == 90)
           return;
       if (Rotate == 0)
           SrcImg += WidthByte * (0 - Y);
       Height -= (0 - Y);
       Y = 0;
   }

   if (X + Width > Dst->iWidth)
       Width = Dst->iWidth - X;
   if (Width <= 0)
       return;
   if (Y + Height > Dst->iHeight)
       Height = Dst->iHeight - Y;
   if (Height <= 0)
       return;

ModifyImgSection(Y, Height, Dst);

Offset = (Dst->iWidth + 7) / 8 * Y + X / 8;
ShiftBit = X % 8;

   switch (Rotate)
   {
       case 0:
           if (PutWay == PUT_XOR)
               NorXOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else if (PutWay == PUT_OW)
               NorOW(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else
               NorOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           break;

       case 90:
           if (PutWay == PUT_XOR)
               RightXOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else if (PutWay == PUT_OW)
               RightOW(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else
               RightOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           break;

       case 180:
           if (PutWay == PUT_XOR)
               DownXOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else if (PutWay == PUT_OW)
               DownOW(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else
               DownOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           break;

       case 270:
           if (PutWay == PUT_XOR)
               LeftXOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else if (PutWay == PUT_OW)
               LeftOW(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           else
               LeftOR(Width, Height, WidthByte, Dst->iByteWidth, Offset, ShiftBit, SrcImg, Dst->pBuffer);
           break;
   }
}

VOID ModifyImgSection(INT Y, INT Height, _ImgBuf *pImgBuf)
{
INT LastDotLine;

if (Y < pImgBuf->iFirstLine)
pImgBuf->iFirstLine = Y;

LastDotLine = Y + Height - 1;

   if (LastDotLine > (pImgBuf->iHeight - 1))
       pImgBuf->iLastLine = pImgBuf->iHeight - 1;
   else if (LastDotLine > pImgBuf->iLastLine)
       pImgBuf->iLastLine = LastDotLine;
}

ImgUtil.h /

#ifndef IMGUTIL_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define IMGUTIL_H

/* None */

#include "XImgMgr.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

/* None */

typedef enum
{
   PUT_OR,
   PUT_OW,
   PUT_XOR,
}_ePutWay;

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

INT LineMultiple(BYTE *, BYTE *, INT, INT, INT, INT);
VOID NorOR(INT, INT, INT, INT, INT, INT, BYTE *, BYTE *);
VOID NorXOR(INT, INT, INT, INT, INT, INT, BYTE *, BYTE *);
VOID NorOW(INT, INT, INT, INT, INT, INT, BYTE *, BYTE *);
VOID DownOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID DownXOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID DownOW(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID LeftOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID LeftXOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID LeftOW(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID RightOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID RightXOR(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID RightOW(INT, INT, INT, INT, INT, BYTE, BYTE *, BYTE *);
VOID PutImage(_ImgBuf *, _ImgBuf *, INT, INT, INT, _ePutWay);
VOID ModifyImgSection(INT, INT, _ImgBuf *);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

qq_33772147

关注

17
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
T168_Backup\T168_111\appl\Graphic文件：

* None *//* None */}_BMPAttr;/* None *//* None *//* None *//* None *//* None */
复制链接

扫一扫