开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
LCD13XX.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：110k
源码类别：

uCOS

开发平台：

C/C++

LCD13XX.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/GUI
  4. *                        Universal graphic software for embedded applications
  5. *
  6. *                       (c) Copyright 2002, Micrium Inc., Weston, FL
  7. *                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
  8. *
  9. *              礐/GUI is protected by international copyright laws. Knowledge of the
  10. *              source code may not be used to write a similar product. This file may
  11. *              only be used in accordance with a license and should not be redistributed
  12. *              in any way. We appreciate your understanding and fairness.
  13. *
  14. ----------------------------------------------------------------------
  15. File        : LCD13XX.C
  16. Purpose     : Driver for LCDs using a single Seiko Epson SED13XX controllers
  17.               This version supports a single LCD controller
  18.               in (almost) any hardware configuration. The following
  19.               derivatives are currently supported:
  20.               SED1352
  21.               SED1354
  22.               SED1356     (With/Without BitBlt engine support)
  23.               SED1374
  24.               SED1375
  25.               SED13806
  26.               Other Epson LCD controllers are very similar and could
  27.               be covered by this driver as well, but have not been
  28.               tested.
  29. ----------------------------------------------------------------------   
  30. ---------------------------LIST OF CONFIG SWITCHES--------------------
  31. The following is a list of additional configuration switches for this
  32. driver. These switches might not be listed in the manual, because
  33. the manual mainly covers the general config switches which are
  34. supported by all drivers.
  35. ----------------------------------------------------------------------
  36. define ----------------------Explanation------------------------------
  37. LCD_SWAP_BYTE_ORDER          Activate if high low bytes are swapped
  38.                              Default: 0
  39. LCD_WRITE_MEM32(Off,Data32)  This macro accelerates display access
  40.                              if defined by allowing the CPU to write
  41.                              32 bits at a time to the controller.
  42.                              (For 32 bits CPUs only and only if the
  43.                              BUS interface unit can automatically
  44.                              convert this to 2 16 bit accesses
  45. LCD_OPTIMIZE                 Controls the use of optimized routines.
  46.                              If 1, several (speed) optimizations are used.
  47.                              Default: ON (1)
  48. LCD_USE_BITBLT               This switch controls the use of optimized routines
  49.                               with SED1356 bitblt engine.
  50.                              If 1, the optimized routines with bitblt access are used.
  51.                              The default value depends of LCD_BITSPERPIXEL: (4  ) -> 0, (8,15) -> 1
  52. LCD_ENABLE_REG_ACCESS()    
  53. LCD_ENABLE_MEM_ACCESS()      In most systems (and with most LCD-controllers)
  54.                              registers / memory can be accessed at
  55.                              different addresses. However, in some
  56.                              systems, it could be necessary to exec
  57.                              code in order to be able to access the
  58.                              registers or memory. This code should
  59.                              then be placed in these macros (rather
  60.                              than the actual access macros, which
  61.                              would be slowed down)
  62. LCD_DATAADR                  define adress if video memory can be treated
  63.                              like regular memory
  64.                              (will speed up driver)
  65. ----------------------------------------------------------------------
  66. Known problems or limitations with current version
  67. ----------------------------------------------------------------------
  68. none
  69. ----------------------------------------------------------------------
  70. Open issues
  71. ----------------------------------------------------------------------
  72. None
  73. ---------------------------END-OF-HEADER------------------------------
  74. */
  76. #include <stddef.h>           /* needed for definition of NULL */
  77. #include "LCD_Private.H"      /* private modul definitions & config */
  78. #include "GUI_Private.H"
  79. #include "GUIDebug.h"
  80. #include "LCD_0.h"            /* Defines for first display */
  82. // extern U8  LCD_Buffer [LCD_XSIZE*LCD_YSIZE];
  83. extern U8  LCD_Buffer [];
  85. // 对 Video RAM 区的读写操作.
  86. #define LCD_READ_MEM(Off)            LCD_Buffer[Off]
  87. #define LCD_WRITE_MEM(Off,data)      LCD_Buffer[Off]=data
  88. #define LCD_READ_REG(Off)            0
  89. #define LCD_WRITE_REG(Off,data)      
  91. #if (LCD_CONTROLLER/100 == 13) && (LCD_CONTROLLER/10 != 133) 
  92.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  94. /*
  95.         *********************************************************
  96.         *                                                       *
  97.         *           Compiler specific settings                  *
  98.         *                                                       *
  99.         *********************************************************
  100. */
  101. #ifdef WIN32   /* Avoid warnings in MS-compiler */
  102.   #pragma warning(disable : 4244)  // warning C4244: '=' : conversion from 'long ' to 'unsigned char ', possible loss of data
  103.   #pragma warning(disable : 4761)  // warning C4761: integral size mismatch in argument; conversion supplied
  104. #endif
  106. /*
  107. *********************************************************
  108. *
  109. *           Controller renumbering
  110. *
  111. *********************************************************
  113.   EPSON decided to rename all of their controllers. In order to
  114.   be able to work with old and new numbers, we simply map the old ones
  115.   to the new ones.
  116. */
  117. #if LCD_CONTROLLER == 1386
  118.   #undef LCD_CONTROLLER
  119.   #define LCD_CONTROLLER 13806
  120. #endif
  122. /*
  123.         *********************************************************
  124.         *                                                       *
  125.         *           Defaults for configuration                  *
  126.         *                                                       *
  127.         *********************************************************
  129. */
  131. /* Switch for support of multiple pages.
  132.  Only available with certain LCD-controllers */
  133. #ifndef LCD_SUPPORT_PAGING
  134.   #define LCD_SUPPORT_PAGING            (0)
  135. #endif
  137. #ifndef LCD_SCHEDULE_CNT
  138.   #define LCD_SCHEDULE_CNT              (0)
  139. #endif
  141. #ifndef LCD_NUM_CONTROLLERS
  142.   #define LCD_NUM_CONTROLLERS           (1)
  143. #endif
  145. #ifndef LCD_BUSWIDTH
  146.   #define LCD_BUSWIDTH                  (16)
  147. #endif
  149. #ifndef LCD_OPTIMIZE
  150.   #define LCD_OPTIMIZE                (1)
  151. #endif
  153. #if (LCD_CONTROLLER == 1356) || (LCD_CONTROLLER == 13806)
  154.   #ifndef LCD_USE_BITBLT
  155.     #if ((LCD_BITSPERPIXEL == 16) || (LCD_BITSPERPIXEL == 8 )) && (LCD_MIRROR_Y == 0) && (LCD_SWAP_XY  == 0)
  156.       #define LCD_USE_BITBLT            (1)
  157.     #else
  158.       #define LCD_USE_BITBLT            (0)
  159.     #endif
  160.   #else
  161.     #if (LCD_MIRROR_Y)
  162.       #error BITBLT engine does not support LCD_MIRROR_Y = 1!
  163.     #endif
  164.     #if (LCD_SWAP_XY)
  165.       #error BITBLT engine does not support LCD_SWAP_XY = 1!
  166.     #endif
  167.   #endif
  168. #else
  169.   #define LCD_USE_BITBLT                (0)
  170. #endif
  172. #ifndef LCD_ENABLE_REG_ACCESS
  173.   #define LCD_ENABLE_REG_ACCESS()
  174. #endif
  176. #ifndef LCD_ENABLE_MEM_ACCESS
  177.   #define LCD_ENABLE_MEM_ACCESS()
  178. #endif
  180. #ifndef STATIC
  181.   #define STATIC static
  182. #endif
  185. /*
  186.         *********************************************************
  187.         *                                                       *
  188.         *           Defines for configuration simulation        *
  189.         *                                                       *
  190.         *********************************************************
  191. */
  192. #if defined(WIN32) && !defined(USE_PC_HARDWARE)
  193.   void SIM_WriteMem8(unsigned int Off, int Data);
  194.   void SIM_WriteReg8(unsigned int Off, int Data);
  195.   int  SIM_ReadMem8(unsigned int Off);
  196.   int  SIM_ReadReg8(unsigned int Off);
  197.   void SIM_WriteMem16(unsigned int Off, int Data);
  198.   void SIM_WriteReg16(unsigned int Off, int Data);
  199.   int  SIM_ReadMem16(unsigned int Off);
  200.   int  SIM_ReadReg16(unsigned int Off);
  202.   #undef  LCD_READ_MEM
  203.   #undef  LCD_READ_REG
  204.   #undef  LCD_WRITE_MEM
  205.   #undef  LCD_WRITE_REG
  207.   #if LCD_BUSWIDTH==8
  208.     #define LCD_READ_MEM(Off)       SIM_ReadMem8(Off)
  209.     #define LCD_WRITE_MEM(Off,Data) SIM_WriteMem8(Off, Data)
  210.     #define LCD_READ_REG(Off)       SIM_ReadReg8(Off)
  211.     #define LCD_WRITE_REG(Off,Data) SIM_WriteReg8(Off, Data)
  212.   #elif LCD_BUSWIDTH==16
  213.     #define LCD_READ_MEM(Off)       SIM_ReadMem16(Off)
  214.     #define LCD_WRITE_MEM(Off,Data) SIM_WriteMem16(Off, Data)
  215.     #define LCD_READ_REG(Off)       SIM_ReadReg16(Off)
  216.     #define LCD_WRITE_REG(Off,Data) SIM_WriteReg16(Off, Data)
  217.   #endif
  218. #elif defined(WIN32) && defined(USE_PC_HARDWARE)
  219.   void PC_WriteMem8(unsigned int Off, int Data);
  220.   void PC_WriteReg8(unsigned int Off, int Data);
  221.   int  PC_ReadMem8(unsigned int Off);
  222.   int  PC_ReadReg8(unsigned int Off);
  223.   void PC_WriteMem16(unsigned int Off, int Data);
  224.   void PC_WriteReg16(unsigned int Off, int Data);
  225.   int  PC_ReadMem16(unsigned int Off);
  226.   int  PC_ReadReg16(unsigned int Off);
  228.   #undef  LCD_READ_MEM
  229.   #undef  LCD_READ_REG
  230.   #undef  LCD_WRITE_MEM
  231.   #undef  LCD_WRITE_REG
  232.   #if LCD_BUSWIDTH==8
  233.     #define LCD_READ_MEM(Off)       PC_ReadMem8(Off)
  234.     #define LCD_WRITE_MEM(Off,Data) PC_WriteMem8(Off, Data)
  235.     #define LCD_READ_REG(Off)       PC_ReadReg8(Off)
  236.     #define LCD_WRITE_REG(Off,Data) PC_WriteReg8(Off, Data)
  237.   #else
  238.     #define LCD_READ_MEM(Off)       PC_ReadMem16(Off)
  239.     #define LCD_WRITE_MEM(Off,Data) PC_WriteMem16(Off, Data)
  240.     #define LCD_READ_REG(Off)       PC_ReadReg16(Off)
  241.     #define LCD_WRITE_REG(Off,Data) PC_WriteReg16(Off, Data)
  242.   #endif
  243. #endif
  245. /********************************************************
  246. *
  247. *           Remap Hardware macros
  248. *
  249. *********************************************************
  250. */
  252. #if LCD_NUM_DISPLAYS ==1 /* Use single display macros */
  253. #else
  254.   #if LCD_DISPLAY_INDEX == 0     /* First display in a multi-display configuration */
  255.     #define LCD_READ_MEM(Off)       LCD_READ_MEM_0(Off)
  256.     #define LCD_WRITE_MEM(Off,Data) LCD_WRITE_MEM_0(Off,Data)
  257.     #define LCD_READ_REG(Off)       LCD_READ_REG_0(Off)
  258.     #define LCD_WRITE_REG(Off,Data) LCD_WRITE_REG_0(Off,Data)
  259.     #define LCD_INIT_CONTROLLER     LCD_INIT_CONTROLLER_0
  260.   #else
  261.     #define LCD_READ_MEM(Off)       LCD_READ_MEM_1(Off)
  262.     #define LCD_WRITE_MEM(Off,Data) LCD_WRITE_MEM_1(Off,Data)
  263.     #define LCD_READ_REG(Off)       LCD_READ_REG_1(Off)
  264.     #define LCD_WRITE_REG(Off,Data) LCD_WRITE_REG_1(Off,Data)
  265.     #define LCD_INIT_CONTROLLER     LCD_INIT_CONTROLLER_1
  266.   #endif
  267. #endif
  269. /*
  270.         *********************************************************
  271.         *                                                       *
  272.         *          Internal types                               *
  273.         *                                                       *
  274.         *********************************************************
  275. */
  277. /*
  278.         *********************************************************
  279.         *                                                       *
  280.         *          SCHEDULING                                   *
  281.         *                                                       *
  282.         *********************************************************
  283. */
  285. #if (LCD_SCHEDULE_CNT !=0)
  286.   static int ScheduleCntRem=LCD_SCHEDULE_CNT;
  287.   #define CHECK_SCHEDULE(PixelCnt)                              
  288.           if ((ScheduleCntRem-=(PixelCnt)) <=0) {               
  289.             ScheduleCntRem=LCD_SCHEDULE_CNT;                    
  290.             LCD_SCHEDULE();                                     
  291.           }
  292. #else
  293.   #define CHECK_SCHEDULE(PixelCnt)
  294. #endif
  296. /*
  297.         *********************************************************
  298.         *                                                       *
  299.         *           Macro calculations                          *
  300.         *                                                       *
  301.         *********************************************************
  302. */
  304. /* To make life easier, assign physical x/y size */
  306. #if !LCD_SWAP_XY
  307.   #define LCD_XSIZE_P   LCD_XSIZE
  308.   #define LCD_YSIZE_P   LCD_YSIZE
  309.   #define LCD_VXSIZE_P  LCD_VXSIZE
  310.   #define LCD_VYSIZE_P  LCD_VYSIZE
  311. #else
  312.   #define LCD_XSIZE_P   LCD_YSIZE
  313.   #define LCD_YSIZE_P   LCD_XSIZE
  314.   #define LCD_VXSIZE_P  LCD_VYSIZE
  315.   #define LCD_VYSIZE_P  LCD_VXSIZE
  316. #endif
  318. #if   LCD_BITSPERPIXEL == 1
  319.   #define BYTESPERLINE  (LCD_VXSIZE_P/8)
  320.   #define WORDSPERLINE  (LCD_VXSIZE_P/16)
  321. #elif   LCD_BITSPERPIXEL == 2
  322.   #define BYTESPERLINE  (LCD_VXSIZE_P/4)
  323.   #define WORDSPERLINE  (LCD_VXSIZE_P/8)
  324. #elif   LCD_BITSPERPIXEL == 4
  325.   #define BYTESPERLINE  (LCD_VXSIZE_P/2)
  326.   #define WORDSPERLINE  (LCD_VXSIZE_P/4)
  327. #elif LCD_BITSPERPIXEL == 8
  328.   #define BYTESPERLINE  (LCD_VXSIZE_P)
  329.   #define WORDSPERLINE  (LCD_VXSIZE_P/2)
  330. #elif  (LCD_BITSPERPIXEL == 15)
  331.   #define BYTESPERLINE  (LCD_VXSIZE_P*2)
  332.   #define WORDSPERLINE  (LCD_VXSIZE_P)
  333. #elif  (LCD_BITSPERPIXEL == 16)
  334.   #define BYTESPERLINE  (LCD_VXSIZE_P*2)
  335.   #define WORDSPERLINE  (LCD_VXSIZE_P)
  336. #else
  337.   #error This colordepth is not supported !!!
  338. #endif
  340. #ifndef LCD_USE_32BIT_OFF
  341.   #if ((WORDSPERLINE * LCD_YSIZE) > 0xFFFF)
  342.     #define LCD_USE_32BIT_OFF 1
  343.   #else
  344.     #define LCD_USE_32BIT_OFF 0
  345.   #endif
  346. #endif
  348. #if LCD_USE_32BIT_OFF
  349.   typedef unsigned long tOff;
  350. #else
  351.   typedef unsigned int  tOff;
  352. #endif
  354. /*
  355.         *********************************************************
  356.         *                                                       *
  357.         *              Macros, standard                         *
  358.         *                                                       *
  359.         *********************************************************
  361. These macros can be found in any LCD-driver as they serve purposes
  362. that can be found in any class of LCD-driver (Like clipping).
  363. */
  365. #define BKCOLOR LCD_BKCOLORINDEX
  366. #define   COLOR LCD_COLORINDEX
  368. /*
  369.         *********************************************************
  370.         *                                                       *
  371.         *      Configuration switch checking                    *
  372.         *                                                       *
  373.         *********************************************************
  375. Please be aware that not all configuration errors can be captured !
  377. */
  379. /* Check number of controllers */
  380. #if ((LCD_NUM_CONTROLLERS >1) || (LCD_NUM_CONTROLLERS <0))
  381.   #error "More than 1 controller not supported by this driver"
  382. #endif
  384. #if ((LCD_CONTROLLER==1356)||(LCD_CONTROLLER==13806)) && (LCD_BUSWIDTH !=16)
  385.   #error This controller does not work with 8-bit bus
  386. #endif
  388. #if (((LCD_CONTROLLER==1356)||(LCD_CONTROLLER==13806)) && LCD_USE_BITBLT && ((LCD_BITSPERPIXEL != 8) && (LCD_BITSPERPIXEL != 16)))
  389.   #error BitBlt-Access only available for 8bpp and 16bpp mode
  390. #endif
  392. #if (LCD_CONTROLLER==1374)
  393.   #if (LCD_BITSPERPIXEL == 8)
  394.     #if (LCD_FIXEDPALETTE != 233)
  395.       #error This controller supports only 233 palette in 8 bpp mode !
  396.     #endif
  397.   #endif
  398. #endif
  404. /*
  405.         *********************************************************
  406.         *                                                       *
  407.         *       Macros for internal use                         *
  408.         *                                                       *
  409.         *********************************************************
  410. */
  412. #if !defined (LCD_LUT_COM)
  413.   #define LINE2COM(y) y
  414. #else
  415.   #define LINE2COM(y) LCD__aLine2Com0[y]
  416. #endif
  418. #if LCD_BUSWIDTH == 16
  419.   #if   (LCD_BITSPERPIXEL == 16)
  420.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x))
  421.   #elif (LCD_BITSPERPIXEL == 15)
  422.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x))
  423.   #elif (LCD_BITSPERPIXEL ==  8)
  424.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x>>1))
  425.   #elif (LCD_BITSPERPIXEL ==  4)
  426.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x>>2))
  427.   #elif (LCD_BITSPERPIXEL ==  2)
  428.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+((x)>>3))
  429.   #elif (LCD_BITSPERPIXEL ==  1)
  430.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+((x)>>4))
  431.   #endif
  432. #else
  433.   #if   (LCD_BITSPERPIXEL == 16)
  434.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)<<1))
  435.   #elif (LCD_BITSPERPIXEL == 15)
  436.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)<<1))
  437.   #elif (LCD_BITSPERPIXEL ==  8)
  438.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+(x))
  439.   #elif (LCD_BITSPERPIXEL ==  4)
  440.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>1))
  441.   #elif (LCD_BITSPERPIXEL ==  2)
  442.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>2))
  443.   #elif (LCD_BITSPERPIXEL ==  1)
  444.     #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>3))
  445.   #endif
  446. #endif
  448. //#if ((LCD_SWAP_BYTE_ORDER) && (LCD_BITSPERPIXEL <=8)) | ((LCD_SWAP_BYTE_ORDER==0) && (LCD_BITSPERPIXEL  > 8))
  449. //  #define READ_MEM(Off, Data)  Data = LCD_READ_MEM(Off); Data = ((Data & 0xff) << 8) + (Data >> 8)
  450. //  #define WRITE_MEM(Off, Data) LCD_WRITE_MEM(Off, (U16)(((Data & 0xff) << 8) + ((Data & 0xff00) >> 8)))
  451. //#else
  452.   #define READ_MEM(Off, Data)  Data = LCD_READ_MEM(Off)
  453.   #define WRITE_MEM(Off, Data) LCD_WRITE_MEM(Off, Data)
  454. //#endif
  456. #if (LCD_SWAP_BYTE_ORDER)
  457.   #define READ_REG(Off, Data)  Data = LCD_READ_REG(Off)
  458.   #define WRITE_REG(Off, Data) LCD_WRITE_REG(Off, Data)
  459. #else
  460.   #define READ_REG(Off, Data)  { Data = Swap(LCD_READ_REG(Off)); }
  461.   #define WRITE_REG(Off, Data) { LCD_WRITE_REG(Off, Swap(Data)); }
  462.   #define REQUIRE_SWAP
  463. #endif
  465. /* No use of LCD_WRITE_MEM, LCD_READ_MEM, LCD_WRITE_REG, LCD_READ_REG from this point */
  467. #if defined (LCD_LUT_COM)
  468.   #if (LCD_MIRROR_Y)
  469.     #error LCD_MIRROR_Y not supported with COMTrans !
  470.   #endif
  471.   #if (LCD_MIRROR_X)
  472.     #error LCD_MIRROR_X not supported with COMTrans !
  473.   #endif
  474. #endif
  476. #if (!defined(LCD_LUT_SEG))
  477.   #if   (!LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  478.     #define PHYS2LOG(x, y) x, y
  479.   #elif (!LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  480.     #define PHYS2LOG(x, y) y, x
  481.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  482.     #define PHYS2LOG(x, y) x, LCD_YSIZE - 1 - (y)
  483.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  484.     #define PHYS2LOG(x, y) LCD_YSIZE - 1 - (y), x
  485.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  486.     #define PHYS2LOG(x, y) LCD_XSIZE - 1 - (x), y
  487.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  488.     #define PHYS2LOG(x, y) LCD_YSIZE - 1 - (y), x
  489.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  490.     #define PHYS2LOG(x, y) LCD_XSIZE - 1 - (x), LCD_YSIZE - 1 - (y)
  491.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  492.     #error This combination of mirroring/swapping not yet supported
  493.   #endif
  494. #else
  495.   #define PHYS2LOG(x, y) LCD__aCol2Seg0[x], y
  496. #endif
  498. #define SETPIXEL(x, y, c)  _SetPixel    (PHYS2LOG(x, y), c)
  499. #define GETPIXEL(x, y)     GetPixelIndex(PHYS2LOG(x, y))
  500. #define XORPIXEL(x, y)     XorPixel     (PHYS2LOG(x, y))
  502. /*
  503.         *********************************************************
  504.         *                                                       *
  505.         *       Register access routines                        *
  506.         *                                                       *
  507.         *********************************************************
  508. */
  509. #if defined(LCD_READ_REG)
  510. #if (LCD_BUSWIDTH == 8)
  511.   #define READ_REG_BYTE(Off) LCD_READ_REG(Off)
  512. #else
  513.   #define READ_REG_BYTE(Off) ReadRegByte(Off)
  514. U8 ReadRegByte(int Off) {
  515.   U16 Data = LCD_READ_REG((Off>>1));
  516.   #if LCD_SWAP_BYTE_ORDER
  517.     return (Off&1) ? Data>>8 : Data&255;
  518.   #else
  519.     return (Off&1) ? Data&255 : Data>>8;
  520.   #endif
  521. }
  522. #endif  
  523. #endif
  527. /*
  528. *********************************************************
  529. *                                                       *
  530. *       Static routines
  531. *                                                       *
  532. *********************************************************
  533. */
  534. #ifdef REQUIRE_SWAP
  535. U16 Swap(U16 Data) {
  536.   return (Data<<8) | (Data>>8);
  537. }
  538. #endif
  546. /*
  547.         *********************************************************
  548.         *                                                       *
  549.         *       Next pixel routines                             *
  550.         *                                                       *
  551.         *********************************************************
  552. */
  554. #if      (LCD_OPTIMIZE)             
  555.       && (LCD_BUSWIDTH == 8)        
  556.       && (!LCD_MIRROR_X)             
  557.       && (!LCD_MIRROR_Y)            
  558.       && (LCD_SWAP_XY)              
  559.       && (!defined (LCD_LUT_COM))    
  560.       && (!defined (LCD_LUT_SEG))    
  561.       && (LCD_BITSPERPIXEL == 4)
  563. static int CurPosY;    /* Physical x position !!! */
  564. static tOff CurOff;
  566. static void SetPosXY(int x, int y) {
  567.   y = LCD_YSIZE-1-y;
  568.   CurPosY = y;
  569.   CurOff = XY2OFF(y,x);
  570. }
  572. static void SetNextPixel(LCD_PIXELINDEX c) {
  573.   U8 Data;
  574.   READ_MEM(CurOff, Data);
  575.   if (CurPosY&1) {
  576.     Data = (Data & ~(15<<0)) | (c<<0);
  577.     CurOff++;
  578.   } else {
  579.     Data = (Data & ~(15<<4)) | (c<<4);
  580.   }
  581.   WRITE_MEM(CurOff, Data);
  582.   CurPosY++;
  583. }
  585. #elif      (LCD_OPTIMIZE)           
  586.       && (LCD_BUSWIDTH == 8)        
  587.       && (!LCD_MIRROR_X)            
  588.       && (!LCD_MIRROR_Y)            
  589.       && (!LCD_SWAP_XY)              
  590.       && (!defined (LCD_LUT_COM))    
  591.       && (!defined (LCD_LUT_SEG))    
  592.       && (LCD_BITSPERPIXEL == 4)
  594. static int CurPosX;    /* Physical x position !!! */
  595. static tOff CurOff;
  596. static U8  CurData;
  598. static void SetPosXY(int x, int y) {
  599.   CurPosX = x;
  600.   CurOff = XY2OFF(x,y);
  601.   CurData = LCD_READ_MEM(CurOff);
  602. }
  604. #define SETNEXTPIXEL(c) {                           
  605.   if (CurPosX&1) {                                  
  606.     CurData = (CurData & ~(15<<0)) | (c<<0);        
  607.     WRITE_MEM(CurOff, CurData);                     
  608.     CurOff++;                                       
  609.     READ_MEM(CurOff, CurData);                      
  610.   } else {                                          
  611.     CurData = (CurData & ~(15<<4)) | (c<<4);        
  612.   }                                                 
  613.   CurPosX++;                                        
  614. }
  616. void SetNextPixel(int c) {
  617.   SETNEXTPIXEL(c);
  618. }
  620. #define END_SETNEXTPIXEL() if (CurPosX&1) WRITE_MEM(CurOff, CurData);
  622. #else
  623.   #define END_SETNEXTPIXEL()
  624. #endif
  626. /*
  627.         *********************************************************
  628.         *                                                       *
  629.         *       BitBlt access for SED1356/SED13806              *
  630.         *                                                       *
  631.         *********************************************************
  632. */
  634. #if LCD_USE_BITBLT                  
  635.     && (LCD_BUSWIDTH==16)           
  636.     && (!defined (LCD_LUT_COM))     
  637.     && (!defined (LCD_LUT_SEG))     
  638.     && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))
  640. #if LCD_BITSPERPIXEL == 8
  641.   #define BITBLT_SET_DESTINATION(x,y)     WRITE_REG(0x108 / 2, (((tOff)y * (tOff)BYTESPERLINE) + x)); 
  642.                                           WRITE_REG(0x10a / 2, (U32)(((tOff)y * (tOff)BYTESPERLINE) + x) >> 16)
  643.   #define BITBLT_SET_ACTIVE()             WRITE_REG(0x100 / 2, 0x0000); WRITE_REG(0x100 / 2, 0x0080)
  644. #elif LCD_BITSPERPIXEL == 16
  645.   #define BITBLT_SET_DESTINATION(x,y)     WRITE_REG(0x108 / 2, (((tOff)y * (tOff)BYTESPERLINE) + (x << 1))); 
  646.                                           WRITE_REG(0x10a / 2, (((tOff)y * (tOff)BYTESPERLINE) + (x << 1)) >> 16)
  647.   #define BITBLT_SET_ACTIVE()             WRITE_REG(0x100 / 2, 0x0100); WRITE_REG(0x100 / 2, 0x0180)
  648. #endif
  650. static void WaitForBltEnd(void) {
  651.   volatile U16 tmp;
  652.   do {
  653.     READ_REG(0x100 / 2, tmp);
  654.   } while (tmp & 0x80);
  655.   READ_REG(0x100000 / 2, tmp);                                            /* dummy read */
  656. }
  658. static void LCD_FillRectBB(int x0, int y0, int x1, int y1) {
  659.   LCD_ENABLE_REG_ACCESS(); {
  660.     for (;x0 <= x1; x0 += 1024) {
  661.       int _y0 = y0;
  662.       int _x1 = x1;
  663.       if (_x1 > (x0 + 1023)) {
  664.         _x1 = x0 + 1023;
  665.       }
  666.       for (;_y0 <= y1; _y0 += 1024) {
  667.         int _y1 = y1;
  668.         if (_y1 > (_y0 + 1023)) {
  669.           _y1 = _y0 + 1023;
  670.         }
  671.         BITBLT_SET_DESTINATION(x0, _y0);                                  /* set destination start address */
  672.         WRITE_REG(0x110 / 2, (_x1 - x0));                                 /* set width */
  673.         WRITE_REG(0x112 / 2, (_y1 - _y0));                                /* set height */
  674.         WRITE_REG(0x118 / 2, (COLOR));                                    /* set foreground color  */
  675.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  676.           WRITE_REG(0x102 / 2, 0x0605);                                   /* pattern fill, ~D   */
  677.         } else {
  678.           WRITE_REG(0x102 / 2, 0x0c00);                                   /* solid fill, no ROP */
  679.         }
  680.         BITBLT_SET_ACTIVE();                                              /* engage bitblt engine */
  681.         WaitForBltEnd();                                                  /* wait for pending blit to end */
  682.       }
  683.     }
  684.   } LCD_ENABLE_MEM_ACCESS();
  685. }
  687. static void LCD_DrawBitmap1BPPBB(int x, int y, U8 const*p, int Diff, int xsize, int ysize, int BytesPerLine, const LCD_PIXELINDEX*pTrans) {
  688.   volatile U16 tmp;
  689.   x+= Diff;
  690.   LCD_ENABLE_REG_ACCESS(); {
  691.     U16 StartBit = 7 - (Diff & 7);
  692.     U16 Data = StartBit | ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) ? 0x900 : 0x800);
  693.     int NumWords = ((Diff & 7) + xsize + 15) >> 4;
  694.     WRITE_REG(0x102 / 2, Data);                                           /* set start bit and operation */
  695.     WRITE_REG(0x104 / 2, 0);                                              /* set source start address */
  696.     BITBLT_SET_DESTINATION(x, y);                                         /* set destination start address */
  697.     WRITE_REG(0x110 / 2, (xsize - 1));                                    /* set width */
  698.     WRITE_REG(0x112 / 2, (ysize - 1));                                    /* set height */
  699.     WRITE_REG(0x114 / 2, (*(pTrans + 0)));                                /* set background color */
  700.     WRITE_REG(0x118 / 2, (*(pTrans + 1)));                                /* set foreground color  */
  701.     BITBLT_SET_ACTIVE();                                                  /* engage bitblt engine */
  702.     do {
  703.       READ_REG(0x100 / 2, tmp);
  704.     } while ((tmp & 0x80) == 0);
  705.     for (;ysize; ysize--, p += BytesPerLine) {
  706.       U8 const *pLine= p;
  707.       int i;
  708.       for (i = NumWords; i; i--, pLine += 2) {
  709.         do {
  710.           READ_REG(0x100 / 2, tmp);
  711.         } while ((tmp & 0x40) == 0x40);
  712.         WRITE_REG(0x100000 / 2, ((*pLine) | ((*(pLine + 1)) << 8)));      /* write data into FIFO */
  713.       }
  714.     }
  715.     WaitForBltEnd();                                                      /* wait for pending blit to end */
  716.   } LCD_ENABLE_MEM_ACCESS();
  717. }
  719. #endif
  722. /*
  723.         *********************************************************
  724.         *                                                       *
  725.         *       Internal set pixel routines                     *
  726.         *                                                       *
  727.         *********************************************************
  728. */
  730. static void _SetPixel(int x, int y, LCD_PIXELINDEX c) {
  731.   tOff Off = XY2OFF(x,y);
  732. #if LCD_BUSWIDTH == 16
  733.   #if LCD_BITSPERPIXEL == 1
  734.     U8 BitNo = (~x)&15;
  735.     U16 Data;
  736.     READ_MEM(Off, Data);
  737.     if (c)
  738.       Data |= c<<BitNo;
  739.     else
  740.       Data &= ~(1<<BitNo);      
  741.     WRITE_MEM(Off, Data);
  742.   #elif LCD_BITSPERPIXEL == 2
  743.     U16 Data;
  744.     U8 Shift = 14 - ((x & 7) << 1);
  745.     READ_MEM(Off, Data);
  746.     Data = (Data & ~(3 << Shift)) | (c << Shift);
  747.     WRITE_MEM(Off, Data);
  748.   #elif LCD_BITSPERPIXEL == 4
  749.     U8 Shift = ((~x)&3)<<2;         /* 12,8,4 or 0 */
  750.     U16 Data;
  751.     READ_MEM(Off, Data);
  752.     Data &= ~(15<<Shift);
  753. Data |= c<<Shift;
  754.     WRITE_MEM(Off, Data);
  755.   #elif LCD_BITSPERPIXEL == 8
  756.     U16 Data; 
  757.     READ_MEM(Off, Data);
  758.     switch (x&1) {
  759.     case 1:
  760.       Data = (Data & ~(0xff   )) | (c   );
  761.       break;
  762.     case 0:
  763.       Data = (Data & ~(0xff<<8)) | (c<<8);
  764.       break;
  765.     }
  766.     WRITE_MEM(Off, Data);
  767.   #elif (LCD_BITSPERPIXEL == 15) | (LCD_BITSPERPIXEL == 16)
  768.     WRITE_MEM(Off, c);
  769.   #else
  770.     #error unsupported LCD_BITSPERPIXEL
  771.   #endif
  772. #elif LCD_BUSWIDTH == 8
  773.   #if LCD_BITSPERPIXEL == 1
  774.     U8 Data;
  775.     U8 BitNo;
  776.     READ_MEM(Off, Data);
  777.     BitNo = 7-(x&7);
  778.     if (c)
  779.       Data |= c<<BitNo;
  780.     else
  781.       Data &= ~(1<<BitNo);      
  782.     WRITE_MEM(Off, Data);
  783.   #elif LCD_BITSPERPIXEL == 2
  784.     U8 Data;
  785.     READ_MEM(Off, Data);
  786.     switch (x&3) {
  787.     case 3:
  788.       Data = (Data & ~(3<<0)) | (c<<0);
  789.       break;
  790.     case 2:
  791.       Data = (Data & ~(3<<2)) | (c<<2);
  792.       break;
  793.     case 1:
  794.       Data = (Data & ~(3<<4)) | (c<<4);
  795.       break;
  796.     case 0:
  797.       Data = (Data & ~(3<<6)) | (c<<6);
  798.       break;
  799.     }
  800.     WRITE_MEM(Off, Data);
  801.   #elif LCD_BITSPERPIXEL == 4
  802.     U8 Data;
  803.     READ_MEM(Off, Data);
  804.     switch (x&1) {
  805.     case 1:
  806.       Data = (Data & ~(15<<0)) | (c<<0);
  807.       break;
  808.     case 0:
  809.       Data = (Data & ~(15<<4)) | (c<<4);
  810.       break;
  811.     }
  812.     WRITE_MEM(Off, Data);
  813.   #elif LCD_BITSPERPIXEL == 8
  814.     WRITE_MEM(Off, c);
  815.   #else
  816.     #error TBD
  817.   #endif
  818. #else
  819.   #error unsupported LCD_BUSWIDTH
  820. #endif
  821. }
  823. unsigned int GetPixelIndex(int x, int y) {
  824.   LCD_PIXELINDEX col;
  825.   tOff Off = XY2OFF(x,y);
  826. #if LCD_BUSWIDTH == 16
  827.   U16 Data;
  828.   READ_MEM(Off,Data);
  829.   #if LCD_BITSPERPIXEL == 1
  830.     col = (Data >> (15-(x&15))) &1;
  831.   #elif LCD_BITSPERPIXEL == 2
  832.     col = (Data >> (14-((x&7)<<1))) &3;
  833.   #elif LCD_BITSPERPIXEL == 4
  834.     col = (Data >> (12-((x&3)<<2))) &15;
  835.   #elif LCD_BITSPERPIXEL == 8
  836.     col = ((x&1) ==0) ? Data>>8 : Data;
  837.   #elif LCD_BITSPERPIXEL == 15
  838.     col = Data;
  839.   #elif LCD_BITSPERPIXEL == 16
  840.     col = Data;
  841.   #endif
  842. #else
  843.   U8 Data;
  844.   READ_MEM(Off,Data);
  845.   #if LCD_BITSPERPIXEL == 1
  846.     col = (Data >> (7-(x&7))) &1;
  847.   #elif LCD_BITSPERPIXEL == 2
  848.     col = (Data >> (6-((x&3)<<1))) &3;
  849.   #elif LCD_BITSPERPIXEL == 4
  850.     col = (x&1) ? Data&15 : Data>>4;
  851.   #elif LCD_BITSPERPIXEL == 8
  852.     col = Data;
  853.   #endif
  854. #endif
  855.   return col;
  856. }
  858. static void XorPixel   (int x, int y) {
  859.   LCD_PIXELINDEX Index = GetPixelIndex(x,y);
  860.   _SetPixel(x,y,LCD_NUM_COLORS-1-Index);
  861. }
  865. /*
  866.         *********************************************************
  867.         *                                                       *
  868.         *       LCD_L0_XorPixel                                 *
  869.         *                                                       *
  870.         *********************************************************
  872. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  873.           display.
  875. */
  877. void LCD_L0_XorPixel(int x, int y) {
  878.   XORPIXEL(x, y);
  879. }
  881. /*
  882.         *********************************************************
  883.         *                                                       *
  884.         *       LCD_L0_SetPixelIndex                            *
  885.         *                                                       *
  886.         *********************************************************
  888. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  889.           display.
  891. */
  892. void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  893.   SETPIXEL(x, y, ColorIndex);
  894. }
  897. /*
  898.         *********************************************************
  899.         *                                                       *
  900.         *          LCD_L0_DrawHLine optimized                      *
  901.         *                                                       *
  902.         *          16 bit bus, Using BITBLT                     *
  903.         *                                                       *
  904.         *********************************************************
  905. */
  907. #if (LCD_USE_BITBLT)           
  908.     && (!LCD_SWAP_XY)          
  909.     && (LCD_BUSWIDTH==16)      
  910.     && (!defined (LCD_LUT_COM))   
  911.     && (!defined (LCD_LUT_SEG))   
  912.     && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))
  914. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  915.   #if LCD_MIRROR_X
  916.     #define X0 (LCD_XSIZE-1-(x1))
  917.     #define X1 (LCD_XSIZE-1-(x0))
  918.   #else
  919.     #define X0 x0
  920.     #define X1 x1
  921.   #endif
  922.   #if LCD_MIRROR_Y
  923.     #define Y0 (LCD_YSIZE-1-(y))
  924.   #else
  925.     #define Y0 y
  926.   #endif
  927.   if (x0>x1) return;
  928.   LCD_FillRectBB(X0,Y0,X1,Y0);
  929.   #undef X0
  930.   #undef X1
  931.   #undef Y0
  932. }
  935. /*
  936.         *********************************************************
  937.         *                                                       *
  938.         *          LCD_L0_DrawHLine optimized                      *
  939.         *                                                       *
  940.         *          16 bit bus, 16 bpp                           *
  941.         *                                                       *
  942.         *********************************************************
  943. */
  945. #elif (LCD_OPTIMIZE)             
  946.       && (!LCD_SWAP_XY)          
  947.       && (!LCD_MIRROR_Y)         
  948.       && (LCD_BUSWIDTH==16)      
  949.       && (!defined (LCD_LUT_COM))   
  950.       && (!defined (LCD_LUT_SEG))   
  951.       && ((LCD_BITSPERPIXEL == 16) || (LCD_BITSPERPIXEL == 15))
  953. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  954.   #if LCD_MIRROR_X
  955.     #define X0 (LCD_XSIZE-1-(x1))
  956.   #else
  957.     #define X0 x0
  958.   #endif
  959.   if (x0>x1) return;
  960.   {
  961.     register tOff Off = XY2OFF(X0,y);
  962.     register int Rem = x1-x0+1;
  963.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  964.       for (; Rem--; Off++) {
  965.         U16 Data;
  966.         READ_MEM(Off, Data);
  967.         Data = LCD_NUM_COLORS-1-Data;
  968.         WRITE_MEM(Off,Data);
  969.       }
  970.     } else {
  971.       for (; Rem >= 8; Off += 8) {
  972.         WRITE_MEM(Off,COLOR);
  973.         WRITE_MEM(Off+1,COLOR);
  974.         WRITE_MEM(Off+2,COLOR);
  975.         WRITE_MEM(Off+3,COLOR);
  976.         WRITE_MEM(Off+4,COLOR);
  977.         WRITE_MEM(Off+5,COLOR);
  978.         WRITE_MEM(Off+6,COLOR);
  979.         WRITE_MEM(Off+7,COLOR);
  980.         Rem -=8;
  981.       }
  982.       for (; Rem--; Off++) {
  983.         WRITE_MEM(Off,COLOR);
  984.       }
  985.     }
  986.   }
  987.   #undef X0
  988. }
  991. /*
  992.         *********************************************************
  993.         *                                                       *
  994.         *          LCD_L0_DrawHLine optimized                   *
  995.         *                                                       *
  996.         *          16 bit bus, 8 bpp                            *
  997.         *                                                       *
  998.         *********************************************************
  999. */
  1001. #elif (LCD_OPTIMIZE)             
  1002.       && (!LCD_SWAP_XY)          
  1003.       && (LCD_BUSWIDTH==16)      
  1004.       && (!defined (LCD_LUT_SEG))   
  1005.       && (LCD_BITSPERPIXEL == 8)
  1006.       
  1007. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1008.   #if LCD_MIRROR_X
  1009.   {
  1010.     int t = (LCD_XSIZE-1-(x0));
  1011.     x0 = (LCD_XSIZE-1-(x1));
  1012.     x1 = t;
  1013.   }
  1014.   #endif
  1015.   #if LCD_MIRROR_Y
  1016.     y = (LCD_YSIZE-1-(y));
  1017.   #endif
  1018.   {
  1019.     register tOff Off = XY2OFF(x0,y);
  1020.     /* register */ U16 Data;
  1021. /* XOR mode */
  1022.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1023.       if (x0&1) {
  1024.         READ_MEM(Off, Data);
  1025.         Data ^= ((unsigned int)255);
  1026.         WRITE_MEM(Off,Data);
  1027.         x0++;
  1028.         Off++;
  1029.       }
  1030.       for (; x0<x1; x0+=2, Off++) {
  1031.         READ_MEM(Off,Data);
  1032.         Data ^= 0xffff;
  1033.         WRITE_MEM(Off,Data);
  1034.       }      
  1035.       if ((x1&1)==0) {
  1036.         READ_MEM(Off,Data);
  1037.         Data ^=  (U16)255<<8;
  1038.         WRITE_MEM(Off,Data);
  1039.       }
  1040. /* WRITE mode */
  1041.     } else {
  1042.       if (x0&1) {
  1043.         READ_MEM(Off,Data);
  1044.         Data = (Data&((U16)0xff<<8)) | (COLOR);
  1045.         WRITE_MEM(Off,Data);
  1046.         x0++;
  1047.         Off++;
  1048.       }
  1049.       Data = COLOR|((U16)COLOR<<8);
  1050.       /* Optimization for longer lines ... */
  1051.       #ifdef LCD_WRITE_MEM32
  1052.       if ((x0<x1-4) && (x0&2)) { /* Write 16 bits if necessary */
  1053.         WRITE_MEM(Off,Data);
  1054.         x0+=2;
  1055.         Off++;
  1056.       }
  1057.       /* write 4 pixels at a time, loop unrolled  */
  1058.       { register U32 Data32 = Data| (Data<<16);
  1059.         for (;x0<x1-32-2; x0+=32, Off+=16) {
  1060.           LCD_WRITE_MEM32(Off+0,Data32);
  1061.           LCD_WRITE_MEM32(Off+2,Data32);
  1062.           LCD_WRITE_MEM32(Off+4,Data32);
  1063.           LCD_WRITE_MEM32(Off+6,Data32);
  1064.           LCD_WRITE_MEM32(Off+8,Data32);
  1065.           LCD_WRITE_MEM32(Off+10,Data32);
  1066.           LCD_WRITE_MEM32(Off+12,Data32);
  1067.           LCD_WRITE_MEM32(Off+14,Data32);
  1068.         }
  1069.       }
  1070.       { register U32 Data32 = Data| (Data<<16);
  1071.         for (;x0<x1-16-2; x0+=16, Off+=8) {
  1072.           LCD_WRITE_MEM32(Off+0,Data32);
  1073.           LCD_WRITE_MEM32(Off+2,Data32);
  1074.           LCD_WRITE_MEM32(Off+4,Data32);
  1075.           LCD_WRITE_MEM32(Off+6,Data32);
  1076.         }
  1077.       }
  1078.       { register U32 Data32 = Data| (Data<<16);
  1079.         for (;x0<x1-8-2; x0+=8, Off+=4) {
  1080.           LCD_WRITE_MEM32(Off+0,Data32);
  1081.           LCD_WRITE_MEM32(Off+2,Data32);
  1082.         }
  1083.       }
  1084.       #else
  1085.       for (;x0<x1-10; x0+=12, Off+=6) {
  1086.         /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1087.         LCD_WRITE_MEM(Off,Data); 
  1088.         LCD_WRITE_MEM(Off+1,Data);
  1089.         LCD_WRITE_MEM(Off+2,Data);
  1090.         LCD_WRITE_MEM(Off+3,Data);
  1091.         LCD_WRITE_MEM(Off+4,Data);
  1092.         LCD_WRITE_MEM(Off+5,Data);
  1093.       }
  1094.       #endif
  1095.       /* write the last pixels 2 at a time */
  1096.       for (; x0<x1; x0+=2, Off++) {
  1097.         /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1098.         LCD_WRITE_MEM(Off,Data);
  1099.       }      
  1100.       if ((x1&1)==0) {
  1101.         READ_MEM(Off, Data);
  1102.         Data = (Data&((unsigned int)0xff)) | ((U16)COLOR<<8);
  1103.         WRITE_MEM(Off,Data);
  1104.       }
  1105.     }
  1106.   }
  1107. }
  1111. /*
  1112.         *********************************************************
  1113.         *                                                       *
  1114.         *          LCD_L0_DrawHLine optimized                   *
  1115.         *                                                       *
  1116.         *          16 bit bus, 4 bpp                            *
  1117.         *                                                       *
  1118.         *********************************************************
  1119. */
  1121. #elif (LCD_OPTIMIZE)             
  1122.       && (!LCD_SWAP_XY)          
  1123.       && (LCD_BUSWIDTH==16)      
  1124.       && (!defined (LCD_LUT_SEG))   
  1125.       && (LCD_BITSPERPIXEL == 4)
  1127. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1128.   #if LCD_MIRROR_X
  1129.     #define X0 (LCD_XSIZE-1-(x1))
  1130.   #else
  1131.     #define X0 x0
  1132.   #endif
  1133.   #if LCD_MIRROR_Y
  1134.     #define Y (LCD_YSIZE - 1 - y)
  1135.   #else
  1136.     #define Y y
  1137.   #endif
  1138.   if (x0>x1) return;
  1139.   {
  1140.     register tOff Off;
  1141.     register int Rem;
  1142.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1143.       for (; (x0&3    )&&(x0<=x1); x0++) XORPIXEL(x0, y);
  1144.       for (; ((x1+1)&3)&&(x0<=x1); x1--) XORPIXEL(x1, y);
  1145.       Off = XY2OFF(X0,Y);
  1146.       Rem = (x1-x0+4)>>2;
  1147.       for (; Rem--; Off++) {
  1148.         U16 c;
  1149.         READ_MEM(Off, c);
  1150.         c ^= 0xffff; 
  1151.         WRITE_MEM(Off,c);
  1152.       }
  1153.     } else {
  1154.       U16 col = COLOR+(COLOR<<4)+(COLOR<<8)+(COLOR<<12);
  1155.       for (; (x0&3    )&&(x0<=x1); x0++)
  1156.         SETPIXEL(x0, y, COLOR);
  1157.       for (; ((x1+1)&3)&&(x0<=x1); x1--)
  1158.         SETPIXEL(x1, y, COLOR);
  1159.       Off = XY2OFF(X0,Y);
  1160.       Rem = (x1-x0+4)>>2;
  1161.       for (; Rem--; Off++) {
  1162.         /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1163.         LCD_WRITE_MEM(Off,col);
  1164.       }
  1165.     }
  1166.   }
  1167.   #undef X0
  1168. }
  1170. /*
  1171.         *********************************************************
  1172.         *                                                       *
  1173.         *          LCD_L0_DrawHLine optimized                   *
  1174.         *                                                       *
  1175.         *          16 bit bus, 1 bpp                            *
  1176.         *                                                       *
  1177.         *********************************************************
  1178. */
  1180. #elif (LCD_OPTIMIZE)             
  1181.       && (!LCD_SWAP_XY)          
  1182.       && (LCD_BUSWIDTH==16)      
  1183.       && (!defined (LCD_LUT_SEG))   
  1184.       && (LCD_BITSPERPIXEL == 1)
  1186. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1187.   #if LCD_MIRROR_X
  1188.   {
  1189.     int temp = x0;
  1190.     x0 = (LCD_XSIZE-1-(x1));
  1191.     x1 = (LCD_XSIZE-1-(temp));
  1192.   }
  1193.   #endif
  1194.   #if LCD_MIRROR_Y
  1195.   {
  1196.     y = (LCD_YSIZE - 1 - y);
  1197.   }
  1198.   #endif
  1199.   {
  1200.     register tOff Off = XY2OFF(x0,y);
  1201.     int iWord = x0>>4;
  1202.     int Word1 = x1>>4;
  1203.     U16 Mask   =  0xffff   >> (x0&15);
  1204.     U16 EndMask = 0xffff8000 >> (x1&15);
  1205.     U16 Data;
  1206.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1207.       for (; iWord<Word1; iWord++) {
  1208.         READ_MEM(Off,Data);
  1209.         Data ^= Mask; 
  1210.         WRITE_MEM(Off++,Data);
  1211.         Mask = 0xffff;
  1212.       }
  1213.       Mask &= EndMask;
  1214.       READ_MEM(Off,Data);
  1215.       Data ^= Mask; 
  1216.       WRITE_MEM(Off++,Data);
  1217.     } else {                                  /* Clear pixels in line */
  1218.       int NumWords = Word1-iWord;
  1219.       if (COLOR==0) {
  1220.         if (NumWords) {
  1221.           READ_MEM(Off,Data);
  1222.           Data &= ~Mask;
  1223.           WRITE_MEM(Off++,Data);
  1224.           NumWords--;
  1225.           /* Fill Words in 2 loops for speed reasons ... */
  1226.           for (; NumWords>=4; NumWords-=4) {
  1227.             /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1228.             LCD_WRITE_MEM(Off++,0);
  1229.             LCD_WRITE_MEM(Off++,0);
  1230.             LCD_WRITE_MEM(Off++,0);
  1231.             LCD_WRITE_MEM(Off++,0);
  1232.           }
  1233.           for (; NumWords; NumWords--) {
  1234.             /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1235.             LCD_WRITE_MEM(Off++,0);
  1236.           }
  1237.           Mask = 0xffff;
  1238.         }
  1239.         Mask &= EndMask;
  1240.         READ_MEM(Off, Data);
  1241.         Data &= ~Mask; 
  1242.         WRITE_MEM(Off++,Data);
  1243.       } else {                                  /* Set pixels in line */
  1244.         if (NumWords) {
  1245.           READ_MEM(Off, Data); 
  1246.           Data |= Mask; 
  1247.           WRITE_MEM(Off++,Data);
  1248.           NumWords--;
  1249.         /* Fill Words in 2 loops for speed reasons ... */
  1250.           for (; NumWords>=4; NumWords-=4) {
  1251.             /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1252.             LCD_WRITE_MEM(Off++,0xffff);
  1253.             LCD_WRITE_MEM(Off++,0xffff);
  1254.             LCD_WRITE_MEM(Off++,0xffff);
  1255.             LCD_WRITE_MEM(Off++,0xffff);
  1256.           }
  1257.           for (; NumWords; NumWords--) {
  1258.             /* swapping can be ignored, so use faster LCD_WRITE_MEM */
  1259.             LCD_WRITE_MEM(Off++,0xffff);
  1260.           }
  1261.           Mask = 0xffff;
  1262.         }
  1263.         Mask &= EndMask;
  1264.         READ_MEM(Off, Data); 
  1265.         Data |= Mask; 
  1266.         WRITE_MEM(Off++,Data);
  1267.       }
  1268.     }
  1269.   }
  1270. }
  1272. /*
  1273.         *********************************************************
  1274.         *                                                       *
  1275.         *          LCD_L0_DrawHLine optimized                      *
  1276.         *                                                       *
  1277.         *          8 bit bus, 8 bpp                             *
  1278.         *                                                       *
  1279.         *********************************************************
  1280. */
  1282. #elif (LCD_OPTIMIZE)             
  1283.       && (!LCD_SWAP_XY)          
  1284.       && (LCD_BUSWIDTH==8)      
  1285.       && (!defined (LCD_LUT_SEG))   
  1286.       && (LCD_BITSPERPIXEL == 8)
  1288. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1289.   #if LCD_MIRROR_X
  1290.     #define X0 (LCD_XSIZE-1-(x1))
  1291.   #else
  1292.     #define X0 x0
  1293.   #endif
  1294.   #if LCD_MIRROR_Y
  1295.     y = LCD_YSIZE - 1 - y;
  1296.   #endif
  1297.   if (x0>x1) return;
  1298.   {
  1299.     register tOff Off = XY2OFF(X0,y);
  1300.     register int Rem = x1-x0+1;
  1301.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1302.       for (; (--Rem)>=0; Off++) {
  1303.         U16 c;
  1304.         READ_MEM(Off,c);
  1305.         c ^= 0xff; 
  1306.         WRITE_MEM(Off,c);
  1307.       }
  1308.     } else {
  1309.       for (;Rem>=4;Off+=4,Rem-=4) {
  1310.         WRITE_MEM(Off,COLOR);
  1311.         WRITE_MEM(Off+1,COLOR);
  1312.         WRITE_MEM(Off+2,COLOR);
  1313.         WRITE_MEM(Off+3,COLOR);
  1314.   }
  1315.       for (; (--Rem)>=0; Off++) {
  1316.         WRITE_MEM(Off,COLOR);
  1317.       }
  1318.     }
  1319.   }
  1320.   #undef X0
  1321. }
  1324. /*
  1325.         *********************************************************
  1326.         *                                                       *
  1327.         *          LCD_L0_DrawHLine optimized                      *
  1328.         *                                                       *
  1329.         *          8 bit bus, 4 bpp                            *
  1330.         *                                                       *
  1331.         *********************************************************
  1332. */
  1334. #elif (LCD_OPTIMIZE)             
  1335.       && (!LCD_SWAP_XY)          
  1336.       && (!LCD_MIRROR_Y)         
  1337.       && (LCD_BUSWIDTH==8)       
  1338.       && (!defined (LCD_LUT_SEG))   
  1339.       && (LCD_BITSPERPIXEL == 4)
  1341. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1342.   #if LCD_MIRROR_X
  1343.     #define X0 (LCD_XSIZE-1-(x1))
  1344.   #else
  1345.     #define X0 x0
  1346.   #endif
  1347.   if (x0>x1) return;
  1348.   {
  1349.     register tOff Off;
  1350.     register int Rem;
  1351.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1352.       for (;  (x0&1)      &&(x0<=x1); x0++) XORPIXEL(x0, y);
  1353.       for (; ((x1&1)!=1)  &&(x0<=x1); x1--) XORPIXEL(x1, y);
  1354.       Off = XY2OFF(X0,y);
  1355.       Rem = (x1-x0+2)>>1;
  1356.       for (; Rem--; Off++) {
  1357.         U16 c;
  1358.         READ_MEM(Off,c);
  1359.         c ^= 0xff; 
  1360.         WRITE_MEM(Off,c);
  1361.       }
  1362.     } else {
  1363.       U8 col = COLOR+(COLOR<<4);
  1364.       /* Draw pixels left of fill area */
  1365.       for (; (x0&1) && (x0<=x1); x0++)   SETPIXEL(x0, y, COLOR);
  1366.       /* Draw pixels right of fill area */
  1367.       for (; ((x1+1)&1)&&(x0<=x1); x1--) SETPIXEL(x1, y, COLOR);
  1368.       Off = XY2OFF(X0,y);
  1369.       Rem = (x1-x0+2)>>1;
  1370.       for (; Rem--; Off++) {
  1371.         WRITE_MEM(Off,col);
  1372.       }
  1373.     }
  1374.   }
  1375.   #undef X0
  1376. }
  1379. /*
  1380.         *********************************************************
  1381.         *                                                       *
  1382.         *          LCD_L0_DrawHLine optimized                      *
  1383.         *                                                       *
  1384.         *          8 bit bus, 1 bpp                             *
  1385.         *                                                       *
  1386.         *********************************************************
  1387. */
  1389. #elif (LCD_OPTIMIZE)             
  1390.       && (!LCD_SWAP_XY)          
  1391.       && (!LCD_MIRROR_Y)         
  1392.       && (!LCD_MIRROR_X)         
  1393.       && (LCD_BUSWIDTH==8)       
  1394.       && (!defined (LCD_LUT_SEG))   
  1395.       && (LCD_BITSPERPIXEL == 1)
  1397. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1398.   register tOff Off = XY2OFF(x0,y);
  1399.   int iByte = x0>>3;
  1400.   int Byte1 = x1>>3;
  1401.   U8 Mask =    0xff   >> (x0&7);
  1402.   U8 EndMask = 0xff80 >> (x1&7);
  1403.   U8 Data;
  1404.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1405.     for (; iByte<Byte1; iByte++) {
  1406.       READ_MEM(Off,Data);
  1407.       Data ^= Mask; 
  1408.       WRITE_MEM(Off,Data);
  1409.       Mask = 0xff;
  1410.       Off++;
  1411.     }
  1412.     Mask &= EndMask;
  1413.     READ_MEM(Off,Data);
  1414.     Data ^= Mask; 
  1415.     WRITE_MEM(Off,Data);
  1416.   } else {                                  /* Clear pixels in line */
  1417.     int NumBytes = Byte1-iByte;
  1418.     if (COLOR==0) {
  1419.       if (NumBytes) {
  1420.         READ_MEM(Off,Data);
  1421.         Data &= (~Mask);
  1422.         WRITE_MEM(Off,Data);
  1423.         Off++; NumBytes--;
  1424.       /* Fill bytes in 2 loops for speed reasons ... */
  1425.         for (; NumBytes>=4; NumBytes-=4, Off+=4) {
  1426.           WRITE_MEM(Off,0);
  1427.           WRITE_MEM(Off+1,0);
  1428.           WRITE_MEM(Off+2,0);
  1429.           WRITE_MEM(Off+3,0);
  1430.         }
  1431.         for (; NumBytes; NumBytes--, Off++) {
  1432.           WRITE_MEM(Off,0);
  1433.         }
  1434.         Mask = 0xff;
  1435.       }
  1436.       Mask &= EndMask;
  1437.       READ_MEM(Off,Data);
  1438.       Data &= ~Mask; 
  1439.       WRITE_MEM(Off,Data);
  1440.     } else {                                  /* Set pixels in line */
  1441.       if (NumBytes) {
  1442.         READ_MEM(Off,Data); 
  1443.         Data |= Mask;
  1444.         WRITE_MEM(Off,Data);
  1445.         Off++; NumBytes--;
  1446.       /* Fill bytes in 2 loops for speed reasons ... */
  1447.         for (; NumBytes>=4; NumBytes-=4, Off+=4) {
  1448.           WRITE_MEM(Off,  0xff);
  1449.           WRITE_MEM(Off+1,0xff);
  1450.           WRITE_MEM(Off+2,0xff);
  1451.           WRITE_MEM(Off+3,0xff);
  1452.         }
  1453.         for (; NumBytes; NumBytes--, Off++) {
  1454.           WRITE_MEM(Off,0xff);
  1455.         }
  1456.         Mask = 0xff;
  1457.       }
  1458.       Mask &= EndMask;
  1459.       READ_MEM(Off,Data);
  1460.       Data |= Mask;
  1461.       WRITE_MEM(Off,Data);
  1462.     }
  1463.   }
  1464. }
  1469. /*
  1470.         *********************************************************
  1471.         *                                                       *
  1472.         *          LCD_L0_DrawHLine unoptimized                    *
  1473.         *                                                       *
  1474.         *********************************************************
  1475. */
  1477. #else  /* Unoptimized variant */
  1479. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  1480.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1481.     while (x0 <= x1) {
  1482.       XORPIXEL(x0, y);
  1483.       x0++;
  1484.     }
  1485.   } else {
  1486.     while (x0 <= x1) {
  1487.       SETPIXEL(x0, y, COLOR);
  1488.       x0++;
  1489.     }
  1490.   }
  1491. }
  1493. #endif
  1496. /********************************************************
  1497. *
  1498. *          LCD_L0_DrawVLine optimized
  1499. *
  1500. *          16 bit bus, using BITBLT
  1501. *
  1502. *********************************************************
  1503. */
  1505. #if (LCD_USE_BITBLT)           
  1506.     && (!LCD_SWAP_XY)          
  1507.     && (LCD_BUSWIDTH==16)      
  1508.     && (!defined (LCD_LUT_COM))   
  1509.     && (!defined (LCD_LUT_SEG))   
  1510.     && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))
  1512. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  1513.   #if LCD_MIRROR_X
  1514.     #define X0 (LCD_XSIZE-1-(x))
  1515.   #else
  1516.     #define X0 x
  1517.   #endif
  1518.   #if LCD_MIRROR_Y
  1519.     #define Y0 (LCD_YSIZE-1-(y1))
  1520.     #define Y1 (LCD_YSIZE-1-(y0))
  1521.   #else
  1522.     #define Y0 y0
  1523.     #define Y1 y1
  1524.   #endif
  1525.   if (y0>y1) return;
  1526.   LCD_FillRectBB(X0,Y0,X0,Y1);
  1527.   #undef X0
  1528.   #undef Y0
  1529.   #undef Y1
  1530. }
  1532. /********************************************************
  1533. *
  1534. *          LCD_L0_DrawVLine optimized
  1535. *
  1536. *          8 bit bus, 4 bpp, SWAP_XY, MIRROR_Y
  1537. *
  1538. *********************************************************
  1539. */
  1541. #elif (LCD_OPTIMIZE)             
  1542.       && (LCD_SWAP_XY)          
  1543.       && (LCD_MIRROR_Y)         
  1544.       && (LCD_BUSWIDTH==8)       
  1545.       && (!defined (LCD_LUT_COM))   
  1546.       && (!defined (LCD_LUT_SEG))   
  1547.       && (LCD_BITSPERPIXEL == 4)
  1548.       
  1549. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  1550.   #if !LCD_MIRROR_X
  1551.     int y_P = x;
  1552.   #else
  1553.     int y_P = (LCD_XSIZE-1-(x1));
  1554.   #endif
  1555.   #if !LCD_MIRROR_Y
  1556.     int x0_P = y0;
  1557.     int x1_P = y1;
  1558.   #else
  1559.     int x0_P = (LCD_YSIZE-1-(y1));
  1560.     int x1_P = (LCD_YSIZE-1-(y0));
  1561.   #endif
  1562.   register tOff Off = XY2OFF(x0_P, y_P);
  1563.   register int Rem;
  1564.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1565.     if (x0_P & 3)
  1566.       while (x0_P <= x1_P)
  1567.         XorPixel(x0_P++, y_P);
  1568.     if ((x1_P + 1) & 3)
  1569.       while (x1_P >= x0_P)
  1570.         XorPixel(x1_P--, y_P);
  1571.     Rem = (x1_P - x0_P + 1) >> 1;
  1572.     for (; Rem-- > 0; Off++) {
  1573.       U8 Contents;
  1574.       READ_MEM(Off,Contents);
  1575.       Contents ^= 0xff;
  1576.       WRITE_MEM(Off,Contents);
  1577.     }
  1578.   } else {
  1579.     U8 col = COLOR+(COLOR<<4);
  1580.     if (x0_P & 3)
  1581.       while (x0_P <= x1_P)
  1582.         _SetPixel(x0_P++, y_P, COLOR);
  1583.     if ((x1_P + 1) & 3)
  1584.       while (x1_P >= x0_P)
  1585.         _SetPixel(x1_P--, y_P, COLOR);
  1586.     Rem = (x1_P - x0_P + 1) >> 1;
  1587.     for (; Rem-- > 0; Off++)
  1588.       WRITE_MEM(Off,col);
  1589.   }
  1590.   #if 0
  1591.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1592. //      for (;  y0<=y1; y0++) XORPIXEL(x0, y0);
  1593.   } else {
  1594.     U8 col = COLOR+(COLOR<<4);
  1595.     /* Draw pixels left of fill area */
  1596.     for (; (x0_P&1) && (x0_P<=x1_P); x0_P++)
  1597.       _SetPixel(x0_P, y_P, COLOR);
  1598.     /* Draw pixels right of fill area */
  1599.     for (; ((x1_P+1)&1)&&(x0_P<=x1_P); x1_P--)
  1600.       _SetPixel(x0_P, y_P, COLOR);
  1601.     Rem = (x1_P+1-x0_P)>>1;
  1602.     for (; Rem--; Off++) {
  1603.       WRITE_MEM(Off,col);
  1604.     }
  1605.   }
  1606.   #endif
  1607. }
  1609. /*
  1610. *********************************************************
  1611. *
  1612. *          LCD_L0_DrawVLine optimized
  1613. *
  1614. *          16 bit bus, 4 bpp, SWAP_XY
  1615. *
  1616. *********************************************************
  1617. */
  1619. #elif (LCD_OPTIMIZE)               
  1620.       && (LCD_SWAP_XY)             
  1621.       && (!defined (LCD_LUT_COM))  
  1622.       && (!defined (LCD_LUT_SEG))  
  1623.       && (LCD_BITSPERPIXEL == 4)   
  1624.       && (LCD_BUSWIDTH==16)
  1626. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  1627.   int y_P = x;
  1628.   #if (!LCD_MIRROR_Y) && (!LCD_MIRROR_X)
  1629.     int x0_P = y0;
  1630.     int x1_P = y1;
  1631.   #else
  1632.     int x0_P = (LCD_YSIZE-1-(y1));
  1633.     int x1_P = (LCD_YSIZE-1-(y0));
  1634.   #endif
  1635.   register tOff Off;
  1636.   register int Rem;
  1637.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1638.     if (x0_P & 3)
  1639.       while ((x0_P <= x1_P) && (x0_P & 3))
  1640.         XorPixel(x0_P++, y_P);
  1641.     if ((x1_P + 1) & 3)
  1642.       while ((x1_P >= x0_P) && ((x1_P + 1) & 3))
  1643.         XorPixel(x1_P--, y_P);
  1644.     Off = XY2OFF(x0_P, y_P);
  1645.     Rem = (x1_P - x0_P + 3) >> 2;
  1646.     for (; Rem-- > 0; Off++) {
  1647.       U16 Contents;
  1648.       Contents = LCD_READ_MEM(Off);
  1649.       Contents ^= 0xffff;
  1650.       LCD_WRITE_MEM(Off,Contents);
  1651.     }
  1652.   } else {
  1653.     U16 col = COLOR+(COLOR<<4)+(COLOR<<8)+(COLOR<<12);
  1654.     if (x0_P & 3)
  1655.       while ((x0_P <= x1_P) && (x0_P & 3))
  1656.         _SetPixel(x0_P++, y_P, COLOR);
  1657.     if ((x1_P + 1) & 3)
  1658.       while ((x1_P >= x0_P) && ((x1_P + 1) & 3))
  1659.         _SetPixel(x1_P--, y_P, COLOR);
  1660.     Off = XY2OFF(x0_P, y_P);
  1661.     Rem = (x1_P - x0_P + 3) >> 2;
  1662.     for (; Rem-- > 0; Off++) {
  1663.       LCD_WRITE_MEM(Off,col);
  1664.     }
  1665.   }
  1666. }
  1668. /*
  1669. *********************************************************
  1670. *
  1671. *          LCD_L0_DrawVLine optimized
  1672. *
  1673. *          16 bit bus, 8 bpp
  1674. *
  1675. *********************************************************
  1676. */
  1678. #elif (LCD_OPTIMIZE)              
  1679.       && (!LCD_SWAP_XY)          
  1680.       && (!LCD_MIRROR_Y)          
  1681.       && (!defined (LCD_LUT_COM))  
  1682.       && (!defined (LCD_LUT_SEG))  
  1683.       && (LCD_BITSPERPIXEL == 8)  
  1684.       && (LCD_BUSWIDTH==16)
  1686. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  1687.   #if LCD_MIRROR_X
  1688.     #define X0 (LCD_XSIZE-1-(x))
  1689.   #else
  1690.     #define X0 x
  1691.   #endif
  1692.   {
  1693.     register int shift;
  1694.     register U16 AndMask, OrMask;
  1695.     register tOff Off = XY2OFF((X0),y0);
  1696.   #if LCD_MIRROR_X
  1697.     switch (x&1) {
  1698.   #else
  1699.     switch (1-(x&1)) {
  1700.   #endif
  1701.     case 0:
  1702.       shift = 0;
  1703.       break;
  1704.     case 1:
  1705.       shift = 8;
  1706.     }
  1707.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1708.       AndMask = 0xffff;
  1709.       OrMask =  (0xff << shift);
  1710.     } else {
  1711.       AndMask = ~(0xff << shift);
  1712.       OrMask = ((U16)COLOR << shift);
  1713.     }
  1714.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1715.       register U16 Mask = (0xff << shift);
  1716.       for (;y0<=y1;y0++) {
  1717.         U16 Data;
  1718.         READ_MEM(Off,Data);
  1719.         Data ^= Mask;
  1720.         WRITE_MEM(Off,Data);
  1721.         Off+= WORDSPERLINE;
  1722.       }
  1723.     } else {
  1724.       for (;y0<=y1;y0++) {
  1725.         U16 Data;
  1726.         READ_MEM(Off,Data);
  1727.         Data &= AndMask;
  1728.         Data |= OrMask;
  1729.         WRITE_MEM(Off,Data);
  1730.         Off+= WORDSPERLINE;
  1731.       }
  1732.     }
  1733.   }
  1734.   #undef X0
  1735. }
  1737. /*
  1738. *********************************************************
  1739. *
  1740. *          LCD_L0_DrawVLine no optimization
  1741. *
  1742. *          8 bit bus, 1 bpp
  1743. *
  1744. *********************************************************
  1745. */
  1747. #else  /* No optimization */
  1749. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  1750.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1751.     while (y0 <= y1) {
  1752.       XORPIXEL(x, y0);
  1753.       y0++;
  1754.     }
  1755.   } else {
  1756.     while (y0 <= y1) {
  1757.       SETPIXEL(x, y0, COLOR);
  1758.       y0++;
  1759.     }
  1760.   }
  1761. }
  1763. #endif
  1766. /*
  1767.         *********************************************************
  1768.         *                                                       *
  1769.         *          LCD_FillRect Optimized                       *
  1770.         *                                                       *
  1771.         *          16 bit bus, Using BITBLT                     *
  1772.         *                                                       *
  1773.         *********************************************************
  1774. */
  1776. #if (LCD_USE_BITBLT)           
  1777.     && (!LCD_SWAP_XY)          
  1778.     && (LCD_BUSWIDTH==16)      
  1779.     && (!defined (LCD_LUT_COM))   
  1780.     && (!defined (LCD_LUT_SEG))   
  1781.     && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))
  1783. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  1784.   #if LCD_MIRROR_X
  1785.     #define X0 (LCD_XSIZE-1-(x1))
  1786.     #define X1 (LCD_XSIZE-1-(x0))
  1787.   #else
  1788.     #define X0 x0
  1789.     #define X1 x1
  1790.   #endif
  1791.   #if LCD_MIRROR_Y
  1792.     #define Y0 (LCD_YSIZE-1-(y1))
  1793.     #define Y1 (LCD_YSIZE-1-(y0))
  1794.   #else
  1795.     #define Y0 y0
  1796.     #define Y1 y1
  1797.   #endif
  1798.   if ((x0>x1) | (y0>y1)) return;
  1799.   LCD_FillRectBB(X0,Y0,X1,Y1);
  1800.   #undef X0
  1801.   #undef X1
  1802.   #undef Y0
  1803.   #undef Y1
  1804. }
  1806. #else
  1809. /*
  1810.         *********************************************************
  1811.         *                                                       *
  1812.         *          LCD_FillRect                                 *
  1813.         *                                                       *
  1814.         *********************************************************
  1815. */
  1817. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  1818. #if !LCD_SWAP_XY
  1819.   for (; y0 <= y1; y0++) {
  1820.     LCD_L0_DrawHLine(x0,y0, x1);
  1821.   }
  1822. #else
  1823.   for (; x0 <= x1; x0++) {
  1824.     LCD_L0_DrawVLine(x0,y0, y1);
  1825.   }
  1826. #endif
  1827. }
  1829. #endif
  1832. /********************************************************
  1833. *
  1834. *          Draw Bitmap 1 BPP Optimzed
  1835. *
  1836. *          8 bit bus, 1 bpp
  1837. *
  1838. *********************************************************
  1839. */
  1841. #if (LCD_OPTIMIZE)             
  1842.       && (!LCD_SWAP_XY)          
  1843.       && (!LCD_MIRROR_Y)         
  1844.       && (!LCD_MIRROR_X)         
  1845.       && (LCD_BUSWIDTH==8)       
  1846.       && (!defined (LCD_LUT_COM))   
  1847.       && (!defined (LCD_LUT_SEG))   
  1848.       && (LCD_BITSPERPIXEL == 1)
  1851. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1852. /* only normal mode optimized */
  1853.   if (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR))
  1854.     goto DrawBitLine1BPP_NoOpt;
  1855.   {
  1856.     LCD_PIXELINDEX Index0 = *(pTrans+0);
  1857.     LCD_PIXELINDEX Index1 = *(pTrans+1);
  1858.     x+=Diff;
  1859.   /* Check if filling will do ... */
  1860.     if (Index0==Index1) {
  1861.       LCD_PIXELINDEX ColorIndexOld= COLOR;  /* Save forground color */
  1862.       COLOR = Index0;              /* Set foreground color */
  1863.       LCD_L0_DrawHLine(x,y,x+xsize-1);
  1864.       COLOR = ColorIndexOld;
  1865.       return;
  1866.     }  
  1867.     {
  1868.   /* O.K., we have to draw ... */
  1869.       tOff Off  = XY2OFF(x,y);
  1870.       int x1 = x+xsize-1;
  1871.       U8 Mask =    0xff   >> (x &7);
  1872.       U8 EndMask = 0xff80 >> (x1&7);
  1873.       U8 Data;
  1874.       U16 XorData = Index1 ? 0 : 0xffff;
  1875.       U16 PixelData;
  1876.       int NumBytes = (x1>>3) - (x>>3);
  1877.       if (NumBytes) {
  1878.   /* Write first byte (Needs to be masked) */
  1879.         READ_MEM(Off,Data);
  1880.         Data &= (~Mask);
  1881.         PixelData   = (*(p+1) | ((*p)<<8)) ^ XorData;
  1882.         PixelData >>= (8+(x&7)-(Diff&7));
  1883.         Data |= PixelData&Mask;
  1884.         WRITE_MEM(Off,Data);
  1885.         { int DiffOld = Diff;
  1886.           Diff+= 8-(x&7); 
  1887.           if ((DiffOld&~7) != (Diff&~7))
  1888.             p++;
  1889.         }
  1890.         x=0;
  1891.         Off++; NumBytes--;
  1892.   /* Write full byte */
  1893.         for (; NumBytes; NumBytes--, Off++) {
  1894.           PixelData   = (*(p+1) | ((*p)<<8))^XorData;
  1895.           PixelData >>= (8-(Diff&7));
  1896.           p++;
  1897.           WRITE_MEM(Off, PixelData);
  1898.         }
  1899.         Mask = 0xff;
  1900.       }
  1901.       PixelData   = (*(p+1) | ((*p)<<8))^XorData;
  1902.       PixelData >>= (8+(x&7)-(Diff&7));
  1903.       Mask &= EndMask;
  1904.       READ_MEM(Off,Data);
  1905.       Data &= (~Mask);
  1906.       Data |= PixelData&Mask;
  1907.       WRITE_MEM(Off,Data);
  1908.     }
  1909.     return;
  1910.   }
  1911. /* no optimization */
  1912. DrawBitLine1BPP_NoOpt:
  1913.   {
  1914.     LCD_PIXELINDEX pixels;
  1915.     LCD_PIXELINDEX Index0 = *(pTrans+0);
  1916.     LCD_PIXELINDEX Index1 = *(pTrans+1);
  1917.   /*
  1918.   // Jump to right entry point
  1919.   */
  1920.     pixels = *p;
  1921.     switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  1922.     case LCD_DRAWMODE_TRANS:
  1923.       switch (Diff&7) {
  1924.       case 0:
  1925.         goto WriteTBit0;
  1926.       case 1:
  1927.         goto WriteTBit1;
  1928.       case 2:
  1929.         goto WriteTBit2;
  1930.       case 3:
  1931.         goto WriteTBit3;
  1932.       case 4:
  1933.         goto WriteTBit4;
  1934.       case 5:   
  1935.         goto WriteTBit5;
  1936.       case 6:   
  1937.         goto WriteTBit6;
  1938.       case 7:   
  1939.         goto WriteTBit7;
  1940.       }
  1941.       break;
  1942.     case LCD_DRAWMODE_XOR:
  1943.       switch (Diff&7) {
  1944.       case 0:   
  1945.         goto WriteXBit0;
  1946.       case 1:   
  1947.         goto WriteXBit1;
  1948.       case 2:
  1949.         goto WriteXBit2;
  1950.       case 3:
  1951.         goto WriteXBit3;
  1952.       case 4:
  1953.         goto WriteXBit4;
  1954.       case 5:   
  1955.         goto WriteXBit5;
  1956.       case 6:   
  1957.         goto WriteXBit6;
  1958.       case 7:   
  1959.         goto WriteXBit7;
  1960.       }
  1961.     }
  1962.   /*
  1963.           Write with transparency
  1964.   */
  1965.     WriteTBit0:
  1966.       if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  1967.       if (!--xsize)
  1968.         return;
  1969.     WriteTBit1:
  1970.       if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  1971.       if (!--xsize)
  1972.         return;
  1973.     WriteTBit2:
  1974.       if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  1975.       if (!--xsize)
  1976.         return;
  1977.     WriteTBit3:
  1978.       if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  1979.       if (!--xsize)
  1980.         return;
  1981.     WriteTBit4:
  1982.       if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  1983.       if (!--xsize)
  1984.         return;
  1985.     WriteTBit5:
  1986.       if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  1987.       if (!--xsize)
  1988.         return;
  1989.     WriteTBit6:
  1990.       if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  1991.       if (!--xsize)
  1992.         return;
  1993.     WriteTBit7:
  1994.       if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  1995.       if (!--xsize)
  1996.         return;
  1997.       x+=8;
  1998.       pixels = *(++p);
  1999.       goto WriteTBit0;
  2000.   /*
  2001.           Write XOR mode
  2002.   */
  2003.     WriteXBit0:
  2004.       if (pixels&(1<<7))
  2005.         XORPIXEL(x+0, y);
  2006.       if (!--xsize)
  2007.         return;
  2008.     WriteXBit1:
  2009.       if (pixels&(1<<6))
  2010.         XORPIXEL(x+1, y);
  2011.       if (!--xsize)
  2012.         return;
  2013.     WriteXBit2:
  2014.       if (pixels&(1<<5))
  2015.         XORPIXEL(x+2, y);
  2016.       if (!--xsize)
  2017.         return;
  2018.     WriteXBit3:
  2019.       if (pixels&(1<<4))
  2020.         XORPIXEL(x+3, y);
  2021.       if (!--xsize)
  2022.         return;
  2023.     WriteXBit4:
  2024.       if (pixels&(1<<3))
  2025.         XORPIXEL(x+4, y);
  2026.       if (!--xsize)
  2027.         return;
  2028.     WriteXBit5:
  2029.       if (pixels&(1<<2))
  2030.         XORPIXEL(x+5, y);
  2031.       if (!--xsize)
  2032.         return;
  2033.     WriteXBit6:
  2034.       if (pixels&(1<<1))
  2035.         XORPIXEL(x+6, y);
  2036.       if (!--xsize)
  2037.         return;
  2038.     WriteXBit7:
  2039.       if (pixels&(1<<0))
  2040.         XORPIXEL(x+7, y);
  2041.       if (!--xsize)
  2042.         return;
  2043.       x+=8;
  2044.       pixels = *(++p);
  2045.       goto WriteXBit0;
  2046.   }
  2047. }
  2049. /********************************************************
  2050. *
  2051. *          Draw Bitmap 1 BPP Optimzed
  2052. *
  2053. *          16 bit bus, 4 bpp mode, SWAP_XY
  2054. *
  2055. *********************************************************
  2056. */
  2058. #elif (LCD_OPTIMIZE)               
  2059.     && (LCD_SWAP_XY)             
  2060.     && (!defined (LCD_LUT_COM))  
  2061.     && (!defined (LCD_LUT_SEG))  
  2062.     && (LCD_BITSPERPIXEL == 4)   
  2063.     && (LCD_BUSWIDTH==16)
  2065. static const U8 ShiftNibble[] = {
  2066.   12, 8, 4, 0
  2067. };
  2069. static void DrawBitLine1BPP_Swap(
  2070.   int x,
  2071.   int y,
  2072.   U8 const * pData,
  2073.   int ysize,
  2074.   const U8 * pTrans,
  2075.   int BytesPerLine,
  2076.   U8 Pos)
  2077. {
  2078.   int y0 = x;
  2079.   #if LCD_MIRROR_Y || LCD_MIRROR_X
  2080.     int x0 = LCD_YSIZE - y - 1;
  2081.   #else
  2082.     int x0 = y;
  2083.   #endif
  2084.   tOff Off = XY2OFF(x0,y0);
  2085.   U16 Buffer, Data;
  2086.   U8 Index, Pixel;
  2087.   U8 BufferValid = 0;
  2088.   U8 ShiftPos = 7 - (Pos & 7);
  2089.   U16 DataMask = 0x80 >> (7 -ShiftPos);
  2090.   #if LCD_MIRROR_Y || LCD_MIRROR_X
  2091.     for (; ysize; ysize--, pData += BytesPerLine, x0--) {
  2092.   #else
  2093.     for (; ysize; ysize--, pData += BytesPerLine, x0++) {
  2094.   #endif
  2095.     U8 Shift = ShiftNibble[x0 & 3];
  2096.     Pixel = (*pData & DataMask) >> ShiftPos;
  2097.     if (!BufferValid) {
  2098.       READ_MEM(Off,Buffer);
  2099.       BufferValid = 1;
  2100.     }
  2101.     switch (GUI_Context.DrawMode) {
  2102.     case LCD_DRAWMODE_NORMAL:
  2103.     case LCD_DRAWMODE_REV:
  2104.       Buffer &= ~(0xF << Shift);
  2105.       Index = *(pTrans + Pixel);
  2106.       Data = Index << Shift;
  2107.       Buffer |= Data;
  2108.       break;
  2109.     case LCD_DRAWMODE_XOR:
  2110.       if (Pixel)
  2111.         Buffer ^= (0xF << Shift);
  2112.       break;
  2113.     case LCD_DRAWMODE_TRANS:
  2114.       if (Pixel) {
  2115.         Buffer &= ~(0xF << Shift);
  2116.         Index = *(pTrans + Pixel);
  2117.         Data = Index << Shift;
  2118.         Buffer |= Data;
  2119.       }
  2120.       break;
  2121.     }
  2122.     #if LCD_MIRROR_Y || LCD_MIRROR_X
  2123.       if (!(x0 & 3)) {
  2124.         BufferValid = 0;
  2125.         WRITE_MEM(Off--, Buffer);
  2126.       }
  2127.     #else
  2128.       if ((x0 & 3) == 3) {
  2129.         BufferValid = 0;
  2130.         WRITE_MEM(Off++, Buffer);
  2131.       }
  2132.     #endif
  2133.   }
  2134.   if (BufferValid)
  2135.     WRITE_MEM(Off, Buffer);
  2136. }
  2138. /********************************************************
  2139. *
  2140. *          Draw Bitmap 1 BPP Optimzed
  2141. *
  2142. *          16 bit bus, 8 bpp mode
  2143. *
  2144. *********************************************************
  2145. */
  2147. #elif (LCD_OPTIMIZE)             
  2148.       && (!LCD_SWAP_XY)          
  2149.       && (!LCD_MIRROR_X)         
  2150.       && (LCD_BUSWIDTH==16)       
  2151.       && (!defined (LCD_LUT_SEG))   
  2152.       && (LCD_BITSPERPIXEL == 8)
  2154. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2155.   U8 Pixels = *p;
  2156.   U8 RemPixels;
  2157.   x+= Diff;
  2158.   RemPixels = 8-Diff;
  2159.   Pixels <<= Diff;
  2160.   /* Handle transparent bitmaps */
  2161.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  2162.     do {
  2163.       if (RemPixels==0) {
  2164.         Pixels = *(++p);
  2165.         RemPixels =8;
  2166.       }
  2167.       if (Pixels & 0x80) {
  2168.         XORPIXEL(x, y);
  2169.       }
  2170.       RemPixels--;
  2171.       Pixels <<=1;
  2172.       x++;
  2173.     } while (--xsize);
  2174.   } else if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  2175.     do {
  2176.       if (RemPixels==0) {
  2177.         Pixels = *(++p);
  2178.         RemPixels =8;
  2179.       }
  2180.       if (Pixels & 0x80) {
  2181.         SETPIXEL(x, y, *(pTrans+1));
  2182.       }
  2183.       RemPixels--;
  2184.       Pixels <<=1;
  2185.       x++;
  2186.     } while (--xsize);
  2187.   } else {
  2188.     /* Handle solid bitmaps */
  2189.     tOff Off;
  2190.     #if LCD_MIRROR_Y
  2191.       y = (LCD_YSIZE-1-(y));
  2192.     #endif
  2193.     Off = XY2OFF(x,y);
  2194.     /* Handle left border (incomplete words) */
  2195.     if (x&1) {
  2196.       U16 Data, Pixel;
  2197.       READ_MEM(Off,Data);
  2198.       Pixel = *(pTrans+(Pixels>>7));
  2199.       Data = (Data &  ((unsigned)0xff<<8)) | (Pixel);
  2200.       WRITE_MEM(Off, Data);
  2201.       xsize--;
  2202.       RemPixels--;
  2203.       Pixels <<=1;
  2204.       Off++;
  2205.     }
  2206.     /* Handle solid middle area */
  2207.     while (xsize >=2) {
  2208.       U16 Data;
  2209.       U8 Data0,Data1;
  2210.       /* Load first pixel */
  2211.       if (RemPixels ==0) {
  2212.         Pixels = *++p;
  2213.         RemPixels =8;
  2214.       }
  2215.       Data0 = Pixels>>7;
  2216.       RemPixels--;
  2217.       Pixels <<= 1;
  2218.       /* Load second pixel */
  2219.       if (RemPixels ==0) {
  2220.         Pixels = *++p;
  2221.         RemPixels =8;
  2222.       }
  2223.       Data1 = Pixels>>7;
  2224.       RemPixels--;
  2225.       Pixels <<= 1;
  2226.       Data = ((*(pTrans+Data0)) <<8) | ((*(pTrans+Data1)));
  2227.       WRITE_MEM(Off, Data);
  2228.       xsize-=2;
  2229.       Off++;
  2230.     }
  2231.     /* Handle right border (single pixel) if necessary */
  2232.     if (xsize >0) {
  2233.       U16 Data;
  2234.       U16 Pixel;
  2235.       READ_MEM(Off,Data);
  2236.       if (RemPixels==0) {
  2237.         Pixels =*(p+1);
  2238.       }
  2239.       Pixel = *(pTrans+(Pixels>>7));
  2240.       Data = (Data & (U16)(0xff)) | (Pixel<<8);
  2241.       WRITE_MEM(Off, Data);
  2242.     }
  2243.   }
  2244. }
  2246. /********************************************************
  2247. *
  2248. *          Draw Bitmap 1 BPP Optimzed
  2249. *
  2250. *          16 bit bus, 4 bpp mode
  2251. *
  2252. *********************************************************
  2253. */
  2255. #elif (LCD_OPTIMIZE)             
  2256.       && (!LCD_SWAP_XY)          
  2257.       && (!LCD_MIRROR_X)         
  2258.       && (LCD_BUSWIDTH==16)       
  2259.       && (!defined (LCD_LUT_SEG))   
  2260.       && (LCD_BITSPERPIXEL == 4)
  2262. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2263.   LCD_PIXELINDEX aColor[2];
  2264.   U16 Pixels = ((*p) << 8) | (*(p + 1));
  2265.   U8 RemPixels;
  2266.   p++;
  2267.   aColor[0] = *pTrans;
  2268.   aColor[1] = *(pTrans + 1);
  2269.   x += Diff;
  2270.   RemPixels = 16 - Diff;
  2271.   Pixels <<= Diff;
  2272.   /* Handle transparent bitmaps */
  2273.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  2274.     do {
  2275.       if (RemPixels==0) {
  2276.         Pixels = ((*(p + 1)) << 8) | (*(p + 2));
  2277.         p += 2;
  2278.         RemPixels = 16;
  2279.       }
  2280.       if (Pixels & 0x8000) {
  2281.         XORPIXEL(x, y);
  2282.       }
  2283.       RemPixels--;
  2284.       Pixels <<=1;
  2285.       x++;
  2286.     } while (--xsize);
  2287.   } else if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  2288.     do {
  2289.       if (RemPixels==0) {
  2290.         Pixels = ((*(p + 1)) << 8) | (*(p + 2));
  2291.         p += 2;
  2292.         RemPixels = 16;
  2293.       }
  2294.       if (Pixels & 0x8000) {
  2295.         SETPIXEL(x, y, *(pTrans+1));
  2296.       }
  2297.       RemPixels--;
  2298.       Pixels <<=1;
  2299.       x++;
  2300.     } while (--xsize);
  2301.   } else {
  2302.     /* Handle solid bitmaps */
  2303.     tOff Off;
  2304.     #if LCD_MIRROR_Y
  2305.       y = (LCD_YSIZE-1-(y));
  2306.     #endif
  2307.     Off = XY2OFF(x,y);
  2308.     /* Handle left border (incomplete words) */
  2309.     if (x & 3) {
  2310.       U16 Data;
  2311.       U8 LeftRem = 4 - (x & 3);
  2312.       READ_MEM(Off, Data);
  2313.       if (LeftRem == 1) {
  2314.         Data &= 0xfff0;
  2315.         Data |= (Pixels & (U16)(1<<15)) ? aColor[1] : aColor[0];
  2316.       } else if (LeftRem == 2) {
  2317.         Data &= 0xff0f;
  2318.         Data |= ((Pixels & (U16)(1<<15)) ? aColor[1] : aColor[0]) << 4;
  2319.         if (xsize > 1) {
  2320.           Data &= 0xfff0;
  2321.           Data |= (Pixels & (1<<14)) ? aColor[1] : aColor[0];
  2322.         }
  2323.       } else if (LeftRem == 3) {
  2324.         Data &= 0xf0ff;
  2325.         Data |= ((Pixels & (U16)(1<<15)) ? aColor[1] : aColor[0]) << 8;
  2326.         if (xsize > 1) {
  2327.           Data &= 0xff0f;
  2328.           Data |= ((Pixels & (1<<14)) ? aColor[1] : aColor[0]) << 4;
  2329.           if (xsize > 2) {
  2330.             Data &= 0xfff0;
  2331.             Data |= (Pixels & (1<<13)) ? aColor[1] : aColor[0];
  2332.           }
  2333.         }
  2334.       }
  2335.       WRITE_MEM(Off, Data);
  2336.       xsize -= LeftRem;
  2337.       Off++;
  2338.       RemPixels -= LeftRem;
  2339.       Pixels <<= LeftRem;
  2340.     }
  2341.     /* Handle solid middle area */
  2342.     while (xsize >= 4) {
  2343.       U16 Data;
  2344.       Data  = ((Pixels & (U16)(1<<15)) ? aColor[1] : aColor[0]) << 12;
  2345.       Data |= ((Pixels & (1<<14)) ? aColor[1] : aColor[0]) << 8;
  2346.       Data |= ((Pixels & (1<<13)) ? aColor[1] : aColor[0]) << 4;
  2347.       Data |= ((Pixels & (1<<12)) ? aColor[1] : aColor[0]);
  2348.       RemPixels -= 4;
  2349.       Pixels <<= 4;
  2350.       WRITE_MEM(Off, Data);
  2351.       xsize -= 4;
  2352.       Off++;
  2353.       if (RemPixels <= 3) {
  2354.         U16 NewPixels;
  2355.         p++;
  2356.         NewPixels = ((*p) << 8) | (*(p + 1));
  2357.         NewPixels >>= RemPixels ;
  2358.         Pixels |= NewPixels;
  2359.         RemPixels += 8;
  2360.       }
  2361.     }
  2362.     /* Handle right border (single pixel) if necessary */
  2363.     if (xsize > 0) {
  2364.       U16 Data;
  2365.       READ_MEM(Off, Data);
  2366.       Data &= 0x0fff;
  2367.       Data |= ((Pixels & (U16)(1<<15)) ? aColor[1] : aColor[0]) << 12;
  2368.       if (xsize > 1) {
  2369.         Data &= 0xf0ff;
  2370.         Data |= ((Pixels & (1<<14)) ? aColor[1] : aColor[0]) << 8;
  2371.         if (xsize > 2) {
  2372.           Data &= 0xff0f;
  2373.           Data |= ((Pixels & (1<<13)) ? aColor[1] : aColor[0]) << 4;
  2374.         }
  2375.       }
  2376.       WRITE_MEM(Off, Data);
  2377.     }
  2378.   }
  2379. }
  2381. /*
  2382. *********************************************************
  2383. *
  2384. *          Draw Bitmap 1 BPP unoptimzed
  2385. *
  2386. *********************************************************
  2387. */
  2389. #else
  2390. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2391.   LCD_PIXELINDEX pixels;
  2392.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  2393.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  2394. /*
  2395. // Jump to right entry point
  2396. */
  2397.   pixels = *p;
  2398.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  2399.   case 0:
  2400.     #if defined (SETNEXTPIXEL)   /* Optimization ! */
  2401.       x+=Diff;
  2402.       SetPosXY(x,y);
  2403.     #endif
  2404.     switch (Diff&7) {
  2405.     case 0:   
  2406.       goto WriteBit0;
  2407.     case 1:   
  2408.       goto WriteBit1;
  2409.     case 2:
  2410.       goto WriteBit2;
  2411.     case 3:
  2412.       goto WriteBit3;
  2413.     case 4:
  2414.       goto WriteBit4;
  2415.     case 5:   
  2416.       goto WriteBit5;
  2417.     case 6:   
  2418.       goto WriteBit6;
  2419.     case 7:   
  2420.       goto WriteBit7;
  2421.     }
  2422.     break;
  2423.   case LCD_DRAWMODE_TRANS:
  2424.     switch (Diff&7) {
  2425.     case 0:
  2426.       goto WriteTBit0;
  2427.     case 1:
  2428.       goto WriteTBit1;
  2429.     case 2:
  2430.       goto WriteTBit2;
  2431.     case 3:
  2432.       goto WriteTBit3;
  2433.     case 4:
  2434.       goto WriteTBit4;
  2435.     case 5:   
  2436.       goto WriteTBit5;
  2437.     case 6:   
  2438.       goto WriteTBit6;
  2439.     case 7:   
  2440.       goto WriteTBit7;
  2441.     }
  2442.     break;
  2443.   case LCD_DRAWMODE_XOR:
  2444.     switch (Diff&7) {
  2445.     case 0:   
  2446.       goto WriteXBit0;
  2447.     case 1:   
  2448.       goto WriteXBit1;
  2449.     case 2:
  2450.       goto WriteXBit2;
  2451.     case 3:
  2452.       goto WriteXBit3;
  2453.     case 4:
  2454.       goto WriteXBit4;
  2455.     case 5:   
  2456.       goto WriteXBit5;
  2457.     case 6:   
  2458.       goto WriteXBit6;
  2459.     case 7:   
  2460.       goto WriteXBit7;
  2461.     }
  2462.   }
  2463. /*
  2464.         Write with transparency
  2465. */
  2466.   WriteTBit0:
  2467.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  2468.     if (!--xsize)
  2469.       return;
  2470.   WriteTBit1:
  2471.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  2472.     if (!--xsize)
  2473.       return;
  2474.   WriteTBit2:
  2475.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  2476.     if (!--xsize)
  2477.       return;
  2478.   WriteTBit3:
  2479.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  2480.     if (!--xsize)
  2481.       return;
  2482.   WriteTBit4:
  2483.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  2484.     if (!--xsize)
  2485.       return;
  2486.   WriteTBit5:
  2487.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  2488.     if (!--xsize)
  2489.       return;
  2490.   WriteTBit6:
  2491.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  2492.     if (!--xsize)
  2493.       return;
  2494.   WriteTBit7:
  2495.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  2496.     if (!--xsize)
  2497.       return;
  2498.     x+=8;
  2499.     pixels = *(++p);
  2500.     goto WriteTBit0;
  2502. /*
  2503.         Write without transparency
  2504. */
  2505. #if defined (SETNEXTPIXEL)   /* Optimization ! */
  2506.   WriteBit0:
  2507.     SetNextPixel((pixels&(1<<7)) ? Index1 : Index0);
  2508.     if (!--xsize) {
  2509. End_WriteBit:
  2510.       END_SETNEXTPIXEL();
  2511.       return;
  2512.     }
  2513.   WriteBit1:
  2514.     SetNextPixel((pixels&(1<<6)) ? Index1 : Index0);
  2515.     if (!--xsize)
  2516.       goto End_WriteBit;
  2517.   WriteBit2:
  2518.     SetNextPixel((pixels&(1<<5)) ? Index1 : Index0);
  2519.     if (!--xsize)
  2520.       goto End_WriteBit;
  2521.   WriteBit3:
  2522.     SetNextPixel((pixels&(1<<4)) ? Index1 : Index0);
  2523.     if (!--xsize)
  2524.       goto End_WriteBit;
  2525.   WriteBit4:
  2526.     SetNextPixel((pixels&(1<<3)) ? Index1 : Index0);
  2527.     if (!--xsize)
  2528.       goto End_WriteBit;
  2529.   WriteBit5:
  2530.     SetNextPixel((pixels&(1<<2)) ? Index1 : Index0);
  2531.     if (!--xsize)
  2532.       goto End_WriteBit;
  2533.   WriteBit6:
  2534.     SetNextPixel((pixels&(1<<1)) ? Index1 : Index0);
  2535.     if (!--xsize)
  2536.       goto End_WriteBit;
  2537.   WriteBit7:
  2538.     SetNextPixel((pixels&(1<<0)) ? Index1 : Index0);
  2539.     if (!--xsize)
  2540.       goto End_WriteBit;
  2541.     x+=8;
  2542.     pixels = *(++p);
  2543.     goto WriteBit0;
  2544. #else
  2545.   WriteBit0:
  2546.     SETPIXEL(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  2547.     if (!--xsize)
  2548.       return;
  2549.   WriteBit1:
  2550.     SETPIXEL(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  2551.     if (!--xsize)
  2552.       return;
  2553.   WriteBit2:
  2554.     SETPIXEL(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  2555.     if (!--xsize)
  2556.       return;
  2557.   WriteBit3:
  2558.     SETPIXEL(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  2559.     if (!--xsize)
  2560.       return;
  2561.   WriteBit4:
  2562.     SETPIXEL(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  2563.     if (!--xsize)
  2564.       return;
  2565.   WriteBit5:
  2566.     SETPIXEL(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  2567.     if (!--xsize)
  2568.       return;
  2569.   WriteBit6:
  2570.     SETPIXEL(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  2571.     if (!--xsize)
  2572.       return;
  2573.   WriteBit7:
  2574.     SETPIXEL(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  2575.     if (!--xsize)
  2576.       return;
  2577.     x+=8;
  2578.     pixels = *(++p);
  2579.     goto WriteBit0;
  2580. #endif
  2581. /*
  2582.         Write XOR mode
  2583. */
  2584.   WriteXBit0:
  2585.     if (pixels&(1<<7))
  2586.       XORPIXEL(x+0, y);
  2587.     if (!--xsize)
  2588.       return;
  2589.   WriteXBit1:
  2590.     if (pixels&(1<<6))
  2591.       XORPIXEL(x+1, y);
  2592.     if (!--xsize)
  2593.       return;
  2594.   WriteXBit2:
  2595.     if (pixels&(1<<5))
  2596.       XORPIXEL(x+2, y);
  2597.     if (!--xsize)
  2598.       return;
  2599.   WriteXBit3:
  2600.     if (pixels&(1<<4))
  2601.       XORPIXEL(x+3, y);
  2602.     if (!--xsize)
  2603.       return;
  2604.   WriteXBit4:
  2605.     if (pixels&(1<<3))
  2606.       XORPIXEL(x+4, y);
  2607.     if (!--xsize)
  2608.       return;
  2609.   WriteXBit5:
  2610.     if (pixels&(1<<2))
  2611.       XORPIXEL(x+5, y);
  2612.     if (!--xsize)
  2613.       return;
  2614.   WriteXBit6:
  2615.     if (pixels&(1<<1))
  2616.       XORPIXEL(x+6, y);
  2617.     if (!--xsize)
  2618.       return;
  2619.   WriteXBit7:
  2620.     if (pixels&(1<<0))
  2621.       XORPIXEL(x+7, y);
  2622.     if (!--xsize)
  2623.       return;
  2624.     x+=8;
  2625.     pixels = *(++p);
  2626.     goto WriteXBit0;
  2627. }
  2628. #endif
  2630. /*
  2631.         *********************************************************
  2632.         *                                                       *
  2633.         *  Draw Bitmap 2 BPP                                    *
  2634.         *                                                       *
  2635.         *********************************************************
  2636. */
  2638. #if (LCD_MAX_LOG_COLORS > 2)
  2640. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2641.   LCD_PIXELINDEX pixels;
  2642. /*
  2643. // Jump to right entry point
  2644. */
  2645.   pixels = *p;
  2646.   if (pTrans) {
  2647.     /*
  2648.       with palette
  2649.     */
  2650.     if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  2651.     case 0:
  2652.       goto WriteTBit0;
  2653.     case 1:
  2654.       goto WriteTBit1;
  2655.     case 2:
  2656.       goto WriteTBit2;
  2657.     default:
  2658.       goto WriteTBit3;
  2659.     } else switch (Diff&3) {
  2660.     case 0:
  2661.       goto WriteBit0;
  2662.     case 1:
  2663.       goto WriteBit1;
  2664.     case 2:
  2665.       goto WriteBit2;
  2666.     default:
  2667.       goto WriteBit3;
  2668.     }
  2669.   /*
  2670.           Write without transparency
  2671.   */
  2672.   WriteBit0:
  2673.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  2674.     if (!--xsize)
  2675.       return;
  2676.   WriteBit1:
  2677.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  2678.     if (!--xsize)
  2679.       return;
  2680.   WriteBit2:
  2681.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  2682.     if (!--xsize)
  2683.       return;
  2684.   WriteBit3:
  2685.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  2686.     if (!--xsize)
  2687.       return;
  2688.     pixels = *(++p);
  2689.     x+=4;
  2690.     goto WriteBit0;
  2691.   /*
  2692.           Write with transparency
  2693.   */
  2694.   WriteTBit0:
  2695.     if (pixels&(3<<6))
  2696.       SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  2697.     if (!--xsize)
  2698.       return;
  2699.   WriteTBit1:
  2700.     if (pixels&(3<<4))
  2701.       SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  2702.     if (!--xsize)
  2703.       return;
  2704.   WriteTBit2:
  2705.     if (pixels&(3<<2))
  2706.       SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  2707.     if (!--xsize)
  2708.       return;
  2709.   WriteTBit3:
  2710.     if (pixels&(3<<0))
  2711.       SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  2712.     if (!--xsize)
  2713.       return;
  2714.     pixels = *(++p);
  2715.     x+=4;
  2716.     goto WriteTBit0;
  2717.   } else { 
  2718.     /* 
  2719.       without palette 
  2720.     */
  2721.     if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  2722.     case 0:
  2723.       goto WriteDDPTBit0;
  2724.     case 1:
  2725.       goto WriteDDPTBit1;
  2726.     case 2:
  2727.       goto WriteDDPTBit2;
  2728.     default:
  2729.       goto WriteDDPTBit3;
  2730.     } else switch (Diff&3) {
  2731.     case 0:
  2732.       goto WriteDDPBit0;
  2733.     case 1:
  2734.       goto WriteDDPBit1;
  2735.     case 2:
  2736.       goto WriteDDPBit2;
  2737.     default:
  2738.       goto WriteDDPBit3;
  2739.     }
  2740.   /*
  2741.           Write without transparency
  2742.   */
  2743.   WriteDDPBit0:
  2744.     SETPIXEL(x+0, y, (pixels>>6));
  2745.     if (!--xsize)
  2746.       return;
  2747.   WriteDDPBit1:
  2748.     SETPIXEL(x+1, y, (3&(pixels>>4)));
  2749.     if (!--xsize)
  2750.       return;
  2751.   WriteDDPBit2:
  2752.     SETPIXEL(x+2, y, (3&(pixels>>2)));
  2753.     if (!--xsize)
  2754.       return;
  2755.   WriteDDPBit3:
  2756.     SETPIXEL(x+3, y, (3&(pixels)));
  2757.     if (!--xsize)
  2758.       return;
  2759.     pixels = *(++p);
  2760.     x+=4;
  2761.     goto WriteDDPBit0;
  2762.   /*
  2763.           Write with transparency
  2764.   */
  2765.   WriteDDPTBit0:
  2766.     if (pixels&(3<<6))
  2767.       SETPIXEL(x+0, y, (pixels>>6));
  2768.     if (!--xsize)
  2769.       return;
  2770.   WriteDDPTBit1:
  2771.     if (pixels&(3<<4))
  2772.       SETPIXEL(x+1, y, (3&(pixels>>4)));
  2773.     if (!--xsize)
  2774.       return;
  2775.   WriteDDPTBit2:
  2776.     if (pixels&(3<<2))
  2777.       SETPIXEL(x+2, y, (3&(pixels>>2)));
  2778.     if (!--xsize)
  2779.       return;
  2780.   WriteDDPTBit3:
  2781.     if (pixels&(3<<0))
  2782.       SETPIXEL(x+3, y, (3&(pixels)));
  2783.     if (!--xsize)
  2784.       return;
  2785.     pixels = *(++p);
  2786.     x+=4;
  2787.     goto WriteDDPTBit0;
  2788.   }
  2789. }
  2791. #endif
  2795. #if (LCD_MAX_LOG_COLORS > 4)
  2797. /**********************************************************
  2798. *
  2799. *          Draw Bitmap 4 BPP, optimized
  2800. *
  2801. *          16 bit bus, 4 bpp mode
  2802. *
  2803. *********************************************************
  2804. */
  2805. #if (LCD_OPTIMIZE)               
  2806.     && (LCD_MAX_LOG_COLORS > 4)  
  2807.     && (LCD_BITSPERPIXEL == 4)   
  2808.     && (LCD_MIRROR_X==0)         
  2809.     && (LCD_BUSWIDTH==16)        
  2810.     && (!LCD_SWAP_XY)            
  2811.     && (!defined (LCD_LUT_SEG))
  2814. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2815.   U16 Data;
  2816.   U16 DataOut;
  2817.   U16 Mask;
  2818.   U8  Phase = x&1;
  2819.   x += Diff;   /* Set x back to the orignal position before clipping */
  2820.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) { 
  2821.     U8 Pixels;
  2822.     U8 RemPixels =0;
  2823.     if (Diff) {
  2824.       RemPixels = Diff;
  2825.       Pixels = (*p++) << (RemPixels<<2);
  2826.     }
  2827.     do {
  2828.       /* Load data if necessary */
  2829.       if (RemPixels == 0) {
  2830.         Pixels = *p++;
  2831.         RemPixels = 2;
  2832.       }
  2833.       /* Set pixel if index != 0 */
  2834.       if (Pixels & 0xf0) {
  2835.         if (pTrans) {
  2836.           SETPIXEL(x, y, *(pTrans + (Pixels >> 4)));
  2837.         } else {
  2838.           SETPIXEL(x, y, (Pixels >> 4));
  2839.         }
  2840.       }
  2841.       /* inc counters / ptrs etc. */
  2842.       RemPixels--;
  2843.       Pixels <<= 4;
  2844.       x++;
  2845.     } while (--xsize);
  2846.   } else { /* Handle non-transparent bitmaps */
  2847.     tOff Off;
  2848.     #if LCD_MIRROR_Y
  2849.       y = LCD_YSIZE - 1 - y;
  2850.     #endif
  2851.     Off = XY2OFF(x, y);
  2852.     /* Handle left border */
  2853.     if (x & 3) {
  2854.       U8 LeftRem = 4- (x & 3);
  2855.       /* Load data */
  2856.       if (Phase == 0) {
  2857.         Data = *p++ <<8;
  2858.         if (LeftRem >2) {
  2859.           Data |= *(p++);
  2860.         } else {
  2861.           Data >>= 8;
  2862.         }
  2863.       } else {
  2864.         Data = *p <<4;
  2865.         if (LeftRem >1) {
  2866.           Data |= (*++p >>4);
  2867.         } else {
  2868.           Data >>= 8;
  2869.         }
  2870.       }
  2871.       /* Convert logical indices to physical indices */
  2872.       if (pTrans) {
  2873.         DataOut  = *(pTrans + (Data & 0xf));
  2874.         if (LeftRem >1) {
  2875.           DataOut |= *(pTrans + ((Data>>4) & 0xf)) <<4;
  2876.           if (LeftRem >2) {
  2877.             DataOut |= *(pTrans + ((Data>>8) & 0xf)) <<8;
  2878.           }
  2879.         }
  2880.       } else {
  2881.         DataOut  = (Data & 0xf);
  2882.         if (LeftRem >1) {
  2883.           DataOut |= ((Data>>4) & 0xf) <<4;
  2884.           if (LeftRem >2) {
  2885.             DataOut |= ((Data>>8) & 0xf) <<8;
  2886.           }
  2887.         }
  2888.       }
  2889.       /* Mask output data */
  2890.       Mask =  0xffff >> (16-(LeftRem << 2));     /* Mask out pixels to the left */
  2891.       if (xsize < LeftRem) {
  2892.         Mask &= 0xffff << ((LeftRem-xsize) << 2);      /* Mask out pixels to the right */
  2893.       }
  2894.       DataOut &= Mask;
  2895.       /* Or unchanged pixels */
  2896.       READ_MEM(Off, Data);
  2897.       DataOut |= Data &~Mask;
  2898.       /* output data */
  2899.       WRITE_MEM(Off, DataOut);
  2900.       xsize -= LeftRem;
  2901.       Off++;
  2902.     }
  2903.     /* Handle solid middle area (4 pixels at a time)*/
  2904.     while (xsize >= 4) {
  2905.       /* Load data */
  2906.       if (Phase == 0) {
  2907.         Data = (*p <<8) | *(p+1) ;
  2908.       } else {
  2909.         Data = (*p <<12) | (*(p+1) <<4) | (*(p+2) >>4);
  2910.       }
  2911.       /* Convert logical indices to physical indices */
  2912.       if (pTrans) {
  2913.         DataOut  = *(pTrans + (Data & 0xf));
  2914.         DataOut |= *(pTrans + ((Data>>4) & 0xf)) <<4;
  2915.         DataOut |= *(pTrans + ((Data>>8) & 0xf)) <<8;
  2916.         DataOut |= *(pTrans +  (Data>>12))       <<12;
  2917.       } else {
  2918.         DataOut  = (Data & 0xf);
  2919.         DataOut |= ((Data>>4) & 0xf) <<4;
  2920.         DataOut |= ((Data>>8) & 0xf) <<8;
  2921.         DataOut |= (Data>>12)       <<12;
  2922.       }
  2923.       /* output data */
  2924.       WRITE_MEM(Off, DataOut);
  2925.       /* inc counters / ptrs etc. */
  2926.       p+=2;
  2927.       xsize -= 4;
  2928.       Off++;
  2929.     }
  2930.     /* Handle right border */
  2931.     if (xsize >0) {    /* Anything to do at all ? */
  2932.       /* Load data */
  2933.       if (Phase == 0) {
  2934.         Data = (*p <<8);
  2935.         if (xsize > 2) {
  2936.           Data |= (*(p+1));
  2937.         }
  2938.       } else {
  2939.         Data = (*p <<12);
  2940.         if (xsize > 1) {
  2941.           Data |= (*(p+1) <<4);
  2942.         }
  2943.       }
  2944.       /* Convert logical indices to physical indices */
  2945.       if (pTrans) {
  2946.         DataOut  = *(pTrans + (Data>>12)) <<12;
  2947.         if (xsize > 1) {
  2948.           DataOut |= *(pTrans + ((Data>>8) & 0xf)) <<8;
  2949.           if (xsize > 2) {
  2950.             DataOut |= *(pTrans + ((Data>>4) & 0xf)) <<4;
  2951.           }
  2952.         }
  2953.       } else {
  2954.         DataOut  = (Data>>12) <<12;
  2955.         if (xsize > 1) {
  2956.           DataOut |= ((Data>>8) & 0xf) <<8;
  2957.           if (xsize > 2) {
  2958.             DataOut |= ((Data>>4) & 0xf) <<4;
  2959.           }
  2960.         }
  2961.       }
  2962.       /* Mask output data */
  2963.       Mask = 0xffff << ((4-xsize)<<2);
  2964.       DataOut &= Mask;
  2965.       /* Or unchanged pixels */
  2966.       READ_MEM(Off, Data);
  2967.       DataOut |= Data &~Mask;
  2968.       /* output data */
  2969.       WRITE_MEM(Off, DataOut);
  2970.     }
  2971.   }
  2972. }
  2974. /********************************************************
  2975. *
  2976. *          Draw Bitmap 4 BPP Optimzed
  2977. *
  2978. *          16 bit bus, 4 bpp mode, SWAP_XY
  2979. *
  2980. *********************************************************
  2981. */
  2983. #elif (LCD_OPTIMIZE)               
  2984.     && (LCD_SWAP_XY)             
  2985.     && (!defined (LCD_LUT_COM))  
  2986.     && (!defined (LCD_LUT_SEG))  
  2987.     && (LCD_BITSPERPIXEL == 4)   
  2988.     && (LCD_BUSWIDTH==16)
  2990. static void DrawBitLine4BPP_Swap(/**/
  2991.   int x,
  2992.   int y,
  2993.   U8 const * pData,
  2994.   int ysize,
  2995.   const U8 * pTrans,
  2996.   int BytesPerLine,
  2997.   U8 Pos)
  2998. {
  2999.   int y0 = x;
  3000.   #if LCD_MIRROR_Y || LCD_MIRROR_X
  3001.     int x0 = LCD_YSIZE - y - 1;
  3002.   #else
  3003.     int x0 = y;
  3004.   #endif
  3005.   tOff Off = XY2OFF(x0,y0);
  3006.   U16 Buffer, Data;
  3007.   U8 Index, Pixel;
  3008.   U8 BufferValid = 0;
  3009.   U8 ShiftPos = (1 - (Pos & 1)) << 2;
  3010.   U16 DataMask = 0xf0 >> (4 - ShiftPos);
  3011.   #if LCD_MIRROR_Y || LCD_MIRROR_X
  3012.     for (; ysize; ysize--, pData += BytesPerLine, x0--) {
  3013.   #else
  3014.     for (; ysize; ysize--, pData += BytesPerLine, x0++) {
  3015.   #endif
  3016.     U8 Shift = ShiftNibble[x0 & 3];
  3017.     Pixel = (*pData & DataMask) >> ShiftPos;
  3018.     if (!BufferValid) {
  3019.       READ_MEM(Off,Buffer);
  3020.       BufferValid = 1;
  3021.     }
  3022.     switch (GUI_Context.DrawMode) {
  3023.     case LCD_DRAWMODE_NORMAL:
  3024.     case LCD_DRAWMODE_REV:
  3025.       Buffer &= ~(0xF << Shift);
  3026.       if (pTrans) {
  3027.         Index = *(pTrans + Pixel);
  3028.       } else {
  3029.         Index = Pixel;
  3030.       }
  3031.       Data = Index << Shift;
  3032.       Buffer |= Data;
  3033.       break;
  3034.     case LCD_DRAWMODE_XOR:
  3035.       if (Pixel)
  3036.         Buffer ^= (0xF << Shift);
  3037.       break;
  3038.     case LCD_DRAWMODE_TRANS:
  3039.       if (Pixel) {
  3040.         Buffer &= ~(0xF << Shift);
  3041.         if (pTrans) {
  3042.           Index = *(pTrans + Pixel);
  3043.         } else {
  3044.           Index = Pixel;
  3045.         }
  3046.         Data = Index << Shift;
  3047.         Buffer |= Data;
  3048.       }
  3049.       break;
  3050.     }
  3051.     #if LCD_MIRROR_Y || LCD_MIRROR_X
  3052.       if (!(x0 & 3)) {
  3053.         BufferValid = 0;
  3054.         WRITE_MEM(Off--, Buffer);
  3055.       }
  3056.     #else
  3057.       if ((x0 & 3) == 3) {
  3058.         BufferValid = 0;
  3059.         WRITE_MEM(Off++, Buffer);
  3060.       }
  3061.     #endif
  3062.   }
  3063.   if (BufferValid)
  3064.     WRITE_MEM(Off, Buffer);
  3065. }
  3068. /**********************************************************
  3069. *
  3070. *          Draw Bitmap 4 BPP, optimized
  3071. *
  3072. *          16 bit bus, 8 bpp mode
  3073. *
  3074. *********************************************************
  3075. */
  3076. #elif (LCD_OPTIMIZE)               
  3077.     && (LCD_MAX_LOG_COLORS > 4) 
  3078.     && (LCD_BITSPERPIXEL == 8)   
  3079.     && (LCD_MIRROR_X==0)         
  3080.     && (LCD_BUSWIDTH==16)        
  3081.     && (!LCD_SWAP_XY)            
  3082.     && (!defined (LCD_LUT_COM))
  3085. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  3086.   LCD_PIXELINDEX Pixels = *p;
  3087.   U8 RemPixels;
  3088.   if (Diff&1) {
  3089.     x++;
  3090.     RemPixels = 1;
  3091.     Pixels <<= 4;
  3092.   } else {
  3093.     RemPixels = 2;
  3094.   }
  3095.   /* Handle transparent bitmaps */
  3096.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  3097.     if (pTrans) {
  3098.       do {
  3099.         if (RemPixels==0) {
  3100.           Pixels = *(++p);
  3101.           RemPixels =2;
  3102.         }
  3103.         if (Pixels & 0xf0) {
  3104.           SETPIXEL(x, y, *(pTrans+(Pixels>>4)));
  3105.         }
  3106.         RemPixels--;
  3107.         Pixels <<=4;
  3108.         x++;
  3109.       } while (--xsize);
  3110.     } else {
  3111.       do {
  3112.         if (RemPixels==0) {
  3113.           Pixels = *(++p);
  3114.           RemPixels =2;
  3115.         }
  3116.         if (Pixels & 0xf0) {
  3117.           SETPIXEL(x, y, (Pixels>>4));
  3118.         }
  3119.         RemPixels--;
  3120.         Pixels <<=4;
  3121.         x++;
  3122.       } while (--xsize);
  3123.     }
  3124.   } else {
  3125.     tOff Off;
  3126.     #if LCD_MIRROR_Y
  3127.       y = (LCD_YSIZE-1-(y));
  3128.     #endif
  3129.     /* Handle solid bitmaps */
  3130.     Off = XY2OFF(x,y);
  3131.     /* Handle left border (incomplete words) */
  3132.     if (x&1) {
  3133.       U16 Data, Pixel;
  3134.       READ_MEM(Off,Data);
  3135.       if (pTrans) {
  3136.         Pixel = *(pTrans+(Pixels>>4));
  3137.       } else {
  3138.         Pixel = (Pixels>>4);
  3139.       }
  3140.       Data = (Data &  ((unsigned)0xff<<8)) | (Pixel);
  3141.       WRITE_MEM(Off, Data);
  3142.       xsize--;
  3143.       RemPixels--;
  3144.       Pixels <<=4;
  3145.       Off++;
  3146.     }
  3147.     /* Handle solid middle area */
  3148.     while (xsize >=2) {
  3149.       U16 Data;
  3150.       U8 Data0,Data1;
  3151.       if ((RemPixels&1) ==0) {
  3152.         if (RemPixels ==0) {
  3153.           Pixels = *++p;
  3154.         } else {
  3155.           RemPixels =0;
  3156.         }
  3157.         Data0 = Pixels>>4;
  3158.         Data1 = Pixels&15;
  3159.       } else {
  3160.         Data0 = Pixels>>4;
  3161.         Pixels = *++p;
  3162.         Data1 = Pixels>>4;
  3163.         Pixels<<=4;
  3164.       }
  3165.       Data = ((*(pTrans+Data0)) <<8) | ((*(pTrans+Data1)));
  3166.       WRITE_MEM(Off, Data);
  3167.       xsize-=2;
  3168.       Off++;
  3169.     }
  3170.     /* Handle right border (single pixel) if necessary */
  3171.     if (xsize >0) {
  3172.       U16 Data;
  3173.       U16 Pixel;
  3174.       READ_MEM(Off,Data);
  3175.       if (RemPixels==0) {
  3176.         Pixels =*(p+1);
  3177.       }
  3178.       if (pTrans) {
  3179.         Pixel = *(pTrans+(Pixels>>4));
  3180.       } else {
  3181.         Pixel = (Pixels>>4);
  3182.       }
  3183.       Data = (Data & (U16)(0xff)) | (Pixel<<8);
  3184.       WRITE_MEM(Off, Data);
  3185.     }
  3186.   }
  3187. }
  3189. /*
  3190.         *********************************************************
  3191.         *                                                       *
  3192.         *  Draw Bitmap 4 BPP, unoptimized (default)             *
  3193.         *                                                       *
  3194.         *********************************************************
  3195. */
  3197. #else
  3198. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  3199.   LCD_PIXELINDEX pixels;
  3200. /*
  3201. // Jump to right entry point
  3202. */
  3203.   pixels = *p;
  3204.   if (pTrans) {
  3205.     /*
  3206.       with palette
  3207.     */
  3208.     if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  3209.       if ((Diff&1) ==0)
  3210.         goto WriteTBit0;
  3211.       goto WriteTBit1;
  3212.     } else {
  3213.       if ((Diff&1) ==0)
  3214.         goto WriteBit0;
  3215.       goto WriteBit1;
  3216.     }
  3217.   /*
  3218.           Write without transparency
  3219.   */
  3220.   WriteBit0:
  3221.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  3222.     if (!--xsize)
  3223.       return;
  3224.   WriteBit1:
  3225.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  3226.     if (!--xsize)
  3227.       return;
  3228.     x+=2;
  3229.     pixels = *(++p);
  3230.     goto WriteBit0;
  3231.   /*
  3232.           Write with transparency
  3233.   */
  3234.   WriteTBit0:
  3235.     if (pixels>>4)
  3236.       SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  3237.     if (!--xsize)
  3238.       return;
  3239.   WriteTBit1:
  3240.     if (pixels&0xf)
  3241.       SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  3242.     if (!--xsize)
  3243.       return;
  3244.     x+=2;
  3245.     pixels = *(++p);
  3246.     goto WriteTBit0;
  3247.   } else {
  3248.     /*
  3249.       without palette
  3250.     */
  3251.     if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  3252.       if ((Diff&1) ==0)
  3253.         goto WriteDDPTBit0;
  3254.       goto WriteDDPTBit1;
  3255.     } else {
  3256.       if ((Diff&1) ==0)
  3257.         goto WriteDDPBit0;
  3258.       goto WriteDDPBit1;
  3259.     }
  3260.   /*
  3261.           Write without transparency
  3262.   */
  3263.   WriteDDPBit0:
  3264.     SETPIXEL(x+0, y, (pixels>>4));
  3265.     if (!--xsize)
  3266.       return;
  3267.   WriteDDPBit1:
  3268.     SETPIXEL(x+1, y, (pixels&0xf));
  3269.     if (!--xsize)
  3270.       return;
  3271.     x+=2;
  3272.     pixels = *(++p);
  3273.     goto WriteDDPBit0;
  3274.   /*
  3275.           Write with transparency
  3276.   */
  3277.   WriteDDPTBit0:
  3278.     if (pixels>>4)
  3279.       SETPIXEL(x+0, y, (pixels>>4));
  3280.     if (!--xsize)
  3281.       return;
  3282.   WriteDDPTBit1:
  3283.     if (pixels&0xf)
  3284.       SETPIXEL(x+1, y, (pixels&0xf));
  3285.     if (!--xsize)
  3286.       return;
  3287.     x+=2;
  3288.     pixels = *(++p);
  3289.     goto WriteDDPTBit0;
  3290.   }
  3291. }
  3293. #endif
  3294. #endif
  3297. /*
  3298. *********************************************************
  3299. *
  3300. *  Draw Bitmap 8 BPP  (256 colors)
  3301. *
  3302. *      16 bit bus, 4 bpp
  3303. *
  3304. *********************************************************
  3305. */
  3307. #if (LCD_OPTIMIZE)               
  3308.     && (LCD_MAX_LOG_COLORS > 16) 
  3309.     && (LCD_BITSPERPIXEL == 4)   
  3310.     && (LCD_MIRROR_X==0)         
  3311.     && (LCD_BUSWIDTH==16)        
  3312.     && (!LCD_SWAP_XY)            
  3313.     && (!defined (LCD_LUT_SEG))
  3315. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  3316.   LCD_PIXELINDEX pixel;
  3317.   #if LCD_MIRROR_Y
  3318.     #define Y (LCD_YSIZE - 1 - y)
  3319.   #endif
  3320.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  3321.     register tOff Off;
  3322.     /* Handle bitmaps with palette */
  3323.     if (pTrans) {
  3324.       for (; xsize > 0; xsize--, x++, p++) {
  3325.         pixel = *p;
  3326.         if (pixel) {
  3327.           SETPIXEL(x+0, y, *(pTrans+pixel));
  3328.         }
  3329.       }
  3330.     /* Handle bitmaps without palette */
  3331.     } else {
  3332.       #if 1 /* Optimized 020104 */
  3333.         U16 Data;
  3334.         U16 DataOut;
  3335.         U16 Mask;
  3336.         /* Offset */
  3337.         #if LCD_MIRROR_Y
  3338.           y = LCD_YSIZE - 1 - y;
  3339.         #endif
  3340.         Off = XY2OFF(x, y);
  3341.         /* Handle left border */
  3342.         if (x & 3) {
  3343.           /* Load data */
  3344.           U8 LeftRem = 4 - (x & 3);
  3345.           DataOut = (*(p + LeftRem - 1));
  3346.           if (LeftRem > 1) {
  3347.             DataOut |= (*(p + LeftRem - 2)) << 4;
  3348.             if (LeftRem > 2) {
  3349.               DataOut |= (*(p + LeftRem - 3)) << 8;
  3350.             }
  3351.           }
  3352.           /* Mask output data */
  3353.           Mask =  0xffff >> (16 - (LeftRem << 2));       /* Mask out pixels to the left */
  3354.           if (xsize < LeftRem) {
  3355.             Mask &= 0xffff << ((LeftRem - xsize) << 2);  /* Mask out pixels to the right */
  3356.           }
  3357.           DataOut &= Mask;
  3358.           /* Or unchanged pixels */
  3359.           READ_MEM(Off, Data);
  3360.           DataOut |= Data & ~Mask;
  3361.           /* output data */
  3362.           WRITE_MEM(Off, DataOut);
  3363.           xsize -= LeftRem;
  3364.           Off++;
  3365.           p += LeftRem;
  3366.         }
  3367.         /* Handle solid middle area (4 pixels at a time)*/
  3368.         while (xsize >= 4) {
  3369.           /* Load data */
  3370.           DataOut = (*p << 12) | (*(p + 1) << 8) | (*(p + 2) << 4) | *(p + 3);
  3371.           p += 4;
  3372.           /* output data */
  3373.           WRITE_MEM(Off, DataOut);
  3374.           /* inc counters / ptrs etc. */
  3375.           xsize -= 4;
  3376.           Off++;
  3377.         }
  3378.         /* Handle right border */
  3379.         if (xsize >0) {    /* Anything to do at all ? */
  3380.           /* Load data */
  3381.           DataOut = (*p++) << 12;
  3382.           if (xsize > 1) {
  3383.             DataOut |= (*p++) << 8;
  3384.             if (xsize > 2) {
  3385.               DataOut |= (*p) << 4;
  3386.             }
  3387.           }
  3388.           /* Mask output data */
  3389.           Mask = 0xffff << ((4 - xsize) << 2);
  3390.           DataOut &= Mask;
  3391.           /* Or unchanged pixels */
  3392.           READ_MEM(Off, Data);
  3393.           DataOut |= Data & ~Mask;
  3394.           /* output data */
  3395.           WRITE_MEM(Off, DataOut);
  3396.         }
  3397.       #else /* Old */
  3398.         for (;(x&3)&& (xsize>0); x++,xsize--) {
  3399.           SETPIXEL(x, y, *p++);
  3400.         }
  3401.         Off = XY2OFF(x,Y);
  3402.         /* Write 4 pixels at a time */
  3403.         if (xsize >=4) { 
  3404.           int LoopRem = xsize>>2;
  3405.           x += xsize &~3;
  3406.           xsize &=3;
  3407.           for (;--LoopRem>=0; p+=4,Off++) {
  3408.             U16 Data = (*p<<(4+8)) | (*(p+1)<<(0+8))| (*(p+2)<<(4))| (*(p+3));
  3409.             LCD_WRITE_MEM(Off, Data);
  3410.           }
  3411.         }
  3412.         for (;xsize>0; x++,xsize--) {
  3413.           SETPIXEL(x, y, *p++);
  3414.         }
  3415.       #endif
  3416.     }
  3417.   } else {
  3418.     /* Handle transparent bitmap with palette */
  3419.     if (pTrans) {
  3420.       while (xsize > 0) {
  3421.         pixel = *p;
  3422.         if (pixel != 0)
  3423.           SETPIXEL(x+0, y, *(pTrans+pixel));
  3424.         xsize--;
  3425.         x++;
  3426.         p++;
  3427.       }
  3428.     /* Handle transparent bitmap without palette */
  3429.     } else {
  3430.       while (xsize > 0) {
  3431.         pixel = *p;
  3432.         if (pixel != 0)
  3433.           SETPIXEL(x+0, y, pixel);
  3434.         xsize--;
  3435.         x++;
  3436.         p++;
  3437.       }
  3438.     }
  3439.   }
  3440. }
  3442. /*
  3443.         *********************************************************
  3444.         *                                                       *
  3445.         *  Draw Bitmap 8 BPP  (256 colors)                      *
  3446.         *                                                       *
  3447.         *      16 bit bus, 8 bpp                                *
  3448.         *                                                       *
  3449.         *********************************************************
  3450. */
  3452. #elif (LCD_OPTIMIZE)               
  3453.     && (LCD_MAX_LOG_COLORS > 16) 
  3454.     && (LCD_BITSPERPIXEL == 8)   
  3455.     && (LCD_MIRROR_X==0)         
  3456.     && (LCD_BUSWIDTH==16)        
  3457.     && (!LCD_SWAP_XY)            
  3458.     && (!defined (LCD_LUT_SEG))
  3460. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  3461.   LCD_PIXELINDEX pixel;
  3462.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  3463.     register tOff Off;
  3464.     /* Handle bitmaps with palette */
  3465.     if (pTrans) {
  3466.       /* Handle first pixel seperatly if on odd position */
  3467.       if (x&1) {
  3468.         pixel = *p++;
  3469.         SETPIXEL(x+0, y, *(pTrans+pixel));
  3470.         x++;
  3471.         xsize--;
  3472.       }
  3473.       #if LCD_MIRROR_Y
  3474.         y = (LCD_YSIZE-1-(y));
  3475.       #endif
  3476.       Off = XY2OFF(x,y);
  3477.       x+= xsize&~1;
  3478.       /* Optimization for longer lines ... */
  3479.       for (;xsize>8; xsize-=8, p+=8, Off+=4) {
  3480.         WRITE_MEM(Off,   (*(pTrans+*p)     << 8) | (*(pTrans+*(p+1))));
  3481.         WRITE_MEM(Off+1, (*(pTrans+*(p+2)) << 8) | (*(pTrans+*(p+3))));
  3482.         WRITE_MEM(Off+2, (*(pTrans+*(p+4)) << 8) | (*(pTrans+*(p+5))));
  3483.         WRITE_MEM(Off+3, (*(pTrans+*(p+6)) << 8) | (*(pTrans+*(p+7))));
  3484.       }
  3485.       /* Handle 2 pixels at a time */
  3486.       for (; xsize >= 2; xsize-=2) {
  3487.         U16 Data = (*(pTrans+*p) << 8) | (*(pTrans+*(p+1)));
  3488.         WRITE_MEM(Off,Data);
  3489.         p+=2;
  3490.         Off++;
  3491.       }
  3492.       /* Handle last pixel (if one is left) */
  3493.       if (xsize > 0) {
  3494.         #if LCD_MIRROR_Y
  3495.           y = (LCD_YSIZE-1-(y));
  3496.         #endif
  3497.         pixel = *p;
  3498.         SETPIXEL(x+0, y, *(pTrans+pixel));
  3499.         xsize--;
  3500.         x++;
  3501.         p++;
  3502.       }
  3503.     /* Handle bitmaps without palette */
  3504.     } else {
  3505.       #if defined(LCD_DATAADR) & !defined(WIN32)
  3506.         memcpy((U16*)(LCD_DATAADR+x+((U32)y)*LCD_VXSIZE), p,xsize);
  3507.       #else
  3508.         if (x&1) {
  3509.           pixel = *p++;
  3510.           SETPIXEL(x+0, y, pixel);
  3511.           x++;
  3512.           xsize--;
  3513.         }
  3514.         #if LCD_MIRROR_Y
  3515.           y = (LCD_YSIZE-1-(y));
  3516.         #endif
  3517.         Off = XY2OFF(x,y);
  3518.         x+= xsize&~1;
  3519.         /* Optimization for longer lines ... */
  3520.         for (;xsize>8; xsize-=8, p+=8, Off+=4) {
  3521.           WRITE_MEM(Off,   (*(p)   << 8) | (*(p+1)));
  3522.           WRITE_MEM(Off+1, (*(p+2) << 8) | (*(p+3)));
  3523.           WRITE_MEM(Off+2, (*(p+4) << 8) | (*(p+5)));
  3524.           WRITE_MEM(Off+3, (*(p+6) << 8) | (*(p+7)));
  3525.         }
  3526.         /* Handle 2 pixels at a time */
  3527.         for (; xsize >= 2; xsize-=2) {
  3528.           U16 Data = (*(p) << 8) | (*(p+1));
  3529.           WRITE_MEM(Off,Data);
  3530.           p+=2;
  3531.           Off++;
  3532.         }
  3533.         /* Handle last pixel (if one is left) */
  3534.         if (xsize > 0) {
  3535.           #if LCD_MIRROR_Y
  3536.             y = (LCD_YSIZE-1-(y));
  3537.           #endif
  3538.           pixel = *p;
  3539.           SETPIXEL(x+0, y, pixel);
  3540.           xsize--;
  3541.           x++;
  3542.           p++;
  3543.         }
  3544.       #endif
  3545.       }
  3546.   } else {
  3547.     /* Handle transparent bitmap with palette */
  3548.     if (pTrans) {
  3549.       while (xsize > 0) {
  3550.         pixel = *p;
  3551.         if (pixel != 0)
  3552.           SETPIXEL(x+0, y, *(pTrans+pixel));
  3553.         xsize--;
  3554.         x++;
  3555.         p++;
  3556.       }
  3557.     /* Handle transparent bitmap without palette */
  3558.     } else {
  3559.       while (xsize > 0) {
  3560.         pixel = *p;
  3561.         if (pixel != 0)
  3562.           SETPIXEL(x+0, y, pixel);
  3563.         xsize--;
  3564.         x++;
  3565.         p++;
  3566.       }
  3567.     }
  3568.   }
  3569. }
  3571. #else
  3574. /*
  3575.         *********************************************************
  3576.         *                                                       *
  3577.         *  Draw Bitmap 8 BPP  (256 colors)                      *
  3578.         *                                                       *
  3579.         *      Default (no optimization)                        *
  3580.         *                                                       *
  3581.         *********************************************************
  3582. */
  3584. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  3585.   LCD_PIXELINDEX pixel;
  3586.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  3587.     if (pTrans) {
  3588.       for (;xsize > 0; xsize--,x++,p++) {
  3589.         pixel = *p;
  3590.         SETPIXEL(x, y, *(pTrans+pixel));
  3591.       }
  3592.     } else {
  3593.       for (;xsize > 0; xsize--,x++,p++) {
  3594.         SETPIXEL(x, y, *p);
  3595.       }
  3596.     }
  3597.   } else {   /* Handle transparent bitmap */
  3598.     if (pTrans) {
  3599.       for (; xsize > 0; xsize--, x++, p++) {
  3600.         pixel = *p;
  3601.         if (pixel) {
  3602.           SETPIXEL(x+0, y, *(pTrans+pixel));
  3603.         }
  3604.       }
  3605.     } else {
  3606.       for (; xsize > 0; xsize--, x++, p++) {
  3607.         pixel = *p;
  3608.         if (pixel) {
  3609.           SETPIXEL(x+0, y, pixel);
  3610.         }
  3611.       }
  3612.     }
  3613.   }
  3614. }
  3616. #endif
  3618. /*
  3619.         *********************************************************
  3620.         *                                                       *
  3621.         *  Draw Bitmap 8 BPP  (256 colors)                      *
  3622.         *                                                       *
  3623.         *      16 bit bus, 8 bpp                                *
  3624.         *                                                       *
  3625.         *********************************************************
  3626. */
  3628. #if (LCD_BITSPERPIXEL > 8)
  3629. #if (LCD_OPTIMIZE)               
  3630.     && (LCD_MAX_LOG_COLORS > 16) 
  3631.     && (LCD_BITSPERPIXEL == 16)   
  3632.     && (LCD_MIRROR_X==0)         
  3633.     && (LCD_BUSWIDTH==16)        
  3634.     && (!LCD_SWAP_XY)            
  3635.     && (!defined (LCD_LUT_SEG))
  3637. static void  DrawBitLine16BPP(int x, int y, U16 const*p, int xsize) {
  3638.   LCD_PIXELINDEX Index;
  3639.   register tOff Off;
  3640.   #if LCD_MIRROR_Y
  3641.     y = (LCD_YSIZE-1-(y));
  3642.   #endif
  3643.   Off = XY2OFF(x,y);
  3644.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  3645.     /* Always write first pixel */
  3646.     Index = *p;
  3647.     WRITE_MEM(Off, Index);
  3648.     /* Unrolled loop */
  3649.     while ( xsize > 4 ) {
  3650.       WRITE_MEM(Off+1, *(p+1));
  3651.       WRITE_MEM(Off+2, *(p+2));
  3652.       WRITE_MEM(Off+3, *(p+3));
  3653.       WRITE_MEM(Off+4, *(p+4));
  3654.       Off += 4;
  3655.       p += 4;
  3656.       xsize -=4;
  3657.     }
  3658.     /* End loop */
  3659.     for (; --xsize; ) {
  3660.       Off++;
  3661.       Index = *++p;
  3662.       WRITE_MEM(Off, Index);
  3663.     }
  3664.   } else {   /* Handle transparent bitmap */
  3665.     for (; xsize > 0; xsize--, x++, p++) {
  3666.       Index = *p;
  3667.       if (Index) {
  3668.         SETPIXEL(x+0, y, Index);
  3669.       }
  3670.     }
  3671.   }
  3672. }
  3674. /*
  3675.         *********************************************************
  3676.         *                                                       *
  3677.         *  Draw Bitmap 16 BPP
  3678.         *                                                       *
  3679.         *      Default (no optimization)                        *
  3680.         *                                                       *
  3681.         *********************************************************
  3682. */
  3684. #else
  3686. static void  DrawBitLine16BPP(int x, int y, U16 const*p, int xsize) {
  3687.   LCD_PIXELINDEX Index;
  3688.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  3689.     for (;xsize > 0; xsize--,x++,p++) {
  3690.       SETPIXEL(x, y, *p);
  3691.     }
  3692.   } else {   /* Handle transparent bitmap */
  3693.     for (; xsize > 0; xsize--, x++, p++) {
  3694.       Index = *p;
  3695.       if (Index) {
  3696.         SETPIXEL(x+0, y, Index);
  3697.       }
  3698.     }
  3699.   }
  3700. }
  3701. #endif
  3702. #endif
  3703. /*
  3704.         *********************************************************
  3705.         *                                                       *
  3706.         *         Universal draw Bitmap routine                 *
  3707.         *                                                       *
  3708.         *********************************************************
  3709. */
  3711. void LCD_L0_DrawBitmap   (int x0, int y0,
  3712.                        int xsize, int ysize,
  3713.                        int BitsPerPixel, 
  3714.                        int BytesPerLine,
  3715.                        const U8* pData, int Diff,
  3716.                        const LCD_PIXELINDEX* pTrans)
  3717. {
  3718.   int i;
  3719.   /*
  3720.      Use BitBlt engine (if available)
  3721.   */
  3722.   #if LCD_USE_BITBLT              
  3723.       && (LCD_BUSWIDTH==16)       
  3724.       && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806)) 
  3725.       && (LCD_MIRROR_X==0)         
  3726.       && (!defined (LCD_LUT_COM))  
  3727.       && (!defined (LCD_LUT_SEG))
  3728.     /*
  3729.     int y1 = y0+ysize-1;
  3730.     int x1 = x0+xsize-1;
  3731.     */
  3732.     if ((BitsPerPixel==1) && !(GUI_Context.DrawMode & LCD_DRAWMODE_XOR)) {
  3733.       LCD_DrawBitmap1BPPBB(x0, y0, pData, Diff, xsize, ysize, BytesPerLine, pTrans);
  3734.       return;
  3735.     }
  3736.   #endif
  3737.   /*
  3738.      Use DrawBitLineXBPP
  3739.   */
  3740.   switch (BitsPerPixel) {
  3741.   case 1:
  3742.     #if (LCD_OPTIMIZE)               
  3743.         && (LCD_SWAP_XY)             
  3744.         && (!defined (LCD_LUT_COM))  
  3745.         && (!defined (LCD_LUT_SEG))  
  3746.         && (LCD_BITSPERPIXEL == 4)   
  3747.         && (LCD_BUSWIDTH==16)
  3748.       xsize += Diff & 7;
  3749.       for (i = Diff; i < xsize; i++) {
  3750.         DrawBitLine1BPP_Swap(x0+i, y0, pData + (i>>3), ysize, pTrans, BytesPerLine, i);
  3751.       }
  3752.     #else
  3753.       for (i=0; i<ysize; i++) {
  3754.         DrawBitLine1BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  3755.         pData += BytesPerLine;
  3756.       }
  3757.     #endif
  3758.     break;
  3759.   #if (LCD_MAX_LOG_COLORS > 2)
  3760.     case 2:
  3761.       for (i=0; i<ysize; i++) {
  3762.         DrawBitLine2BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  3763.         pData += BytesPerLine;
  3764.       }
  3765.       break;
  3766.   #endif
  3767.   #if (LCD_MAX_LOG_COLORS > 4)
  3768.     case 4:
  3769.       #if (LCD_OPTIMIZE)               
  3770.           && (LCD_SWAP_XY)             
  3771.           && (!defined (LCD_LUT_COM))  
  3772.           && (!defined (LCD_LUT_SEG))  
  3773.           && (LCD_BITSPERPIXEL == 4)   
  3774.           && (LCD_BUSWIDTH==16)
  3775.         xsize += Diff & 1;
  3776.         for (i = Diff; i < xsize; i++) {
  3777.           DrawBitLine4BPP_Swap(x0+i, y0, pData + (i>>1), ysize, pTrans, BytesPerLine, i);
  3778.         }
  3779.       #else
  3780.         for (i=0; i<ysize; i++) {
  3781.           DrawBitLine4BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  3782.           pData += BytesPerLine;
  3783.         }
  3784.       #endif
  3785.       break;
  3786.   #endif
  3787.   #if (LCD_MAX_LOG_COLORS > 16)
  3788.     case 8:
  3789.       for (i=0; i<ysize; i++) {
  3790.         DrawBitLine8BPP(x0, i+y0, pData, xsize, pTrans);
  3791.         pData += BytesPerLine;
  3792.       }
  3793.       break;
  3794.   #endif
  3795.   #if (LCD_BITSPERPIXEL > 8)
  3796.     case 16:
  3797.       for (i=0; i<ysize; i++) {
  3798.         DrawBitLine16BPP(x0, i+y0, (U16*)pData, xsize);
  3799.         pData += BytesPerLine;
  3800.       }
  3801.       break;
  3802.   #endif
  3803.   }
  3804. }
  3806. /********************************************************
  3807. *
  3808. *       LCD_L0_SetOrg
  3809. *
  3810. *********************************************************
  3812. Purpose:        Sets the original position of the virtual display.
  3813.                 Has no function at this point with the PC-driver.
  3814. */
  3816. int OrgX, OrgY;
  3817. void LCD_L0_SetOrg(int x, int y) {
  3818.   OrgX = x;
  3819.   OrgY = y;
  3820. }
  3822. /*
  3823.         *********************************************************
  3824.         *                                                       *
  3825.         *       LCD_On                                          *
  3826.         *       LCD_Off                                         *
  3827.         *                                                       *
  3828.         *********************************************************
  3829. */
  3831. void LCD_Off          (void) {
  3832. #ifdef LCD_OFF
  3833.   LCD_ENABLE_REG_ACCESS();
  3834.   LCD_OFF();
  3835.   LCD_ENABLE_MEM_ACCESS();
  3836. #endif
  3837. }
  3838. void LCD_On           (void) {
  3839. #ifdef LCD_ON
  3840.   LCD_ENABLE_REG_ACCESS();
  3841.   LCD_ON();
  3842.   LCD_ENABLE_MEM_ACCESS();
  3843. #endif
  3844. }
  3846. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  3847.   return GETPIXEL(x,y);
  3848. }
  3851. /*
  3852.         *********************************************************
  3853.         *                                                       *
  3854.         *                   LCD_L0_SetLUTEntry                     *
  3855.         *                                                       *
  3856.         *********************************************************
  3858. */
  3860. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  3861.   int i;
  3862.   #if LCD_BITSPERPIXEL
  3863.     U16 aColorSep[3];
  3864.     for (i=0; i<3; i++) {
  3865.       aColorSep[i] = color &0xff;
  3866.       color>>=8;
  3867.     }
  3868.   #endif
  3869. /* Convert 8 bit color seperation into index */
  3870.   #if (LCD_CONTROLLER == 1374)   /* Calculation for controllers with 4 bit LUT */   
  3871.     ||(LCD_CONTROLLER == 1375) ||(LCD_CONTROLLER == 13705)  
  3872.     ||(LCD_CONTROLLER == 1356) ||(LCD_CONTROLLER == 13506)  
  3873.     ||(LCD_CONTROLLER == 13806)
  3874.     for (i=0; i<3; i++)
  3875.       aColorSep[i] = (U16)(aColorSep[i]+8)/17;
  3876.   #endif
  3877.   #if (LCD_CONTROLLER == 1376)   /* Calculation for controllers with 6 bit LUT */
  3878.     for (i=0; i<3; i++)
  3879.       aColorSep[i] = (aColorSep[i])/4;
  3880.   #endif
  3881. /* Write into palette register */
  3882.   LCD_ENABLE_REG_ACCESS();
  3883.   #if (LCD_CONTROLLER == 1375) || (LCD_CONTROLLER == 1374)  /* 4 bit palette */
  3884.     #if (LCD_BUSWIDTH == 16)
  3885.       WRITE_REG((0x14>>1), Pos * 0x101);   /* Select position */
  3886.       for (i=0; i<3; i++) {
  3887.         WRITE_REG((0x16>>1), ((U16)aColorSep[i]*17) <<8);  /* 1375 expects high nibble, 1374 low nibble (so this works on both) */
  3888.       }
  3889.     #else
  3890.       WRITE_REG((0x15), Pos);   /* Select position */
  3891.       for (i=0; i<3; i++) {
  3892.         WRITE_REG((0x17), aColorSep[i]<<4);
  3893.       }
  3894.     #endif
  3895.   #elif ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))
  3896.     #if (LCD_BUSWIDTH == 16)
  3897.       WRITE_REG(0x01e2/2, Pos);   /* Select position */
  3898.       for (i=0; i<3; i++) {
  3899.         WRITE_REG(0x01e4/2, aColorSep[i]<<4);
  3900.       }
  3901.     #else
  3902.       #error Not yet defined
  3903.     #endif
  3904.   #elif (LCD_CONTROLLER == 1376)
  3905.     #if 0
  3906.     #if LCD_SWAP_BYTE_ORDER
  3907.       /* Write Green and Blue into regs 8/9 */
  3908.       LCD_WRITE_REG((0x8>>1), ((aColorSep[2]<<2)| (aColorSep[1]<<(8+2))));
  3909.       /* Write Red into regs 0xa, index into 0xb */
  3910.       LCD_WRITE_REG(0xa>>1, (Pos<<8)  | (aColorSep[0]<<2));   /* Select position */
  3911.    #else
  3912.       /* Write Green and Blue into regs 8/9 */
  3913.       LCD_WRITE_REG((0x8>>1), (aColorSep[2]<<(8+2))| (aColorSep[1]<<2));
  3914.       /* Write Red into regs 0xa, index into 0xb */
  3915.       LCD_WRITE_REG(0xa>>1, Pos  | (aColorSep[0]<<(8+2)));   /* Select position */
  3916.    #endif
  3917.    #endif /* 0 */
  3918.     /* Write Green and Blue into regs 8/9 */
  3919.     WRITE_REG((0x8>>1), (aColorSep[2]<<(8+2))| (aColorSep[1]<<2));
  3920.     /* Write Red into regs 0xa, index into 0xb */
  3921.     WRITE_REG(0xa>>1, Pos  | (aColorSep[0]<<(8+2)));   /* Select position */
  3922.   #else
  3923.     Pos=Pos;
  3924.     color = color;
  3925.   #endif
  3926.   LCD_ENABLE_MEM_ACCESS();
  3927. }
  3929. /*
  3930.         *********************************************************
  3931.         *                                                       *
  3932.         *       LCD_L0_ReInit : Re-Init the display                *
  3933.         *                                                       *
  3934.         *********************************************************
  3936. ReInit contains all of the code that can be re-executed at any point without
  3937. changing or even disturbing what can be seen on the LCD.
  3938. Note that it is also used as a subroutine by LCD_Init().
  3940. */
  3942. void  LCD_L0_ReInit(void) {
  3943.   LCD_ENABLE_REG_ACCESS();
  3944.   LCD_INIT_CONTROLLER();                     /* macro defined in config */
  3945. #if LCD_USE_BITBLT
  3946.   WRITE_REG(0x10c/2,WORDSPERLINE);       /* Write Bit blit engine line offset */
  3947.   WRITE_REG(0x100/2,0x0);                /* Stop engine (to be on the safe side ...) */
  3948. #endif
  3949.   LCD_ENABLE_MEM_ACCESS();
  3950. }
  3953. /*
  3954.         *********************************************************
  3955.         *                                                       *
  3956.         *       LCD_Init : Init the display                     *
  3957.         *                                                       *
  3958.         *********************************************************
  3959. */
  3960. int  LCD_L0_Init(void) {
  3961.   GUI_DEBUG_LOG("nLCD_Init()");
  3962. /* check production code */
  3963. /*
  3964. #if LCD_CONTROLLER == 1374
  3965.   if ((READ_REG_BYTE(0) &0xfc) != (6<<2)) {
  3966.     GUI_DEBUG_ERROROUT("nLCD13XX: 1374 controller not found");
  3967.     return LCD_ERR_CONTROLLER_NOT_FOUND;
  3968. }
  3969. #elif LCD_CONTROLLER == 1375
  3970.   if ((READ_REG_BYTE(0) >>2) != 0x9) {
  3971.     GUI_DEBUG_ERROROUT("nLCD13XX: 1375 controller not found");
  3972.     return LCD_ERR_CONTROLLER_NOT_FOUND;
  3973. }
  3974. #endif
  3975. */
  3976. #if LCD_CONTROLLER == 1374
  3977.   { int ProdCode;
  3978.     LCD_ENABLE_REG_ACCESS();
  3979.     ProdCode = READ_REG_BYTE(0) >>2;
  3980.     LCD_ENABLE_MEM_ACCESS();
  3981.     if ((ProdCode != 6)    /* 1374 */
  3982.       &&(ProdCode != 9))   /* 1375 */
  3983.     return LCD_ERR_CONTROLLER_NOT_FOUND;
  3984.   }
  3985. #endif
  3986. /* Init controllers (except lookup table) */
  3987.   LCD_L0_ReInit();
  3988.   LCD_Off();
  3989. /* Quick check video memory */
  3990. #if (LCD_BUSWIDTH == 16)
  3991.   LCD_WRITE_MEM(0,0);
  3992.   LCD_WRITE_MEM(1,0x5253);
  3993.   if ((LCD_READ_MEM(0) != 0) || (LCD_READ_MEM(1) != 0x5253)) {
  3994.     GUI_DEBUG_ERROROUT("nLCD13XX: video memory problem");
  3995.     return LCD_ERR_MEMORY;
  3996.   }
  3997.   LCD_WRITE_MEM(1,0);
  3998. #else
  3999.   LCD_WRITE_MEM(0,0);
  4000.   LCD_WRITE_MEM(1,0x52);
  4001.   if ((LCD_READ_MEM(0) != 0) || (LCD_READ_MEM(1) != 0x52)) {
  4002.     GUI_DEBUG_ERROROUT("nLCD13XX: video memory problem");
  4003.     return LCD_ERR_MEMORY;
  4004.   }
  4005. #endif
  4006.   return 0;    /* Init successfull ! */
  4007. }
  4010. /*
  4011.         *********************************************************
  4012.         *                                                       *
  4013.         *       LCD_L0_CheckInit                                   *
  4014.         *                                                       *
  4015.         *  Check if display controller(s) is/are still          *
  4016.         *  properly initialized                                 *
  4017.         *                                                       *
  4018.         *********************************************************
  4020. Return value: 0 => No error, init is O.K.
  4022. */
  4024. int LCD_L0_CheckInit(void) {
  4025.   return 0;
  4026. }
  4029. #else
  4031. void LCD13XX(void) { } /* avoid empty object files */
  4033. #endif  /* (LCD_CONTROLLER/100 == 13) */