dlls/winedib.drv/primitives_pixel.c

   1 /*
   2  * DIB Engine pixel Primitives
   3  *
   4  * Copyright 2009 Massimo Del Fedele
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "dibdrv.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dibdrv);
  27
  28 /* ------------------------------------------------------------*/
  29 /*                     BITFIELD HELPERS                        */
  30 static inline DWORD GetField32 (DWORD pixel, int shift, int len)
  31 {
  32     pixel = pixel & (((1 << (len)) - 1) << shift);
  33     pixel = pixel << (32 - (shift + len)) >> 24;
  34     return pixel;
  35 }
  36
  37 /* ------------------------------------------------------------*/
  38 /*                     PIXEL POINTER READING                   */
  39 void *_DIBDRV_GetPixelPointer32(const DIBDRVBITMAP *dib, int x, int y)
  40 {
  41     BYTE *ptr = dib->bits;
  42
  43     ptr += (y * dib->stride);
  44
  45     ptr += x * 4;
  46     return ptr;
  47 }
  48
  49 void *_DIBDRV_GetPixelPointer24(const DIBDRVBITMAP *dib, int x, int y)
  50 {
  51     BYTE *ptr = dib->bits;
  52
  53     ptr += (y * dib->stride);
  54
  55     ptr += x * 3;
  56     return ptr;
  57 }
  58
  59 void *_DIBDRV_GetPixelPointer16(const DIBDRVBITMAP *dib, int x, int y)
  60 {
  61     BYTE *ptr = dib->bits;
  62
  63     ptr += (y * dib->stride);
  64
  65     ptr += x * 2;
  66     return ptr;
  67 }
  68
  69 void *_DIBDRV_GetPixelPointer8(const DIBDRVBITMAP *dib, int x, int y)
  70 {
  71     BYTE *ptr = dib->bits;
  72
  73     ptr += (y * dib->stride);
  74
  75     ptr += x;
  76     return ptr;
  77 }
  78
  79 void *_DIBDRV_GetPixelPointer4(const DIBDRVBITMAP *dib, int x, int y)
  80 {
  81     BYTE *ptr = dib->bits;
  82
  83     ptr += (y * dib->stride);
  84
  85     ptr += x / 2;
  86     return ptr;
  87 }
  88
  89 void *_DIBDRV_GetPixelPointer1(const DIBDRVBITMAP *dib, int x, int y)
  90 {
  91     BYTE *ptr = dib->bits;
  92
  93     ptr += (y * dib->stride);
  94
  95     ptr += x / 8;
  96     return ptr;
  97 }
  98
  99 /* ------------------------------------------------------------*/
 100 /*                     PIXEL WRITING                           */
 101 void _DIBDRV_SetPixel32(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 102 {
 103     DWORD *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 104     _DIBDRV_rop32(ptr, and, xor);
 105 }
 106
 107 void _DIBDRV_SetPixel24(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 108 {
 109     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 110     _DIBDRV_rop8(ptr,      and        & 0xff,  xor        & 0xff);
 111     _DIBDRV_rop8(ptr + 1, (and >> 8)  & 0xff, (xor >> 8)  & 0xff);
 112     _DIBDRV_rop8(ptr + 2, (and >> 16) & 0xff, (xor >> 16) & 0xff);
 113 }
 114
 115 void _DIBDRV_SetPixel16(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 116 {
 117     WORD *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 118     _DIBDRV_rop16(ptr, and, xor);
 119 }
 120
 121 void _DIBDRV_SetPixel8(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 122 {
 123     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 124     _DIBDRV_rop8(ptr, and, xor);
 125 }
 126
 127 void _DIBDRV_SetPixel4(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 128 {
 129     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 130     BYTE byte_and, byte_xor;
 131
 132     if(x & 1) /* upper nibble untouched */
 133     {
 134         byte_and = (and & 0xf) | 0xf0;
 135         byte_xor = (xor & 0xf);
 136     }
 137     else
 138     {
 139         byte_and = ((and << 4) & 0xf0) | 0x0f;
 140         byte_xor = ((xor << 4) & 0xf0);
 141     }
 142
 143     _DIBDRV_rop8(ptr, byte_and, byte_xor);
 144 }
 145
 146 void _DIBDRV_SetPixel1(DIBDRVBITMAP *dib, int x, int y, DWORD and, DWORD xor)
 147 {
 148     BYTE *ptr;
 149     BYTE byte_and = 0, byte_xor = 0, mask;
 150
 151     if(and & 1) byte_and = 0xff;
 152     if(xor & 1) byte_xor = 0xff;
 153
 154     mask = 1 << (7 - (x & 7));
 155
 156     byte_and |= ~mask;
 157     byte_xor &= mask;
 158
 159     ptr = dib->funcs->GetPixelPointer(dib, x, y);
 160
 161     _DIBDRV_rop8(ptr, byte_and, byte_xor);
 162 }
 163
 164 /* ------------------------------------------------------------*/
 165 /*                     PIXEL READING                           */
 166 DWORD _DIBDRV_GetPixel32_RGB(const DIBDRVBITMAP *dib, int x, int y)
 167 {
 168     DWORD c = *(DWORD *)dib->funcs->GetPixelPointer(dib, x, y);
 169     return
 170         ((c & 0x000000ff) << 16) |
 171         ((c & 0x0000ff00)      ) |
 172         ((c & 0x00ff0000) >> 16) |
 173         ( c & 0xff000000       );   /* last one for alpha channel */
 174 }
 175
 176 DWORD _DIBDRV_GetPixel32_BITFIELDS(const DIBDRVBITMAP *dib, int x, int y)
 177 {
 178     DWORD *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 179
 180     return GetField32(*ptr, dib->redShift,   dib->redLen)         |
 181            GetField32(*ptr, dib->greenShift, dib->greenLen) <<  8 |
 182            GetField32(*ptr, dib->blueShift,  dib->blueLen)  << 16;
 183 }
 184
 185 DWORD _DIBDRV_GetPixel24(const DIBDRVBITMAP *dib, int x, int y)
 186 {
 187     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 188     return ((WORD)ptr[0] << 16) | ((WORD)ptr[1] << 8) | (WORD)ptr[2];
 189 }
 190
 191 DWORD _DIBDRV_GetPixel16_RGB(const DIBDRVBITMAP *dib, int x, int y)
 192 {
 193     WORD c = *(WORD *)dib->funcs->GetPixelPointer(dib, x, y);
 194    /* 0RRR|RRGG|GGGB|BBBB */
 195    return ((c & 0x7c00) >> 7) | ((c & 0x03e0) << 6) | ((c & 0x001f) << 19);
 196 }
 197
 198 DWORD _DIBDRV_GetPixel16_BITFIELDS(const DIBDRVBITMAP *dib, int x, int y)
 199 {
 200     WORD c = *(WORD *)dib->funcs->GetPixelPointer(dib, x, y);
 201
 202     return (((c & dib->blueMask ) >> dib->blueShift ) << (24 - dib->blueLen )) |
 203            (((c & dib->greenMask) >> dib->greenShift) << (16 - dib->greenLen)) |
 204            (((c & dib->redMask  ) >> dib->redShift  ) << ( 8 - dib->redLen  ));
 205 }
 206
 207 DWORD _DIBDRV_GetPixel8(const DIBDRVBITMAP *dib, int x, int y)
 208 {
 209     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y);
 210     RGBQUAD *color = dib->colorTable + *ptr;
 211     return (color->rgbRed) | (color->rgbGreen << 8) | (color->rgbBlue << 16);
 212 }
 213
 214 DWORD _DIBDRV_GetPixel4(const DIBDRVBITMAP *dib, int x, int y)
 215 {
 216     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y), pix;
 217     RGBQUAD *color;
 218
 219     if(x & 1)
 220         pix = *ptr & 0x0f;
 221     else
 222         pix = *ptr >> 4;
 223
 224     color = dib->colorTable + pix;
 225     return (color->rgbRed) | (color->rgbGreen << 8) | (color->rgbBlue << 16);
 226 }
 227
 228 DWORD _DIBDRV_GetPixel1(const DIBDRVBITMAP *dib, int x, int y)
 229 {
 230     BYTE *ptr = dib->funcs->GetPixelPointer(dib, x, y), pix;
 231     RGBQUAD *color;
 232
 233     pix = *ptr;
 234
 235     pix >>= (7 - (x & 7));
 236     pix &= 1;
 237
 238     color = dib->colorTable + pix;
 239     return (color->rgbRed) | (color->rgbGreen << 8) | (color->rgbBlue << 16);
 240 }