dlls/winedib.drv/dib_render.c

   1 /*
   2  * DIBDRV depth specific DIB rendering functions
   3  *
   4  * Copyright 2007 Jesse Allen
   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
  23 #include <stdarg.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wine/debug.h"
  27
  28 #include "dib_render.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dibdrv);
  31
  32 /* DIB_GetColorTableEntry: Return color components of the requested color table entry. */
  33 void DIB_GetColorTableEntry( DIBDRVBITMAP *bmp, BYTE i, BYTE *r, BYTE *g, BYTE *b )
  34 {
  35     *r = bmp->color_table[i].rgbRed;
  36     *g = bmp->color_table[i].rgbGreen;
  37     *b = bmp->color_table[i].rgbBlue;
  38 }
  39
  40 /* DIB_GetNearestIndex: Return closest matching color table entry. */
  41 INT DIB_GetNearestIndex( DIBDRVBITMAP *bmp, BYTE r, BYTE g, BYTE b )
  42 {
  43     INT i, diff, bestdiff = -1, ret = 0;
  44     for (i = 0; i < bmp->nb_colors; i++)
  45     {
  46         diff = (bmp->color_table[i].rgbBlue - b)*(bmp->color_table[i].rgbBlue - b) +
  47                (bmp->color_table[i].rgbGreen - g)*(bmp->color_table[i].rgbGreen - g) +
  48                (bmp->color_table[i].rgbRed - r)*(bmp->color_table[i].rgbRed - r);
  49         if (!diff)
  50             return i;
  51         if (bestdiff == -1 || diff < bestdiff)
  52         {
  53             ret = i;
  54             bestdiff = diff;
  55         }
  56     }
  57     return ret;
  58 }
  59
  60 /* DIB16_EncodeColor: helper to encode a pixel for a 16 bpp DIB. */
  61 WORD DIB16_EncodeColor( DIBDRVBITMAP *bmp, BYTE r, BYTE g, BYTE b )
  62 {
  63     return (r >> bmp->bf_shift[0]) << bmp->bf_pos[0] |
  64            (g >> bmp->bf_shift[1]) << bmp->bf_pos[1] |
  65            (b >> bmp->bf_shift[2]) << bmp->bf_pos[2];
  66 }
  67
  68 /* DIB32_EncodeColor: helper to encode a pixel for a 32 bpp DIB. */
  69 DWORD DIB32_EncodeColor( DIBDRVBITMAP *bmp, BYTE r, BYTE g, BYTE b )
  70 {
  71     return ((r >> bmp->bf_shift[0]) << bmp->bf_pos[0]) |
  72            ((g >> bmp->bf_shift[1]) << bmp->bf_pos[1]) |
  73            ((b >> bmp->bf_shift[2]) << bmp->bf_pos[2]);
  74 }
  75
  76 /* Public Functions
  77  *
  78  * AdvancePosition(): Move drawing location relative to current position by the requested number
  79  * of pixels. It is the caller's responsibility to traverse scan lines correctly, as this does
  80  * not check for that.
  81  *
  82  * Copy(): Copy the requested number of pixels from source DIB to destination DIB performing format
  83  * conversions as necessary. Since this requires two images, call the Copy() member of the
  84  * destination image, pass the source conversion function table, and copy translates the call into
  85  * the appropriate conversion routine. The caller is responsible to traverse scan lines
  86  * correctly.
  87  *
  88  * MoveXY(): Move drawing location using X,Y coordinates. Stores address with whatever shifting
  89  * required to correct value. Returns a BOOL where FALSE means an attempt to move out of range.
  90  *
  91  * ReadColor(): Read pixel and translate into color components.
  92  *
  93  * SelectColor(): Store a color encoded for the DIB.
  94  *
  95  * SetPixel(): Optimized SetPixel for GDI by writing a COLORREF directly.
  96  *
  97  * WriteColor(): Write a number of pixels with stored color.
  98  */
  99
 100 void DIB1_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 101 {
 102     bmp->shift -= n;
 103     while (bmp->shift < 0)
 104     {
 105         bmp->addr = (BYTE*)bmp->addr + 1;
 106         bmp->shift += 8;
 107     }
 108 }
 109
 110 void DIB1_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 111 {
 112     convs->ConvertToDIB1( dst, src, num_pixels );
 113 }
 114
 115 void DIB1_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 116 {
 117     unsigned int r = (unsigned int)bmp->bits + y*bmp->widthbytes + x/8; /* 1 byte per 8 pixels */
 118     bmp->shift = 7 - x % 8; /* maximum shift within unsigned char: 7 */
 119     bmp->addr = (void *)r;
 120 }
 121
 122 void DIB1_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 123 {
 124     DIB_GetColorTableEntry( bmp, (*(BYTE *)bmp->addr >> bmp->shift) & 1, r, g, b );
 125 }
 126
 127 /* DIB1_SelectColor ----> DIB8_SelectColor */
 128
 129 void DIB1_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 130 {
 131     BYTE *p = bmp->addr;
 132     *p = DIB_GetNearestIndex( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) ) ?
 133          *p | 1 << bmp->shift : *p & ~(1 << bmp->shift);
 134 }
 135
 136 void DIB1_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 137 {
 138     int i;
 139     for (i = 0; i < num_pixels; i++)
 140     {
 141         BYTE *p = bmp->addr;
 142         *p = bmp->color8 ? *p | 1 << bmp->shift : *p & ~(1 << bmp->shift);
 143         DIB1_AdvancePosition( bmp, 1 );
 144     }
 145 }
 146
 147 void DIB4_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 148 {
 149     bmp->shift -= n;
 150     while (bmp->shift < 0)
 151     {
 152         bmp->addr = (BYTE*)bmp->addr + 1;
 153         bmp->shift += 2;
 154     }
 155 }
 156
 157 void DIB4_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 158 {
 159     convs->ConvertToDIB4( dst, src, num_pixels );
 160 }
 161
 162 void DIB4_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 163 {
 164     unsigned int r = (unsigned int)bmp->bits + y*bmp->widthbytes + x/2; /* 1 byte per 2 pixels */
 165     bmp->shift = x % 2; /* If true, we need the first 4 bits */
 166     bmp->addr = (void *)r;
 167 }
 168
 169 void DIB4_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 170 {
 171     DIB_GetColorTableEntry( bmp,
 172                                bmp->shift ? *(BYTE *)bmp->addr & 0xf : *(BYTE *)bmp->addr >> 4,
 173                                r, g, b );
 174 }
 175
 176 /* DIB4_SelectColor ----> DIB8_SelectColor */
 177
 178 void DIB4_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 179 {
 180     BYTE *p = bmp->addr;
 181     *p = bmp->shift ?
 182          (*p & 0xf0) |
 183          DIB_GetNearestIndex( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) ) :
 184          (*p & 0xf ) |
 185          (DIB_GetNearestIndex( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) ) << 4);
 186 }
 187
 188 void DIB4_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 189 {
 190     int i;
 191     for (i = 0; i < num_pixels; i++)
 192     {
 193         BYTE *p = bmp->addr;
 194         *p = bmp->shift ? (*p & 0xf0)|bmp->color8 : (*p & 0xf)|(bmp->color8 << 4);
 195         DIB4_AdvancePosition( bmp, 1 );
 196     }
 197 }
 198
 199 void DIB8_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 200 {
 201     bmp->addr = (BYTE*)bmp->addr + n;
 202 }
 203
 204 void DIB8_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 205 {
 206     convs->ConvertToDIB8( dst, src, num_pixels );
 207 }
 208
 209 void DIB8_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 210 {
 211     unsigned int r = (unsigned int)bmp->bits + y*bmp->widthbytes + x; /* 1 byte per 1 pixel */
 212     bmp->addr = (void *)r;
 213 }
 214
 215 void DIB8_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 216 {
 217     DIB_GetColorTableEntry( bmp, *(BYTE *)bmp->addr, r, g, b );
 218 }
 219
 220 void DIB8_SelectColor( DIBDRVBITMAP *bmp, COLORREF c )
 221 {
 222     bmp->color8 = DIB_GetNearestIndex( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 223 }
 224
 225 void DIB8_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 226 {
 227     *(BYTE *)bmp->addr = DIB_GetNearestIndex( bmp,
 228                          GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 229 }
 230
 231 void DIB8_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 232 {
 233     int i;
 234     for (i = 0; i < num_pixels; i++)
 235     {
 236         *(BYTE *)bmp->addr = bmp->color8;
 237         DIB8_AdvancePosition( bmp, 1 );
 238     }
 239 }
 240
 241 void DIB16_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 242 {
 243     bmp->addr = (WORD*)bmp->addr + n;
 244 }
 245
 246 void DIB16_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 247 {
 248     convs->ConvertToDIB16( dst, src, num_pixels );
 249 }
 250
 251 void DIB16_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 252 {
 253     unsigned int addr = (unsigned int)bmp->bits + y*bmp->widthbytes + x*2; /* 2 bytes per pixel */
 254     bmp->addr = (void *)addr;
 255 }
 256
 257 void DIB16_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 258 {
 259     WORD *p = bmp->addr;
 260     *r = (*p & bmp->bitfields[0]) >> bmp->bf_pos[0] << bmp->bf_shift[0];
 261     *g = (*p & bmp->bitfields[1]) >> bmp->bf_pos[1] << bmp->bf_shift[1];
 262     *b = (*p & bmp->bitfields[2]) >> bmp->bf_pos[2] << bmp->bf_shift[2];
 263     if (bmp->bf_size[0] < 8) *r |= *r >> bmp->bf_size[0];
 264     if (bmp->bf_size[1] < 8) *g |= *g >> bmp->bf_size[1];
 265     if (bmp->bf_size[2] < 8) *b |= *b >> bmp->bf_size[2];
 266 }
 267
 268 void DIB16_SelectColor( DIBDRVBITMAP *bmp, COLORREF c )
 269 {
 270     bmp->color16 = DIB16_EncodeColor( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 271 }
 272
 273 void DIB16_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 274 {
 275     *(WORD *)bmp->addr = DIB16_EncodeColor( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 276 }
 277
 278 void DIB16_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 279 {
 280     int i;
 281     for (i = 0; i < num_pixels; i++)
 282     {
 283         *(WORD *)bmp->addr = bmp->color16;
 284         DIB16_AdvancePosition( bmp, 1 );
 285     }
 286 }
 287
 288 void DIB24_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 289 {
 290     bmp->addr = (RGBTRIPLE*)bmp->addr + n;
 291 }
 292
 293 void DIB24_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 294 {
 295     convs->ConvertToDIB24( dst, src, num_pixels );
 296 }
 297
 298 void DIB24_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 299 {
 300     unsigned int addr = (unsigned int)bmp->bits + y*bmp->widthbytes + x*3; /* 3 bytes per pixel */
 301     bmp->addr = (void *)addr;
 302 }
 303
 304 void DIB24_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 305 {
 306     RGBTRIPLE *p = bmp->addr;
 307     *r = p->rgbtRed;
 308     *g = p->rgbtGreen;
 309     *b = p->rgbtBlue;
 310 }
 311
 312 void DIB24_SelectColor( DIBDRVBITMAP *bmp, COLORREF c )
 313 {
 314     bmp->color24.rgbtRed = GetRValue( c );
 315     bmp->color24.rgbtGreen = GetGValue( c );
 316     bmp->color24.rgbtBlue = GetBValue( c );
 317 }
 318
 319 void DIB24_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 320 {
 321     RGBTRIPLE *p = bmp->addr;
 322     p->rgbtRed = GetRValue( c );
 323     p->rgbtGreen = GetGValue( c );
 324     p->rgbtBlue = GetBValue( c );
 325 }
 326
 327 void DIB24_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 328 {
 329     int i;
 330     for (i = 0; i < num_pixels; i++)
 331     {
 332         RGBTRIPLE *p = bmp->addr;
 333         p->rgbtRed = bmp->color24.rgbtRed;
 334         p->rgbtGreen = bmp->color24.rgbtGreen;
 335         p->rgbtBlue = bmp->color24.rgbtBlue;
 336         DIB24_AdvancePosition( bmp, 1 );
 337     }
 338 }
 339
 340 void DIB32_AdvancePosition( DIBDRVBITMAP *bmp, int n )
 341 {
 342     bmp->addr = (DWORD*)bmp->addr + n;
 343 }
 344
 345 void DIB32_Copy( DIBDRVBITMAP *dst, DIBDRVBITMAP *src, int num_pixels, const DIBCONVERT *convs )
 346 {
 347     convs->ConvertToDIB32( dst, src, num_pixels );
 348 }
 349
 350 void DIB32_MoveXY( DIBDRVBITMAP *bmp, INT x, INT y )
 351 {
 352     unsigned int addr = (unsigned int)bmp->bits + y*bmp->widthbytes + x*4; /* 4 bytes per pixel */
 353     bmp->addr = (void *)addr;
 354 }
 355
 356 void DIB32_ReadColor( DIBDRVBITMAP *bmp, BYTE *r, BYTE *g, BYTE *b )
 357 {
 358     DWORD *p = bmp->addr;
 359     *r = (*p & bmp->bitfields[0]) >> bmp->bf_pos[0] << bmp->bf_shift[0];
 360     *g = (*p & bmp->bitfields[1]) >> bmp->bf_pos[1] << bmp->bf_shift[1];
 361     *b = (*p & bmp->bitfields[2]) >> bmp->bf_pos[2] << bmp->bf_shift[2];
 362     if (bmp->bf_size[0] < 8) *r |= *r >> bmp->bf_size[0];
 363     if (bmp->bf_size[1] < 8) *g |= *g >> bmp->bf_size[1];
 364     if (bmp->bf_size[2] < 8) *b |= *b >> bmp->bf_size[2];
 365 }
 366
 367 void DIB32_SelectColor( DIBDRVBITMAP *bmp, COLORREF c )
 368 {
 369     bmp->color32 = DIB32_EncodeColor( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 370 }
 371
 372 void DIB32_SetPixel( DIBDRVBITMAP *bmp, COLORREF c )
 373 {
 374     *(DWORD *)bmp->addr = DIB32_EncodeColor( bmp, GetRValue( c ), GetGValue( c ), GetBValue( c ) );
 375 }
 376
 377 void DIB32_WriteColor( DIBDRVBITMAP *bmp, int num_pixels )
 378 {
 379     int i;
 380     for (i = 0; i < num_pixels; i++)
 381     {
 382         *(DWORD *)bmp->addr = bmp->color32;
 383         DIB32_AdvancePosition( bmp, 1 );
 384     }
 385 }
 386
 387 const DIBFUNCS DIB1_funcs =
 388 {
 389     &DIB1_AdvancePosition,
 390     &DIB1_Copy,
 391     &DIB1_MoveXY,
 392     &DIB1_ReadColor,
 393     &DIB8_SelectColor,
 394     &DIB1_SetPixel,
 395     &DIB1_WriteColor
 396 };
 397
 398 const DIBFUNCS DIB4_funcs =
 399 {
 400     &DIB4_AdvancePosition,
 401     &DIB4_Copy,
 402     &DIB4_MoveXY,
 403     &DIB4_ReadColor,
 404     &DIB8_SelectColor,
 405     &DIB4_SetPixel,
 406     &DIB4_WriteColor
 407 };
 408
 409 const DIBFUNCS DIB8_funcs =
 410 {
 411     &DIB8_AdvancePosition,
 412     &DIB8_Copy,
 413     &DIB8_MoveXY,
 414     &DIB8_ReadColor,
 415     &DIB8_SelectColor,
 416     &DIB8_SetPixel,
 417     &DIB8_WriteColor
 418 };
 419
 420 const DIBFUNCS DIB16_funcs =
 421 {
 422     &DIB16_AdvancePosition,
 423     &DIB16_Copy,
 424     &DIB16_MoveXY,
 425     &DIB16_ReadColor,
 426     &DIB16_SelectColor,
 427     &DIB16_SetPixel,
 428     &DIB16_WriteColor
 429 };
 430
 431 const DIBFUNCS DIB24_funcs =
 432 {
 433     &DIB24_AdvancePosition,
 434     &DIB24_Copy,
 435     &DIB24_MoveXY,
 436     &DIB24_ReadColor,
 437     &DIB24_SelectColor,
 438     &DIB24_SetPixel,
 439     &DIB24_WriteColor
 440 };
 441
 442 const DIBFUNCS DIB32_funcs =
 443 {
 444     &DIB32_AdvancePosition,
 445     &DIB32_Copy,
 446     &DIB32_MoveXY,
 447     &DIB32_ReadColor,
 448     &DIB32_SelectColor,
 449     &DIB32_SetPixel,
 450     &DIB32_WriteColor
 451 };