lcd13xx.c

S3C44B0X在UCOSII的源码

}

#endif


/*
        *********************************************************
        *                                                       *
        *          LCD_FillRect Optimized                       *
        *                                                       *
        *          16 bit bus, Using BITBLT                     *
        *                                                       *
        *********************************************************
*/

#if (LCD_USE_BITBLT)           \
    && (!LCD_SWAP_XY)          \
    && (LCD_BUSWIDTH==16)      \
    && (!defined (LCD_LUT_COM))   \
    && (!defined (LCD_LUT_SEG))   \
    && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))

void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
    #define X1 (LCD_XSIZE-1-(x0))
  #else
    #define X0 x0
    #define X1 x1
  #endif
  #if LCD_MIRROR_Y
    #define Y0 (LCD_YSIZE-1-(y1))
    #define Y1 (LCD_YSIZE-1-(y0))
  #else
    #define Y0 y0
    #define Y1 y1
  #endif
  if ((x0>x1) | (y0>y1)) return;
  LCD_FillRectBB(X0,Y0,X1,Y1);
  #undef X0
  #undef X1
  #undef Y0
  #undef Y1
}

#else


/*
        *********************************************************
        *                                                       *
        *          LCD_FillRect                                 *
        *                                                       *
        *********************************************************
*/

void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
#if !LCD_SWAP_XY
  for (; y0 <= y1; y0++) {
    LCD_L0_DrawHLine(x0,y0, x1);
  }
#else
  for (; x0 <= x1; x0++) {
    LCD_L0_DrawVLine(x0,y0, y1);
  }
#endif
}

#endif


/********************************************************
*
*          Draw Bitmap 1 BPP Optimzed
*
*          8 bit bus, 1 bpp
*
*********************************************************
*/

#if (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_Y)         \
      && (!LCD_MIRROR_X)         \
      && (LCD_BUSWIDTH==8)       \
      && (!defined (LCD_LUT_COM))   \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 1)


static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
/* only normal mode optimized */
  if (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR))
    goto DrawBitLine1BPP_NoOpt;
  {
    LCD_PIXELINDEX Index0 = *(pTrans+0);
    LCD_PIXELINDEX Index1 = *(pTrans+1);
    x+=Diff;
  /* Check if filling will do ... */
    if (Index0==Index1) {
      LCD_PIXELINDEX ColorIndexOld= COLOR;  /* Save forground color */
      COLOR = Index0;              /* Set foreground color */
      LCD_L0_DrawHLine(x,y,x+xsize-1);
      COLOR = ColorIndexOld;
      return;
    }  
    {
  /* O.K., we have to draw ... */
      tOff Off  = XY2OFF(x,y);
      int x1 = x+xsize-1;
      U8 Mask =    0xff   >> (x &7);
      U8 EndMask = 0xff80 >> (x1&7);
      U8 Data;
      U16 XorData = Index1 ? 0 : 0xffff;
      U16 PixelData;
      int NumBytes = (x1>>3) - (x>>3);
      if (NumBytes) {
  /* Write first byte (Needs to be masked) */
        READ_MEM(Off,Data);
        Data &= (~Mask);
        PixelData   = (*(p+1) | ((*p)<<8)) ^ XorData;
        PixelData >>= (8+(x&7)-(Diff&7));
        Data |= PixelData&Mask;
        WRITE_MEM(Off,Data);
        { int DiffOld = Diff;
          Diff+= 8-(x&7); 
          if ((DiffOld&~7) != (Diff&~7))
            p++;
        }
        x=0;
        Off++; NumBytes--;
  /* Write full byte */
        for (; NumBytes; NumBytes--, Off++) {
          PixelData   = (*(p+1) | ((*p)<<8))^XorData;
          PixelData >>= (8-(Diff&7));
          p++;
          WRITE_MEM(Off, PixelData);
        }
        Mask = 0xff;
      }
      PixelData   = (*(p+1) | ((*p)<<8))^XorData;
      PixelData >>= (8+(x&7)-(Diff&7));
      Mask &= EndMask;
      READ_MEM(Off,Data);
      Data &= (~Mask);
      Data |= PixelData&Mask;
      WRITE_MEM(Off,Data);
    }
    return;
  }
/* no optimization */
DrawBitLine1BPP_NoOpt:
  {
    LCD_PIXELINDEX pixels;
    LCD_PIXELINDEX Index0 = *(pTrans+0);
    LCD_PIXELINDEX Index1 = *(pTrans+1);
  /*
  // Jump to right entry point
  */
    pixels = *p;
    switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
    case LCD_DRAWMODE_TRANS:
      switch (Diff&7) {
      case 0:
        goto WriteTBit0;
      case 1:
        goto WriteTBit1;
      case 2:
        goto WriteTBit2;
      case 3:
        goto WriteTBit3;
      case 4:
        goto WriteTBit4;
      case 5:   
        goto WriteTBit5;
      case 6:   
        goto WriteTBit6;
      case 7:   
        goto WriteTBit7;
      }
      break;
    case LCD_DRAWMODE_XOR:
      switch (Diff&7) {
      case 0:   
        goto WriteXBit0;
      case 1:   
        goto WriteXBit1;
      case 2:
        goto WriteXBit2;
      case 3:
        goto WriteXBit3;
      case 4:
        goto WriteXBit4;
      case 5:   
        goto WriteXBit5;
      case 6:   
        goto WriteXBit6;
      case 7:   
        goto WriteXBit7;
      }
    }
  /*
          Write with transparency
  */
    WriteTBit0:
      if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
      if (!--xsize)
        return;
    WriteTBit1:
      if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
      if (!--xsize)
        return;
    WriteTBit2:
      if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
      if (!--xsize)
        return;
    WriteTBit3:
      if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
      if (!--xsize)
        return;
    WriteTBit4:
      if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
      if (!--xsize)
        return;
    WriteTBit5:
      if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
      if (!--xsize)
        return;
    WriteTBit6:
      if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
      if (!--xsize)
        return;
    WriteTBit7:
      if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
      if (!--xsize)
        return;
      x+=8;
      pixels = *(++p);
      goto WriteTBit0;
  /*
          Write XOR mode
  */
    WriteXBit0:
      if (pixels&(1<<7))
        XORPIXEL(x+0, y);
      if (!--xsize)
        return;
    WriteXBit1:
      if (pixels&(1<<6))
        XORPIXEL(x+1, y);
      if (!--xsize)
        return;
    WriteXBit2:
      if (pixels&(1<<5))
        XORPIXEL(x+2, y);
      if (!--xsize)
        return;
    WriteXBit3:
      if (pixels&(1<<4))
        XORPIXEL(x+3, y);
      if (!--xsize)
        return;
    WriteXBit4:
      if (pixels&(1<<3))
        XORPIXEL(x+4, y);
      if (!--xsize)
        return;
    WriteXBit5:
      if (pixels&(1<<2))
        XORPIXEL(x+5, y);
      if (!--xsize)
        return;
    WriteXBit6:
      if (pixels&(1<<1))
        XORPIXEL(x+6, y);
      if (!--xsize)
        return;
    WriteXBit7:
      if (pixels&(1<<0))
        XORPIXEL(x+7, y);
      if (!--xsize)
        return;
      x+=8;
      pixels = *(++p);
      goto WriteXBit0;
  }
}

/********************************************************
*
*          Draw Bitmap 1 BPP Optimzed
*
*          16 bit bus, 4 bpp mode, SWAP_XY
*
*********************************************************
*/

#elif (LCD_OPTIMIZE)               \
    && (LCD_SWAP_XY)             \
    && (!defined (LCD_LUT_COM))  \
    && (!defined (LCD_LUT_SEG))  \
    && (LCD_BITSPERPIXEL == 4)   \
    && (LCD_BUSWIDTH==16)

static const U8 ShiftNibble[] = {
  12, 8, 4, 0
};

static void DrawBitLine1BPP_Swap(
  int x,
  int y,
  U8 const * pData,
  int ysize,
  const U8 * pTrans,
  int BytesPerLine,
  U8 Pos)
{
  int y0 = x;
  #if LCD_MIRROR_Y || LCD_MIRROR_X
    int x0 = LCD_YSIZE - y - 1;
  #else
    int x0 = y;
  #endif
  tOff Off = XY2OFF(x0,y0);
  U16 Buffer, Data;
  U8 Index, Pixel;
  U8 BufferValid = 0;
  U8 ShiftPos = 7 - (Pos & 7);
  U16 DataMask = 0x80 >> (7 -ShiftPos);
  #if LCD_MIRROR_Y || LCD_MIRROR_X
    for (; ysize; ysize--, pData += BytesPerLine, x0--) {
  #else
    for (; ysize; ysize--, pData += BytesPerLine, x0++) {
  #endif
    U8 Shift = ShiftNibble[x0 & 3];
    Pixel = (*pData & DataMask) >> ShiftPos;
    if (!BufferValid) {
      READ_MEM(Off,Buffer);
      BufferValid = 1;
    }
    switch (GUI_Context.DrawMode) {
    case LCD_DRAWMODE_NORMAL:
    case LCD_DRAWMODE_REV:
      Buffer &= ~(0xF << Shift);
      Index = *(pTrans + Pixel);
      Data = Index << Shift;
      Buffer |= Data;
      break;
    case LCD_DRAWMODE_XOR:
      if (Pixel)
        Buffer ^= (0xF << Shift);
      break;
    case LCD_DRAWMODE_TRANS:
      if (Pixel) {
        Buffer &= ~(0xF << Shift);
        Index = *(pTrans + Pixel);
        Data = Index << Shift;
        Buffer |= Data;
      }
      break;
    }
    #if LCD_MIRROR_Y || LCD_MIRROR_X
      if (!(x0 & 3)) {
        BufferValid = 0;
        WRITE_MEM(Off--, Buffer);
      }
    #else
      if ((x0 & 3) == 3) {
        BufferValid = 0;
        WRITE_MEM(Off++, Buffer);
      }
    #endif
  }
  if (BufferValid)
    WRITE_MEM(Off, Buffer);
}

/********************************************************
*
*          Draw Bitmap 1 BPP Optimzed
*
*          16 bit bus, 8 bpp mode
*
*********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_X)         \
      && (LCD_BUSWIDTH==16)       \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 8)

static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  U8 Pixels = *p;
  U8 RemPixels;
  x+= Diff;
  RemPixels = 8-Diff;
  Pixels <<= Diff;
  /* Handle transparent bitmaps */
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    do {
      if (RemPixels==0) {
        Pixels = *(++p);
        RemPixels =8;
      }
      if (Pixels & 0x80) {
        XORPIXEL(x, y);
      }
      RemPixels--;
      Pixels <<=1;
      x++;
    } while (--xsize);
  } else if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
    do {
      if (RemPixels==0) {
        Pixels = *(++p);
        RemPixels =8;
      }
      if (Pixels & 0x80) {
        SETPIXEL(x, y, *(pTrans+1));
      }
      RemPixels--;
      Pixels <<=1;
      x++;
    } while (--xsize);
  } else {
    /* Handle solid bitmaps */
    tOff Off;
    #if LCD_MIRROR_Y
      y = (LCD_YSIZE-1-(y));
    #endif
    Off = XY2OFF(x,y);
    /* Handle left border (incomplete words) */
    if (x&1) {
      U16 Data, Pixel;
      READ_MEM(Off,Data);
      Pixel = *(pTrans+(Pixels>>7));
      Data = (Data &  ((