lcd13xx.c

S3C44B0X在UCOSII的源码

/*
        *********************************************************
        *                                                       *
        *       LCD_L0_SetPixelIndex                            *
        *                                                       *
        *********************************************************

Purpose:  This routine is called by emWin. It writes 1 pixel into the
          display.

*/
void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  SETPIXEL(x, y, ColorIndex);
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine 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_DrawHLine  (int x0, int y,  int x1) {
  #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-(y))
  #else
    #define Y0 y
  #endif
  if (x0>x1) return;
  LCD_FillRectBB(X0,Y0,X1,Y0);
  #undef X0
  #undef X1
  #undef Y0
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          16 bit bus, 16 bpp                           *
        *                                                       *
        *********************************************************
*/

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

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
  #else
    #define X0 x0
  #endif
  if (x0>x1) return;
  {
    register tOff Off = XY2OFF(X0,y);
    register int Rem = x1-x0+1;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; Rem--; Off++) {
        U16 Data;
        READ_MEM(Off, Data);
        Data = LCD_NUM_COLORS-1-Data;
        WRITE_MEM(Off,Data);
      }
    } else {
      for (; Rem >= 8; Off += 8) {
        WRITE_MEM(Off,COLOR);
        WRITE_MEM(Off+1,COLOR);
        WRITE_MEM(Off+2,COLOR);
        WRITE_MEM(Off+3,COLOR);
        WRITE_MEM(Off+4,COLOR);
        WRITE_MEM(Off+5,COLOR);
        WRITE_MEM(Off+6,COLOR);
        WRITE_MEM(Off+7,COLOR);
        Rem -=8;
      }
      for (; Rem--; Off++) {
        WRITE_MEM(Off,COLOR);
      }
    }
  }
  #undef X0
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                   *
        *                                                       *
        *          16 bit bus, 8 bpp                            *
        *                                                       *
        *********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (LCD_BUSWIDTH==16)      \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 8)
      
void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
  {
    int t = (LCD_XSIZE-1-(x0));
    x0 = (LCD_XSIZE-1-(x1));
    x1 = t;
  }
  #endif
  #if LCD_MIRROR_Y
    y = (LCD_YSIZE-1-(y));
  #endif
  {
    register tOff Off = XY2OFF(x0,y);
    /* register */ U16 Data;
/* XOR mode */
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      if (x0&1) {
        READ_MEM(Off, Data);
        Data ^= ((unsigned int)255);
        WRITE_MEM(Off,Data);
        x0++;
        Off++;
      }
      for (; x0<x1; x0+=2, Off++) {
        READ_MEM(Off,Data);
        Data ^= 0xffff;
        WRITE_MEM(Off,Data);
      }      
      if ((x1&1)==0) {
        READ_MEM(Off,Data);
        Data ^=  (U16)255<<8;
        WRITE_MEM(Off,Data);
      }
/* WRITE mode */
    } else {
      if (x0&1) {
        READ_MEM(Off,Data);
        Data = (Data&((U16)0xff<<8)) | (COLOR);
        WRITE_MEM(Off,Data);
        x0++;
        Off++;
      }
      Data = COLOR|((U16)COLOR<<8);
      /* Optimization for longer lines ... */
      #ifdef LCD_WRITE_MEM32
      if ((x0<x1-4) && (x0&2)) { /* Write 16 bits if necessary */
        WRITE_MEM(Off,Data);
        x0+=2;
        Off++;
      }
      /* write 4 pixels at a time, loop unrolled  */
      { register U32 Data32 = Data| (Data<<16);
        for (;x0<x1-32-2; x0+=32, Off+=16) {
          LCD_WRITE_MEM32(Off+0,Data32);
          LCD_WRITE_MEM32(Off+2,Data32);
          LCD_WRITE_MEM32(Off+4,Data32);
          LCD_WRITE_MEM32(Off+6,Data32);
          LCD_WRITE_MEM32(Off+8,Data32);
          LCD_WRITE_MEM32(Off+10,Data32);
          LCD_WRITE_MEM32(Off+12,Data32);
          LCD_WRITE_MEM32(Off+14,Data32);
        }
      }
      { register U32 Data32 = Data| (Data<<16);
        for (;x0<x1-16-2; x0+=16, Off+=8) {
          LCD_WRITE_MEM32(Off+0,Data32);
          LCD_WRITE_MEM32(Off+2,Data32);
          LCD_WRITE_MEM32(Off+4,Data32);
          LCD_WRITE_MEM32(Off+6,Data32);
        }
      }
      { register U32 Data32 = Data| (Data<<16);
        for (;x0<x1-8-2; x0+=8, Off+=4) {
          LCD_WRITE_MEM32(Off+0,Data32);
          LCD_WRITE_MEM32(Off+2,Data32);
        }
      }
      #else
      for (;x0<x1-10; x0+=12, Off+=6) {
        /* swapping can be ignored, so use faster LCD_WRITE_MEM */
        LCD_WRITE_MEM(Off,Data); 
        LCD_WRITE_MEM(Off+1,Data);
        LCD_WRITE_MEM(Off+2,Data);
        LCD_WRITE_MEM(Off+3,Data);
        LCD_WRITE_MEM(Off+4,Data);
        LCD_WRITE_MEM(Off+5,Data);
      }
      #endif
      /* write the last pixels 2 at a time */
      for (; x0<x1; x0+=2, Off++) {
        /* swapping can be ignored, so use faster LCD_WRITE_MEM */
        LCD_WRITE_MEM(Off,Data);
      }      
      if ((x1&1)==0) {
        READ_MEM(Off, Data);
        Data = (Data&((unsigned int)0xff)) | ((U16)COLOR<<8);
        WRITE_MEM(Off,Data);
      }
    }
  }
}



/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                   *
        *                                                       *
        *          16 bit bus, 4 bpp                            *
        *                                                       *
        *********************************************************
*/

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

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
  #else
    #define X0 x0
  #endif
  #if LCD_MIRROR_Y
    #define Y (LCD_YSIZE - 1 - y)
  #else
    #define Y y
  #endif
  if (x0>x1) return;
  {
    register tOff Off;
    register int Rem;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; (x0&3    )&&(x0<=x1); x0++) XORPIXEL(x0, y);
      for (; ((x1+1)&3)&&(x0<=x1); x1--) XORPIXEL(x1, y);
      Off = XY2OFF(X0,Y);
      Rem = (x1-x0+4)>>2;
      for (; Rem--; Off++) {
        U16 c;
        READ_MEM(Off, c);
        c ^= 0xffff; 
        WRITE_MEM(Off,c);
      }
    } else {
      U16 col = COLOR+(COLOR<<4)+(COLOR<<8)+(COLOR<<12);
      for (; (x0&3    )&&(x0<=x1); x0++)
        SETPIXEL(x0, y, COLOR);
      for (; ((x1+1)&3)&&(x0<=x1); x1--)
        SETPIXEL(x1, y, COLOR);
      Off = XY2OFF(X0,Y);
      Rem = (x1-x0+4)>>2;
      for (; Rem--; Off++) {
        /* swapping can be ignored, so use faster LCD_WRITE_MEM */
        LCD_WRITE_MEM(Off,col);
      }
    }
  }
  #undef X0
}

/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                   *
        *                                                       *
        *          16 bit bus, 1 bpp                            *
        *                                                       *
        *********************************************************
*/

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

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
  {
    int temp = x0;
    x0 = (LCD_XSIZE-1-(x1));
    x1 = (LCD_XSIZE-1-(temp));
  }
  #endif
  #if LCD_MIRROR_Y
  {
    y = (LCD_YSIZE - 1 - y);
  }
  #endif
  {
    register tOff Off = XY2OFF(x0,y);
    int iWord = x0>>4;
    int Word1 = x1>>4;
    U16 Mask   =  0xffff   >> (x0&15);
    U16 EndMask = 0xffff8000 >> (x1&15);
    U16 Data;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; iWord<Word1; iWord++) {
        READ_MEM(Off,Data);
        Data ^= Mask; 
        WRITE_MEM(Off++,Data);
        Mask = 0xffff;
      }
      Mask &= EndMask;
      READ_MEM(Off,Data);
      Data ^= Mask; 
      WRITE_MEM(Off++,Data);
    } else {                                  /* Clear pixels in line */
      int NumWords = Word1-iWord;
      if (COLOR==0) {
        if (NumWords) {
          READ_MEM(Off,Data);
          Data &= ~Mask;
          WRITE_MEM(Off++,Data);
          NumWords--;
          /* Fill Words in 2 loops for speed reasons ... */
          for (; NumWords>=4; NumWords-=4) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
          }
          for (; NumWords; NumWords--) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0);
          }
          Mask = 0xffff;
        }
        Mask &= EndMask;
        READ_MEM(Off, Data);
        Data &= ~Mask; 
        WRITE_MEM(Off++,Data);
      } else {                                  /* Set pixels in line */
        if (NumWords) {
          READ_MEM(Off, Data); 
          Data |= Mask; 
          WRITE_MEM(Off++,Data);
          NumWords--;
        /* Fill Words in 2 loops for speed reasons ... */
          for (; NumWords>=4; NumWords-=4) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
          }
          for (; NumWords; NumWords--) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0xffff);
          }
          Mask = 0xffff;
        }
        Mask &= EndMask;
        READ_MEM(Off, Data); 
        Data |= Mask; 
        WRITE_MEM(Off++,Data);
      }
    }
  }
}

/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          8 bit bus, 8 bpp                             *
        *                                                       *
        *********************************************************
*/

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

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
  #else
    #define X0 x0
  #endif
  #if LCD_MIRROR_Y
    y = LCD_YSIZE - 1 - y;
  #endif
  if (x0>x1) return;
  {
    register tOff Off = XY2OFF(X0,y);
    register int Rem = x1-x0+1;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; (--Rem)>=0; Off++) {
        U16 c;
        READ_MEM(Off,c);
        c ^= 0xff; 
        WRITE_MEM(Off,c);
      }
    } else {
      for (;Rem>=4;Off+=4,Rem-=4) {
        WRITE_MEM(Off,COLOR);
        WRITE_MEM(Off+1,COLOR);
        WRITE_MEM(Off+2,COLOR);
        WRITE_MEM(Off+3,COLOR);
	  }
      for (; (--Rem)>=0; Off++) {
        WRITE_MEM(Off,COLOR);
      }
    }
  }
  #undef X0