dlls/gdi32/dibdrv/primitives.c

   1 /*
   2  * DIB driver primitives.
   3  *
   4  * Copyright 2011 Huw Davies
   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 "gdi_private.h"
  22 #include "dibdrv.h"
  23
  24 static inline DWORD *get_pixel_ptr_32(const dib_info *dib, int x, int y)
  25 {
  26     return (DWORD *)((BYTE*)dib->bits + y * dib->stride + x * 4);
  27 }
  28
  29 static inline WORD *get_pixel_ptr_16(const dib_info *dib, int x, int y)
  30 {
  31     return (WORD *)((BYTE*)dib->bits + y * dib->stride + x * 2);
  32 }
  33
  34 static inline void do_rop_32(DWORD *ptr, DWORD and, DWORD xor)
  35 {
  36     *ptr = (*ptr & and) ^ xor;
  37 }
  38
  39 static inline void do_rop_16(WORD *ptr, WORD and, WORD xor)
  40 {
  41     *ptr = (*ptr & and) ^ xor;
  42 }
  43
  44 static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
  45 {
  46     DWORD *ptr, *start;
  47     int x, y, i;
  48
  49     for(i = 0; i < num; i++, rc++)
  50     {
  51         start = get_pixel_ptr_32(dib, rc->left, rc->top);
  52         for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
  53             for(x = rc->left, ptr = start; x < rc->right; x++)
  54                 do_rop_32(ptr++, and, xor);
  55     }
  56 }
  57
  58 static void solid_rects_16(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
  59 {
  60     WORD *ptr, *start;
  61     int x, y, i;
  62
  63     for(i = 0; i < num; i++, rc++)
  64     {
  65         start = get_pixel_ptr_16(dib, rc->left, rc->top);
  66         for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
  67             for(x = rc->left, ptr = start; x < rc->right; x++)
  68                 do_rop_16(ptr++, and, xor);
  69     }
  70 }
  71
  72 static void solid_rects_null(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
  73 {
  74     return;
  75 }
  76
  77 static inline INT calc_offset(INT edge, INT size, INT origin)
  78 {
  79     INT offset;
  80
  81     if(edge - origin >= 0)
  82         offset = (edge - origin) % size;
  83     else
  84     {
  85         offset = (origin - edge) % size;
  86         if(offset) offset = size - offset;
  87     }
  88     return offset;
  89 }
  90
  91 static inline POINT calc_brush_offset(const RECT *rc, const dib_info *brush, const POINT *origin)
  92 {
  93     POINT offset;
  94
  95     offset.x = calc_offset(rc->left, brush->width,  origin->x);
  96     offset.y = calc_offset(rc->top,  brush->height, origin->y);
  97
  98     return offset;
  99 }
 100
 101 static void pattern_rects_32(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
 102                              const dib_info *brush, void *and_bits, void *xor_bits)
 103 {
 104     DWORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
 105     int x, y, i;
 106     POINT offset;
 107
 108     for(i = 0; i < num; i++, rc++)
 109     {
 110         offset = calc_brush_offset(rc, brush, origin);
 111
 112         start = get_pixel_ptr_32(dib, rc->left, rc->top);
 113         start_and = (DWORD*)and_bits + offset.y * brush->stride / 4;
 114         start_xor = (DWORD*)xor_bits + offset.y * brush->stride / 4;
 115
 116         for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
 117         {
 118             and_ptr = start_and + offset.x;
 119             xor_ptr = start_xor + offset.x;
 120
 121             for(x = rc->left, ptr = start; x < rc->right; x++)
 122             {
 123                 do_rop_32(ptr++, *and_ptr++, *xor_ptr++);
 124                 if(and_ptr == start_and + brush->width)
 125                 {
 126                     and_ptr = start_and;
 127                     xor_ptr = start_xor;
 128                 }
 129             }
 130
 131             offset.y++;
 132             if(offset.y == brush->height)
 133             {
 134                 start_and = and_bits;
 135                 start_xor = xor_bits;
 136                 offset.y = 0;
 137             }
 138             else
 139             {
 140                 start_and += brush->stride / 4;
 141                 start_xor += brush->stride / 4;
 142             }
 143         }
 144     }
 145 }
 146
 147 static void pattern_rects_16(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
 148                              const dib_info *brush, void *and_bits, void *xor_bits)
 149 {
 150     WORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
 151     int x, y, i;
 152     POINT offset;
 153
 154     for(i = 0; i < num; i++, rc++)
 155     {
 156         offset = calc_brush_offset(rc, brush, origin);
 157
 158         start = get_pixel_ptr_16(dib, rc->left, rc->top);
 159         start_and = (WORD*)and_bits + offset.y * brush->stride / 2;
 160         start_xor = (WORD*)xor_bits + offset.y * brush->stride / 2;
 161
 162         for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
 163         {
 164             and_ptr = start_and + offset.x;
 165             xor_ptr = start_xor + offset.x;
 166
 167             for(x = rc->left, ptr = start; x < rc->right; x++)
 168             {
 169                 do_rop_16(ptr++, *and_ptr++, *xor_ptr++);
 170                 if(and_ptr == start_and + brush->width)
 171                 {
 172                     and_ptr = start_and;
 173                     xor_ptr = start_xor;
 174                 }
 175             }
 176
 177             offset.y++;
 178             if(offset.y == brush->height)
 179             {
 180                 start_and = and_bits;
 181                 start_xor = xor_bits;
 182                 offset.y = 0;
 183             }
 184             else
 185             {
 186                 start_and += brush->stride / 2;
 187                 start_xor += brush->stride / 2;
 188             }
 189         }
 190     }
 191 }
 192
 193 static void pattern_rects_null(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
 194                                const dib_info *brush, void *and_bits, void *xor_bits)
 195 {
 196     return;
 197 }
 198
 199 static DWORD colorref_to_pixel_888(const dib_info *dib, COLORREF color)
 200 {
 201     return ( ((color >> 16) & 0xff) | (color & 0xff00) | ((color << 16) & 0xff0000) );
 202 }
 203
 204 static inline DWORD put_field(DWORD field, int shift, int len)
 205 {
 206     shift = shift - (8 - len);
 207     if (len <= 8)
 208         field &= (((1 << len) - 1) << (8 - len));
 209     if (shift < 0)
 210         field >>= -shift;
 211     else
 212         field <<= shift;
 213     return field;
 214 }
 215
 216 static DWORD colorref_to_pixel_masks(const dib_info *dib, COLORREF colour)
 217 {
 218     DWORD r,g,b;
 219
 220     r = GetRValue(colour);
 221     g = GetGValue(colour);
 222     b = GetBValue(colour);
 223
 224     return put_field(r, dib->red_shift,   dib->red_len) |
 225            put_field(g, dib->green_shift, dib->green_len) |
 226            put_field(b, dib->blue_shift,  dib->blue_len);
 227 }
 228
 229 static DWORD colorref_to_pixel_555(const dib_info *dib, COLORREF color)
 230 {
 231     return ( ((color >> 19) & 0x1f) | ((color >> 6) & 0x03e0) | ((color << 7) & 0x7c00) );
 232 }
 233
 234
 235 static DWORD colorref_to_pixel_null(const dib_info *dib, COLORREF color)
 236 {
 237     return 0;
 238 }
 239
 240 const primitive_funcs funcs_8888 =
 241 {
 242     solid_rects_32,
 243     pattern_rects_32,
 244     colorref_to_pixel_888
 245 };
 246
 247 const primitive_funcs funcs_32 =
 248 {
 249     solid_rects_32,
 250     pattern_rects_32,
 251     colorref_to_pixel_masks
 252 };
 253
 254 const primitive_funcs funcs_555 =
 255 {
 256     solid_rects_16,
 257     pattern_rects_16,
 258     colorref_to_pixel_555
 259 };
 260
 261 const primitive_funcs funcs_16 =
 262 {
 263     solid_rects_16,
 264     pattern_rects_16,
 265     colorref_to_pixel_masks
 266 };
 267
 268 const primitive_funcs funcs_null =
 269 {
 270     solid_rects_null,
 271     pattern_rects_null,
 272     colorref_to_pixel_null
 273 };