lcdlin32.c

图像系统uc_GUI

        }
      } while (--xsize);
    } else {
      do {
        int Shift = (1 - CurrentPixel) << 2;
        int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
        if (Index) {
          LCD_L0_SetPixelIndex(x, y, Index);
        }
        x++;
        if (++CurrentPixel == 2) {
          CurrentPixel = 0;
          Pixels = *(++p);
        }
      } while (--xsize);
    }
    break;
  }
}
#endif
#endif /* (LCD_MAX_LOG_COLORS > 4) */

/*********************************************************************
*
*       Draw Bitmap 8 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 8
*/
#if (LCD_MAX_LOG_COLORS > 16)
#if (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 8) && \
    (!LCD_MIRROR_X) && \
    (!LCD_MIRROR_Y) && \
    (!LCD_SWAP_XY)
static void  _DrawBitLine8BPP(int x, int y, U8 const GUI_UNI_PTR * p, int xsize, const LCD_PIXELINDEX * pTrans) {
  if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) == 0) {
    U32 Data, ColorMask, AndMask;
    int Off, NumPixel_0, NumPixel_1, i;
    Off = y * DWORDS_PER_LINE + x / PIXELS_PER_DWORD;
    NumPixel_0 = x & (PIXELS_PER_DWORD - 1);
    NumPixel_1 = (x + xsize - 1) & (PIXELS_PER_DWORD - 1);
    if (pTrans) {
      /* First DWORD */
      if (NumPixel_0) {
        ColorMask = 0;
        AndMask = ~(0xFFFFFFFF << (8 * NumPixel_0));
        if ((xsize < 3) && (NumPixel_1)) {
          AndMask |= ~(0xFFFFFFFF >> (8 * (3 - NumPixel_1)));
        }
        for (i = NumPixel_0; (i < 4) && xsize; i++, xsize--) {
          U8 Index = *(pTrans + *p++);
          ColorMask |= Index << (8 * i);
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
        Off++;
      }
      /* Complete DWORDS */
      while (xsize >= 4) {
        ColorMask =  *(pTrans + *p) | 
                    (*(pTrans + *(p + 1)) << 8) | 
                    (*(pTrans + *(p + 2)) << 16) | 
                    (*(pTrans + *(p + 3)) << 24);
        WRITE_MEM(Off, ColorMask);
        p += 4;
        Off++;
        xsize -= 4;
      }
      /* Last DWORD */
      if (xsize) {
        ColorMask = i = 0;
        AndMask = 0xFFFFFF00 << (8 * NumPixel_1);
        while (xsize) {
          U8 Index = *(pTrans + *p++);
          ColorMask |= Index << (8 * i++);
          xsize--;
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
      }
    } else {
      /* First DWORD */
      if (NumPixel_0) {
        ColorMask = 0;
        AndMask = ~(0xFFFFFFFF << (8 * NumPixel_0));
        if ((xsize < 3) && (NumPixel_1)) {
          AndMask |= ~(0xFFFFFFFF >> (8 * (3 - NumPixel_1)));
        }
        for (i = NumPixel_0; (i < 4) && xsize; i++, xsize--) {
          U8 Index = *(p++);
          ColorMask |= Index << (8 * i);
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
        Off++;
      }
      /* Complete DWORDS */
      while (xsize >= 4) {
        ColorMask =  *(p) | 
                    (*(p + 1) << 8) | 
                    (*(p + 2) << 16) | 
                    (*(p + 3) << 24);
        WRITE_MEM(Off, ColorMask);
        p += 4;
        Off++;
        xsize -= 4;
      }
      /* Last DWORD */
      if (xsize) {
        ColorMask = i = 0;
        AndMask = 0xFFFFFF00 << (8 * NumPixel_1);
        while (xsize) {
          U8 Index = *(p++);
          ColorMask |= Index << (8 * i++);
          xsize--;
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
      }
    }
  } else {
    /* Handle transparent bitmap with palette */
    LCD_PIXELINDEX pixel;
    if (pTrans) {
      while (xsize > 0) {
        pixel = *p;
        if (pixel != 0) {
          LCD_L0_SetPixelIndex(x + 0, y, *(pTrans + pixel));
        }
        xsize--;
        x++;
        p++;
      }
    /* Handle transparent bitmap without palette */
    } else {
      while (xsize > 0) {
        pixel = *p;
        if (pixel != 0) {
          LCD_L0_SetPixelIndex(x + 0, y, pixel);
        }
        xsize--;
        x++;
        p++;
      }
    }
  }
}

/*********************************************************************
*
*       Draw Bitmap 8 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 8, LCD_SWAP_XY == 1
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 8) && \
    (LCD_MIRROR_X) && \
    (LCD_SWAP_XY)
static void _DrawBitLine8BPP_Swap(unsigned x, unsigned y, U8 const GUI_UNI_PTR * pData, int ysize, const U8 * pTrans, int BytesPerLine, U8 Pos) {
  unsigned x0, y0, Off, xOdd;
  U32 Data;
  U8 Pixel, BufferValid, Shift, Index;
  #if LCD_MIRROR_Y
    y0 = LCD_XSIZE - x - 1;
  #else
    y0 = x;
  #endif
  x0 = LCD_YSIZE - y - 1;
  Off = XY2OFF(x0, y0);
  BufferValid = 0;
  xOdd = x0 & 0x3;
  if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) == 0) {
    /* Handle non transparent bitmaps */
    if (pTrans) {
      /* First DWORD */
      if (xOdd < 3) {
        Data = READ_MEM(Off);
        do {
          Shift = xOdd << 3;
          Pixel = *(pTrans + *pData);
          pData += BytesPerLine;
          Data &= ~(0xff << Shift);
          Data |= Pixel << Shift;
          if (!--ysize) {
            break;
          }
          x0--;
        } while (xOdd--);
        WRITE_MEM(Off, Data);
        Off--;
      }
      /* Complete DWORDS */
      while (ysize >= 4) {
        Data  = (*(pTrans + *pData)) << 24;
        pData += BytesPerLine;
        Data |= (*(pTrans + *pData)) << 16;
        pData += BytesPerLine;
        Data |= (*(pTrans + *pData)) << 8;
        pData += BytesPerLine;
        Data |= *(pTrans + *pData);
        pData += BytesPerLine;
        WRITE_MEM(Off, Data);
        ysize -= 4;
        x0 -= 4;
        Off--;
      }
      /* Last DWORD */
      if (ysize) {
        Data = READ_MEM(Off);
        Data &= ~0xff000000;
        Data |= (*(pTrans + *pData)) << 24;
        if (ysize > 1) {
          pData += BytesPerLine;
          Data &= ~0xff0000;
          Data |= (*(pTrans + *pData)) << 16;
          if (ysize > 2) {
            pData += BytesPerLine;
            Data &= ~0xff00;
            Data |= (*(pTrans + *pData)) << 8;
          }
        }
        WRITE_MEM(Off, Data);
      }
    } else {
      /* First DWORD */
      if (xOdd < 3) {
        Data = READ_MEM(Off);
        do {
          Shift = xOdd << 3;
          Pixel = *pData;
          pData += BytesPerLine;
          Data &= ~(0xff << Shift);
          Data |= Pixel << Shift;
          if (!--ysize) {
            break;
          }
          x0--;
        } while (xOdd--);
        WRITE_MEM(Off, Data);
        Off--;
      }
      /* Complete DWORDS */
      while (ysize >= 4) {
        Data  = (*pData) << 24;
        pData += BytesPerLine;
        Data |= (*pData) << 16;
        pData += BytesPerLine;
        Data |= (*pData) << 8;
        pData += BytesPerLine;
        Data |= *pData;
        pData += BytesPerLine;
        WRITE_MEM(Off, Data);
        ysize -= 4;
        x0 -= 4;
        Off--;
      }
      /* Last DWORD */
      if (ysize) {
        Data = READ_MEM(Off);
        Data &= ~0xff000000;
        Data |= (*pData) << 24;
        if (ysize > 1) {
          pData += BytesPerLine;
          Data &= ~0xff0000;
          Data |= (*pData) << 16;
          if (ysize > 2) {
            pData += BytesPerLine;
            Data &= ~0xff00;
            Data |= (*pData) << 8;
          }
        }
        WRITE_MEM(Off, Data);
      }
    }
  } else {
    /* Handle transparent bitmaps */
    if (pTrans) {
      /* First DWORD */
      if (xOdd < 3) {
        Data = READ_MEM(Off);
        do {
          Shift = xOdd << 3;
          Index = *pData;
          pData += BytesPerLine;
          if (Index) {
            Pixel = *(pTrans + Index);
            Data &= ~(0xff << Shift);
            Data |= Pixel << Shift;
          }
          if (!--ysize) {
            break;
          }
          x0--;
        } while (xOdd--);
        WRITE_MEM(Off, Data);
        Off--;
      }
      /* Complete DWORDS */
      while (ysize >= 4) {
        Data = READ_MEM(Off);
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 24);
          Data |= (*(pTrans + Index)) << 24;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 16);
          Data |= (*(pTrans + Index)) << 16;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 8);
          Data |= (*(pTrans + Index)) << 8;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff);
          Data |= (*(pTrans + Index));
        }
        WRITE_MEM(Off, Data);
        ysize -= 4;
        x0 -= 4;
        Off--;
      }
      /* Last DWORD */
      if (ysize) {
        Data = READ_MEM(Off);
        Index = *pData;
        if (Index) {
          Data &= ~0xff000000;
          Data |= (*(pTrans + Index)) << 24;
        }
        if (ysize > 1) {
          pData += BytesPerLine;
          Index = *pData;
          if (Index) {
            Data &= ~0xff0000;
            Data |= (*(pTrans + Index)) << 16;
          }
          if (ysize > 2) {
            pData += BytesPerLine;
            Index = *pData;
            if (Index) {
              Data &= ~0xff00;
              Data |= (*(pTrans + Index)) << 8;
            }
          }
        }
        WRITE_MEM(Off, Data);
      }
    } else {
      /* First DWORD */
      if (xOdd < 3) {
        Data = READ_MEM(Off);
        do {
          Shift = xOdd << 3;
          Index = *pData;
          pData += BytesPerLine;
          if (Index) {
            Data &= ~(0xff << Shift);
            Data |= Index << Shift;
          }
          if (!--ysize) {
            break;
          }
          x0--;
        } while (xOdd--);
        WRITE_MEM(Off, Data);
        Off--;
      }
      /* Complete DWORDS */
      while (ysize >= 4) {
        Data = READ_MEM(Off);
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 24);
          Data |= Index << 24;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 16);
          Data |= Index << 16;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff << 8);
          Data |= Index << 8;
        }
        Index = *pData;
        pData += BytesPerLine;
        if (Index) {
          Data &= ~(0xff);
          Data |= Index;
        }
        WRITE_MEM(Off, Data);
        ysize -= 4;
        x0 -= 4;
        Off--;
      }
      /* Last DWORD */
      if (ysize) {
        Data = READ_MEM(Off);
        Index = *pData;
        if (Index) {
          Data &= ~0xff000000;
          Data |= Index << 24;
        }
        if (ysize > 1) {
          pData += BytesPerLine;
          Index = *pData;
          if (Index) {
            Data &= ~0xff0000;
            Data |= Index << 16;
          }
          if (ysize > 2) {
            pData += BytesPerLine;
            Index = *pData;
            if (Index) {
              Data &= ~0xff00;