GUI_SetOrientationCX.h

00001 /*********************************************************************
00002 *                SEGGER Microcontroller GmbH & Co. KG                *
00003 *        Solutions for real time microcontroller applications        *
00004 **********************************************************************
00005 *                                                                    *
00006 *        (c) 1996 - 2016  SEGGER Microcontroller GmbH & Co. KG       *
00007 *                                                                    *
00008 *        Internet: www.segger.com    Support:  support@segger.com    *
00009 *                                                                    *
00010 **********************************************************************
00011 
00012 ** emWin V5.38 - Graphical user interface for embedded applications **
00013 All  Intellectual Property rights  in the Software belongs to  SEGGER.
00014 emWin is protected by  international copyright laws.  Knowledge of the
00015 source code may not be used to write a similar product.  This file may
00016 only be used in accordance with the following terms:
00017 
00018 The software has been licensed to  NXP Semiconductors USA, Inc.  whose
00019 registered  office  is  situated  at 411 E. Plumeria Drive, San  Jose,
00020 CA 95134, USA  solely for  the  purposes  of  creating  libraries  for
00021 NXPs M0, M3/M4 and  ARM7/9 processor-based  devices,  sublicensed  and
00022 distributed under the terms and conditions of the NXP End User License
00023 Agreement.
00024 Full source code is available at: www.segger.com
00025 
00026 We appreciate your understanding and fairness.
00027 ----------------------------------------------------------------------
00028 Licensing information
00029 
00030 Licensor:                 SEGGER Microcontroller Systems LLC
00031 Licensed to:              NXP Semiconductors, 1109 McKay Dr, M/S 76, San Jose, CA 95131, USA
00032 Licensed SEGGER software: emWin
00033 License number:           GUI-00186
00034 License model:            emWin License Agreement, dated August 20th 2011
00035 Licensed product:         -
00036 Licensed platform:        NXP's ARM 7/9, Cortex-M0,M3,M4
00037 Licensed number of seats: -
00038 ----------------------------------------------------------------------
00039 File        : GUI_SetOrientationC0.c
00040 Purpose     : Runtime display orientation without cache
00041 ---------------------------END-OF-HEADER------------------------------
00042 */
00043 
00044 #include "GUI_SetOrientation.h"
00045 
00046 /*********************************************************************
00047 *
00048 *       Defines
00049 *
00050 **********************************************************************
00051 */
00052 #define XY2PTR(x, y) (PIXEL *)(pContext->pData + y * pContext->BytesPerLine + x * pContext->pDrawingAPI->BytesPerPixel)
00053 
00054 /*********************************************************************
00055 *
00056 *       Static code
00057 *
00058 **********************************************************************
00059 */
00060 /*********************************************************************
00061 *
00062 *       Static code
00063 *
00064 **********************************************************************
00065 */
00066 /*********************************************************************
00067 *
00068 *       _Sort
00069 *
00070 * Purpose:
00071 *   Sorts the values pointed by the given pointers. Please note that
00072 *   the same static function is also in GUI_SetOrientationC0.h
00073 *   to enable better compiler optimization.
00074 */
00075 static void _Sort(int * p0, int * p1) {
00076   int temp;
00077 
00078   if (*p0 > *p1) {
00079     temp = *p0;
00080     *p0  = *p1;
00081     *p1  = temp;
00082   }
00083 }
00084 
00085 /*********************************************************************
00086 *
00087 *       Static code: Bitmap drawing routines
00088 *
00089 **********************************************************************
00090 */
00091 /*********************************************************************
00092 *
00093 *       Draw Bitmap 1 BPP
00094 */
00095 static void _DrawBitLine1BPP(GUI_DEVICE * pDevice, unsigned x, unsigned y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
00096   LCD_PIXELINDEX IndexMask, Index0, Index1, Pixel;
00097   LCD_PIXELINDEX (* pfGetPixelIndex)(GUI_DEVICE *, int, int);
00098   PIXEL * pData;
00099   int x_phys, y_phys;
00100   DRIVER_CONTEXT * pContext;
00101 
00102   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00103   Index0 = *(pTrans + 0);
00104   Index1 = *(pTrans + 1);
00105   x += Diff;
00106   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00107   pData = XY2PTR(x_phys, y_phys);
00108   switch (GUI_pContext->DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
00109   case 0:
00110     do {
00111       *pData = (PIXEL)((*p & (0x80 >> Diff)) ? Index1 : Index0);
00112       pData += pContext->PixelOffset;
00113       if (++Diff == 8) {
00114         Diff = 0;
00115         p++;
00116       }
00117     } while (--xsize);
00118     break;
00119   case LCD_DRAWMODE_TRANS:
00120     do {
00121       if (*p & (0x80 >> Diff)) {
00122         *pData = (PIXEL)Index1;
00123       }
00124       pData += pContext->PixelOffset;
00125       if (++Diff == 8) {
00126         Diff = 0;
00127         p++;
00128       }
00129     } while (--xsize);
00130     break;
00131   case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
00132   case LCD_DRAWMODE_XOR:
00133     pfGetPixelIndex = pDevice->pDeviceAPI->pfGetPixelIndex;
00134     IndexMask = pDevice->pColorConvAPI->pfGetIndexMask();
00135     do {
00136       if (*p & (0x80 >> Diff)) {
00137         Pixel = pfGetPixelIndex(pDevice, x, y);
00138         Pixel ^= IndexMask;
00139         *pData = (PIXEL)Pixel;
00140       }
00141       pData += pContext->PixelOffset;
00142       x++;
00143       if (++Diff == 8) {
00144         Diff = 0;
00145         p++;
00146       }
00147     } while (--xsize);
00148     break;
00149   }
00150 }
00151 
00152 /*********************************************************************
00153 *
00154 *       Draw Bitmap 2 BPP
00155 */
00156 static void _DrawBitLine2BPP(GUI_DEVICE * pDevice, int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
00157   LCD_PIXELINDEX Pixels, PixelIndex;
00158   int CurrentPixel, Shift, Index;
00159   PIXEL * pData;
00160   int x_phys, y_phys;
00161   DRIVER_CONTEXT * pContext;
00162 
00163   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00164   Pixels = *p;
00165   CurrentPixel = Diff;
00166   x += Diff;
00167   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00168   pData = XY2PTR(x_phys, y_phys);
00169   switch (GUI_pContext->DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
00170   case 0:
00171     if (pTrans) {
00172       do {
00173         Shift = (3 - CurrentPixel) << 1;
00174         Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
00175         PixelIndex = *(pTrans + Index);
00176         *pData = (PIXEL)PixelIndex;
00177         pData += pContext->PixelOffset;
00178         if (++CurrentPixel == 4) {
00179           CurrentPixel = 0;
00180           Pixels = *(++p);
00181         }
00182       } while (--xsize);
00183     } else {
00184       do {
00185         Shift = (3 - CurrentPixel) << 1;
00186         Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
00187         *pData = (PIXEL)Index;
00188         pData += pContext->PixelOffset;
00189         if (++CurrentPixel == 4) {
00190           CurrentPixel = 0;
00191           Pixels = *(++p);
00192         }
00193       } while (--xsize);
00194     }
00195     break;
00196   case LCD_DRAWMODE_TRANS:
00197     if (pTrans) {
00198       do {
00199         Shift = (3 - CurrentPixel) << 1;
00200         Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
00201         if (Index) {
00202           PixelIndex = *(pTrans + Index);
00203           *pData = (PIXEL)PixelIndex;
00204         }
00205         pData += pContext->PixelOffset;
00206         if (++CurrentPixel == 4) {
00207           CurrentPixel = 0;
00208           Pixels = *(++p);
00209         }
00210       } while (--xsize);
00211     } else {
00212       do {
00213         Shift = (3 - CurrentPixel) << 1;
00214         Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
00215         if (Index) {
00216           *pData = (PIXEL)Index;
00217         }
00218         pData += pContext->PixelOffset;
00219         if (++CurrentPixel == 4) {
00220           CurrentPixel = 0;
00221           Pixels = *(++p);
00222         }
00223       } while (--xsize);
00224     }
00225     break;
00226   }
00227 }
00228 
00229 /*********************************************************************
00230 *
00231 *       Draw Bitmap 4 BPP
00232 */
00233 static void _DrawBitLine4BPP(GUI_DEVICE * pDevice, int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
00234   LCD_PIXELINDEX Pixels, PixelIndex;
00235   int CurrentPixel, Shift, Index;
00236   PIXEL * pData;
00237   int x_phys, y_phys;
00238   DRIVER_CONTEXT * pContext;
00239 
00240   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00241   Pixels = *p;
00242   CurrentPixel = Diff;
00243   x += Diff;
00244   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00245   pData = XY2PTR(x_phys, y_phys);
00246   switch (GUI_pContext->DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
00247   case 0:
00248     if (pTrans) {
00249       do {
00250         Shift = (1 - CurrentPixel) << 2;
00251         Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
00252         PixelIndex = *(pTrans + Index);
00253         *pData = (PIXEL)PixelIndex;
00254         pData += pContext->PixelOffset;
00255         if (++CurrentPixel == 2) {
00256           CurrentPixel = 0;
00257           Pixels = *(++p);
00258         }
00259       } while (--xsize);
00260     } else {
00261       do {
00262         Shift = (1 - CurrentPixel) << 2;
00263         Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
00264         *pData = (PIXEL)Index;
00265         pData += pContext->PixelOffset;
00266         if (++CurrentPixel == 2) {
00267           CurrentPixel = 0;
00268           Pixels = *(++p);
00269         }
00270       } while (--xsize);
00271     }
00272     break;
00273   case LCD_DRAWMODE_TRANS:
00274     if (pTrans) {
00275       do {
00276         Shift = (1 - CurrentPixel) << 2;
00277         Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
00278         if (Index) {
00279           PixelIndex = *(pTrans + Index);
00280           *pData = (PIXEL)PixelIndex;
00281         }
00282         pData += pContext->PixelOffset;
00283         if (++CurrentPixel == 2) {
00284           CurrentPixel = 0;
00285           Pixels = *(++p);
00286         }
00287       } while (--xsize);
00288     } else {
00289       do {
00290         Shift = (1 - CurrentPixel) << 2;
00291         Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
00292         if (Index) {
00293           *pData = (PIXEL)Index;
00294         }
00295         pData += pContext->PixelOffset;
00296         if (++CurrentPixel == 2) {
00297           CurrentPixel = 0;
00298           Pixels = *(++p);
00299         }
00300       } while (--xsize);
00301     }
00302     break;
00303   }
00304 }
00305 
00306 /*********************************************************************
00307 *
00308 *       Draw Bitmap 8 BPP
00309 */
00310 static void _DrawBitLine8BPP(GUI_DEVICE * pDevice, int x, int y, U8 const * p, int xsize, const LCD_PIXELINDEX * pTrans) {
00311   LCD_PIXELINDEX Pixel;
00312   PIXEL * pData;
00313   int x_phys, y_phys;
00314   DRIVER_CONTEXT * pContext;
00315 
00316   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00317   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00318   pData = XY2PTR(x_phys, y_phys);
00319   switch (GUI_pContext->DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
00320   case 0:
00321     if (pTrans) {
00322       do {
00323         Pixel = *p++;
00324         *pData = (PIXEL)*(pTrans + Pixel);
00325         pData += pContext->PixelOffset;
00326       } while (--xsize);
00327     } else {
00328       do {
00329         *pData = (PIXEL)*p++;
00330         pData += pContext->PixelOffset;
00331       } while (--xsize);
00332     }
00333     break;
00334   case LCD_DRAWMODE_TRANS:
00335     if (pTrans) {
00336       do {
00337         Pixel = *p++;
00338         if (Pixel) {
00339           *pData = (PIXEL)*(pTrans + Pixel);
00340         }
00341         pData += pContext->PixelOffset;
00342       } while (--xsize);
00343     } else {
00344       do {
00345         Pixel = *p++;
00346         if (Pixel) {
00347           *pData = (PIXEL)Pixel;
00348         }
00349         pData += pContext->PixelOffset;
00350       } while (--xsize);
00351     }
00352     break;
00353   }
00354 }
00355 
00356 /*********************************************************************
00357 *
00358 *       Draw Bitmap 16 BPP
00359 */
00360 static void _DrawBitLine16BPP(GUI_DEVICE * pDevice, int x, int y, U16 const * p, int xsize) {
00361   PIXEL * pData;
00362   int x_phys, y_phys, PixelOffset;
00363   DRIVER_CONTEXT * pContext;
00364 
00365   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00366   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00367   pData = XY2PTR(x_phys, y_phys);
00368   PixelOffset = pContext->PixelOffset;
00369   do {
00370     *pData = (PIXEL)*p++;
00371     pData += PixelOffset;
00372   } while (--xsize);
00373 }
00374 
00375 /*********************************************************************
00376 *
00377 *       Draw Bitmap 32 BPP
00378 */
00379 static void _DrawBitLine32BPP(GUI_DEVICE * pDevice, int x, int y, U32 const * p, int xsize) {
00380   PIXEL * pData;
00381   int x_phys, y_phys, PixelOffset;
00382   DRIVER_CONTEXT * pContext;
00383 
00384   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00385   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00386   pData = XY2PTR(x_phys, y_phys);
00387   PixelOffset = pContext->PixelOffset;
00388   do {
00389     *pData = (PIXEL)*p++;
00390     pData += PixelOffset;
00391   } while (--xsize);
00392 }
00393 
00394 /*********************************************************************
00395 *
00396 *       Static code: API functions for drawing operations, no cache
00397 *
00398 **********************************************************************
00399 */
00400 /*********************************************************************
00401 *
00402 *       _DrawBitmap_CX
00403 */
00404 static void _DrawBitmap_CX(GUI_DEVICE * pDevice, int x0, int y0,
00405                        int xSize, int ySize,
00406                        int BitsPerPixel,
00407                        int BytesPerLine,
00408                        const U8 * pData, int Diff,
00409                        const LCD_PIXELINDEX * pTrans) {
00410   int x0_phys, y0_phys, x1_phys, y1_phys;
00411   int i;
00412   PIXEL * pDataBM;
00413   DRIVER_CONTEXT * pContext;
00414 
00415   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00416   switch (BitsPerPixel) {
00417   case 1:
00418     for (i = 0; i < ySize; i++) {
00419       _DrawBitLine1BPP(pDevice, x0, i + y0, pData, Diff, xSize, pTrans);
00420       pData += BytesPerLine;
00421     }
00422     break;
00423   case 2:
00424     for (i = 0; i < ySize; i++) {
00425       _DrawBitLine2BPP(pDevice, x0, i + y0, pData, Diff, xSize, pTrans);
00426       pData += BytesPerLine;
00427     }
00428     break;
00429   case 4:
00430     for (i = 0; i < ySize; i++) {
00431       _DrawBitLine4BPP(pDevice, x0, i + y0, pData, Diff, xSize, pTrans);
00432       pData += BytesPerLine;
00433     }
00434     break;
00435   case 8:
00436     for (i = 0; i < ySize; i++) {
00437       _DrawBitLine8BPP(pDevice, x0, i + y0, pData, xSize, pTrans);
00438       pData += BytesPerLine;
00439     }
00440     break;
00441   case 16:
00442     for (i = 0; i < ySize; i++) {
00443       _DrawBitLine16BPP(pDevice, x0, i + y0, (U16 *)pData, xSize);
00444       pData += BytesPerLine;
00445     }
00446     break;
00447   case 32:
00448     for (i = 0; i < ySize; i++) {
00449       _DrawBitLine32BPP(pDevice, x0, i + y0, (U32 *)pData, xSize);
00450       pData += BytesPerLine;
00451     }
00452     break;
00453   }
00454 
00455   pContext->pfLog2Phys(pContext, x0 + Diff,             y0,             &x0_phys, &y0_phys);
00456   pContext->pfLog2Phys(pContext, x0 + Diff + xSize - 1, y0 + ySize - 1, &x1_phys, &y1_phys);
00457   _Sort(&x0_phys, &x1_phys);
00458   _Sort(&y0_phys, &y1_phys);
00459   pDataBM = XY2PTR(x0_phys, y0_phys);
00460   pDevice = pDevice->pNext;
00461   pDevice->pDeviceAPI->pfDrawBitmap(pDevice,
00462                                     x0_phys, y0_phys,
00463                                     x1_phys - x0_phys + 1,
00464                                     y1_phys - y0_phys + 1,
00465                                     pContext->pDrawingAPI->BytesPerPixel << 3,
00466                                     pContext->pDrawingAPI->BytesPerPixel * pContext->vxSize,
00467                                     (U8 *)pDataBM, 0, NULL);
00468 }
00469 
00470 /*********************************************************************
00471 *
00472 *       _GetPixelIndex_CX
00473 */
00474 static LCD_PIXELINDEX _GetPixelIndex_CX(GUI_DEVICE * pDevice, int x, int y) {
00475   PIXEL * pData;
00476   PIXEL Pixel;
00477   int x_phys, y_phys;
00478   DRIVER_CONTEXT * pContext;
00479 
00480   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00481   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00482   pData = XY2PTR(x_phys, y_phys);
00483   Pixel = *pData;
00484   return Pixel;
00485 }
00486 
00487 /*********************************************************************
00488 *
00489 *       _SetPixelIndex_CX
00490 */
00491 static void _SetPixelIndex_CX(GUI_DEVICE * pDevice, int x, int y, LCD_PIXELINDEX PixelIndex) {
00492   PIXEL * pData;
00493   int x_phys, y_phys;
00494   DRIVER_CONTEXT * pContext;
00495 
00496   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00497   pContext->pfLog2Phys(pContext, x, y, &x_phys, &y_phys);
00498   pData = XY2PTR(x_phys, y_phys);
00499   *pData = (PIXEL)PixelIndex;
00500   pDevice = pDevice->pNext;
00501   pDevice->pDeviceAPI->pfSetPixelIndex(pDevice, x_phys, y_phys, PixelIndex);
00502 }
00503 
00504 /*********************************************************************
00505 *
00506 *       _XorPixel_CX
00507 */
00508 static void _XorPixel_CX(GUI_DEVICE * pDevice, int x, int y) {
00509   PIXEL Pixel, IndexMask;
00510 
00511   IndexMask = (PIXEL)pDevice->pColorConvAPI->pfGetIndexMask();
00512   Pixel = (PIXEL)pDevice->pDeviceAPI->pfGetPixelIndex(pDevice, x, y);
00513   Pixel ^= IndexMask;
00514   pDevice->pDeviceAPI->pfSetPixelIndex(pDevice, x, y, Pixel);
00515 }
00516 
00517 /*********************************************************************
00518 *
00519 *       _DrawHLine_CX
00520 */
00521 static void _DrawHLine_CX(GUI_DEVICE * pDevice, int x0, int y, int x1) {
00522   pDevice->pDeviceAPI->pfFillRect(pDevice, x0, y, x1, y);
00523 }
00524 
00525 /*********************************************************************
00526 *
00527 *       _DrawVLine_CX
00528 */
00529 static void _DrawVLine_CX(GUI_DEVICE * pDevice, int x, int y0, int y1) {
00530   pDevice->pDeviceAPI->pfFillRect(pDevice, x, y0, x, y1);
00531 }
00532 
00533 /*********************************************************************
00534 *
00535 *       _FillRect_CX
00536 */
00537 static void _FillRect_CX(GUI_DEVICE * pDevice, int x0, int y0, int x1, int y1) {
00538   PIXEL * pData;
00539   PIXEL * pLine;
00540   PIXEL * pPixel;
00541   PIXEL Pixel, IndexMask;
00542   int x0_phys, y0_phys, x1_phys, y1_phys;
00543   int NumPixels, NumLines;
00544   DRIVER_CONTEXT * pContext;
00545 
00546   pContext = (DRIVER_CONTEXT *)pDevice->u.pContext;
00547   pContext->pfLog2Phys(pContext, x0, y0, &x0_phys, &y0_phys);
00548   pContext->pfLog2Phys(pContext, x1, y1, &x1_phys, &y1_phys);
00549   _Sort(&x0_phys, &x1_phys);
00550   _Sort(&y0_phys, &y1_phys);
00551   pData = pLine = XY2PTR(x0_phys, y0_phys);
00552   NumLines = y1_phys - y0_phys + 1;
00553   if (GUI_pContext->DrawMode & LCD_DRAWMODE_XOR) {
00554     IndexMask = (PIXEL)pDevice->pColorConvAPI->pfGetIndexMask();
00555     do {
00556       pPixel    = pLine;
00557       NumPixels = x1_phys - x0_phys + 1;
00558       do {
00559         *pPixel++ ^= IndexMask;
00560       } while (--NumPixels);
00561       pLine += pContext->vxSize;
00562     } while (--NumLines);
00563   } else {
00564     Pixel = (PIXEL)LCD__GetColorIndex();
00565     if (sizeof(Pixel) == 1) {
00566       NumPixels = x1_phys - x0_phys + 1;
00567       do {
00568         GUI_MEMSET((U8 *)pLine, (U8)Pixel, NumPixels);
00569         pLine += pContext->vxSize;
00570       } while (--NumLines);
00571     } else {
00572       do {
00573         pPixel    = pLine;
00574         NumPixels = x1_phys - x0_phys + 1;
00575         do {
00576           *pPixel++ = Pixel;
00577         } while (--NumPixels);
00578         pLine += pContext->vxSize;
00579       } while (--NumLines);
00580     }
00581   }
00582   pDevice = pDevice->pNext;
00583   pDevice->pDeviceAPI->pfDrawBitmap(pDevice,
00584                                     x0_phys, y0_phys,
00585                                     x1_phys - x0_phys + 1,
00586                                     y1_phys - y0_phys + 1,
00587                                     pContext->pDrawingAPI->BytesPerPixel << 3,
00588                                     pContext->pDrawingAPI->BytesPerPixel * pContext->vxSize,
00589                                     (U8 *)pData, 0, NULL);
00590 }
00591 
00592 /*********************************************************************
00593 *
00594 *       Static data: Drawing API(s)
00595 *
00596 **********************************************************************
00597 */
00598 /*********************************************************************
00599 *
00600 *       GUI_OrientationAPI_CX
00601 */
00602 const GUI_ORIENTATION_API API_NAME = {
00603   _DrawBitmap_CX,
00604   _DrawHLine_CX,
00605   _DrawVLine_CX,
00606   _FillRect_CX,
00607   _GetPixelIndex_CX,
00608   _SetPixelIndex_CX,
00609   _XorPixel_CX,
00610   BYTES_PER_PIXEL
00611 };
00612 
00613 /*************************** End of file ****************************/