dlls/winedib.drv/primitives_font.c

   1 /*
   2  * DIB Engine Font 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 /*               FREETYPE FONT BITMAP BLITTING                 */
  30 void _DIBDRV_freetype_blit_8888(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
  31 {
  32     /* FIXME : MUST BE OPTIMIZED !!! */
  33
  34     DIBDRVBITMAP *dib = physDev->physBitmap;
  35     int bmpX, bmpY;
  36     BYTE *buf;
  37     int dibX, dibY;
  38     int xMin, xMax, yMin, yMax;
  39     DWORD *ptr;
  40 #ifdef DIBDRV_ANTIALIASED_FONTS
  41     DWORD c;
  42     BYTE r, g, b, negColor;
  43 #else
  44     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
  45 #endif
  46
  47     /* gets clip limits */
  48     xMin = clipRec->left;
  49     yMin = clipRec->top;
  50     xMax = clipRec->right;
  51     yMax = clipRec->bottom;
  52
  53     /* loop for every pixel in bitmap */
  54     buf = bmp->buffer;
  55     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
  56     {
  57         ptr = (DWORD *)((BYTE *)dib->bits + (dibY * dib->stride) + x * 4);
  58         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
  59         {
  60             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
  61             {
  62 #ifdef DIBDRV_ANTIALIASED_FONTS
  63                 c = physDev->textColorTable[*buf];
  64                 if(*buf < 255)
  65                 {
  66                     negColor = 255 - *buf;
  67                     r = (*ptr >> 16) & 0xff;
  68                     g = (*ptr >>  8) & 0xff;
  69                     b = *ptr         & 0xff;
  70                     c += MulDiv(r, 255 - *buf, 255) << 16 |
  71                          MulDiv(g, 255 - *buf, 255) <<  8 |
  72                          MulDiv(r, 255 - *buf, 255);
  73                 }
  74 #endif
  75                 *ptr = c;
  76             }
  77             buf++;
  78             ptr++;
  79         }
  80     }
  81 }
  82
  83 void _DIBDRV_freetype_blit_32_RGB(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
  84 {
  85     /* FIXME : MUST BE OPTIMIZED !!! */
  86
  87     DIBDRVBITMAP *dib = physDev->physBitmap;
  88     int bmpX, bmpY;
  89     BYTE *buf;
  90     int dibX, dibY;
  91     int xMin, xMax, yMin, yMax;
  92     DWORD *ptr;
  93 #ifdef DIBDRV_ANTIALIASED_FONTS
  94     DWORD c;
  95     BYTE r, g, b, negColor;
  96 #else
  97     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
  98 #endif
  99
 100     /* gets DIB limits */
 101     xMin = clipRec->left;
 102     yMin = clipRec->top;
 103     xMax = clipRec->right;
 104     yMax = clipRec->bottom;
 105
 106     /* loop for every pixel in bitmap */
 107     buf = bmp->buffer;
 108     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 109     {
 110         ptr = (DWORD *)((BYTE *)dib->bits + (dibY * dib->stride) + x * 4);
 111         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 112         {
 113             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 114             {
 115 #ifdef DIBDRV_ANTIALIASED_FONTS
 116                 c = physDev->textColorTable[*buf];
 117                 if(*buf < 255)
 118                 {
 119                     negColor = 255 - *buf;
 120                     r = (*ptr >> 16) & 0xff;
 121                     g = (*ptr >>  8) & 0xff;
 122                     b = *ptr         & 0xff;
 123                     c += MulDiv(r, 255 - *buf, 255) << 16 |
 124                          MulDiv(g, 255 - *buf, 255) <<  8 |
 125                          MulDiv(r, 255 - *buf, 255);
 126                 }
 127 #endif
 128                 *ptr = c;
 129             }
 130             buf++;
 131             ptr++;
 132         }
 133     }
 134 }
 135
 136 void _DIBDRV_freetype_blit_32_BITFIELDS(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 137 {
 138     /* FIXME : MUST BE OPTIMIZED !!! */
 139
 140     DIBDRVBITMAP *dib = physDev->physBitmap;
 141     int bmpX, bmpY;
 142     BYTE *buf;
 143     int dibX, dibY;
 144     int xMin, xMax, yMin, yMax;
 145 #ifdef DIBDRV_ANTIALIASED_FONTS
 146     DWORD c;
 147     COLORREF pix;
 148     BYTE r, g, b, negColor;
 149 #else
 150     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
 151 #endif
 152
 153     /* gets DIB limits */
 154     xMin = clipRec->left;
 155     yMin = clipRec->top;
 156     xMax = clipRec->right;
 157     yMax = clipRec->bottom;
 158
 159     /* loop for every pixel in bitmap */
 160     buf = bmp->buffer;
 161     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 162     {
 163         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 164         {
 165             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 166             {
 167 #ifdef DIBDRV_ANTIALIASED_FONTS
 168                 c = physDev->textColorTable[*buf];
 169                 if(*buf < 255)
 170                 {
 171                     negColor = 255 - *buf;
 172                     pix = dib->funcs->GetPixel(dib, dibX, dibY);
 173                     r = pix         & 0xff;
 174                     g = (pix >>  8) & 0xff;
 175                     b = (pix >> 16) & 0xff;
 176                     c += MulDiv(r, 255 - *buf, 255) << 16 |
 177                          MulDiv(g, 255 - *buf, 255) <<  8 |
 178                          MulDiv(r, 255 - *buf, 255);
 179                 }
 180 #endif
 181                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 182             }
 183             buf++;
 184         }
 185     }
 186 }
 187
 188 void _DIBDRV_freetype_blit_24(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 189 {
 190     /* FIXME : MUST BE OPTIMIZED !!! */
 191
 192     DIBDRVBITMAP *dib = physDev->physBitmap;
 193     int bmpX, bmpY;
 194     BYTE *buf;
 195     int dibX, dibY;
 196     int xMin, xMax, yMin, yMax;
 197 #ifdef DIBDRV_ANTIALIASED_FONTS
 198     DWORD c;
 199     COLORREF pix;
 200     BYTE r, g, b, negColor;
 201 #else
 202     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
 203 #endif
 204
 205     /* gets DIB limits */
 206     xMin = clipRec->left;
 207     yMin = clipRec->top;
 208     xMax = clipRec->right;
 209     yMax = clipRec->bottom;
 210
 211     /* loop for every pixel in bitmap */
 212     buf = bmp->buffer;
 213     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 214     {
 215         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 216         {
 217             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 218             {
 219 #ifdef DIBDRV_ANTIALIASED_FONTS
 220                 c = physDev->textColorTable[*buf];
 221                 if(*buf < 255)
 222                 {
 223                     negColor = 255 - *buf;
 224                     pix = dib->funcs->GetPixel(dib, dibX, dibY);
 225                     r = pix         & 0xff;
 226                     g = (pix >>  8) & 0xff;
 227                     b = (pix >> 16) & 0xff;
 228                     c += MulDiv(r, 255 - *buf, 255) << 16 |
 229                          MulDiv(g, 255 - *buf, 255) <<  8 |
 230                          MulDiv(r, 255 - *buf, 255);
 231                 }
 232 #endif
 233                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 234             }
 235             buf++;
 236         }
 237     }
 238 }
 239
 240 void _DIBDRV_freetype_blit_16_RGB(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 241 {
 242     /* FIXME : MUST BE OPTIMIZED !!! */
 243
 244     DIBDRVBITMAP *dib = physDev->physBitmap;
 245     int bmpX, bmpY;
 246     BYTE *buf;
 247     int dibX, dibY;
 248     int xMin, xMax, yMin, yMax;
 249 #ifdef DIBDRV_ANTIALIASED_FONTS
 250     DWORD c;
 251     COLORREF pix;
 252     BYTE r, g, b, negColor;
 253 #else
 254     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
 255 #endif
 256
 257     /* gets DIB limits */
 258     xMin = clipRec->left;
 259     yMin = clipRec->top;
 260     xMax = clipRec->right;
 261     yMax = clipRec->bottom;
 262
 263     /* loop for every pixel in bitmap */
 264     buf = bmp->buffer;
 265     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 266     {
 267         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 268         {
 269             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 270             {
 271 #ifdef DIBDRV_ANTIALIASED_FONTS
 272                 c = physDev->textColorTable[*buf];
 273                 if(*buf < 255)
 274                 {
 275                     negColor = 255 - *buf;
 276                     pix = dib->funcs->GetPixel(dib, dibX, dibY);
 277                     r = pix         & 0xff;
 278                     g = (pix >>  8) & 0xff;
 279                     b = (pix >> 16) & 0xff;
 280                     c += MulDiv(r, 255 - *buf, 255) << 16 |
 281                          MulDiv(g, 255 - *buf, 255) <<  8 |
 282                          MulDiv(r, 255 - *buf, 255);
 283                 }
 284 #endif
 285                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 286             }
 287             buf++;
 288         }
 289     }
 290 }
 291
 292 void _DIBDRV_freetype_blit_16_BITFIELDS(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 293 {
 294     /* FIXME : MUST BE OPTIMIZED !!! */
 295
 296     DIBDRVBITMAP *dib = physDev->physBitmap;
 297     int bmpX, bmpY;
 298     BYTE *buf;
 299     int dibX, dibY;
 300     int xMin, xMax, yMin, yMax;
 301 #ifdef DIBDRV_ANTIALIASED_FONTS
 302     DWORD c;
 303     COLORREF pix;
 304     BYTE r, g, b, negColor;
 305 #else
 306     DWORD c = dib->funcs->ColorToPixel(dib, physDev->textColor);
 307 #endif
 308
 309     /* gets DIB limits */
 310     xMin = clipRec->left;
 311     yMin = clipRec->top;
 312     xMax = clipRec->right;
 313     yMax = clipRec->bottom;
 314
 315     /* loop for every pixel in bitmap */
 316     buf = bmp->buffer;
 317     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 318     {
 319         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 320         {
 321             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 322             {
 323 #ifdef DIBDRV_ANTIALIASED_FONTS
 324                 c = physDev->textColorTable[*buf];
 325                 if(*buf < 255)
 326                 {
 327                     negColor = 255 - *buf;
 328                     pix = dib->funcs->GetPixel(dib, dibX, dibY);
 329                     r = pix         & 0xff;
 330                     g = (pix >>  8) & 0xff;
 331                     b = (pix >> 16) & 0xff;
 332                     c += MulDiv(r, 255 - *buf, 255) << 16 |
 333                          MulDiv(g, 255 - *buf, 255) <<  8 |
 334                          MulDiv(r, 255 - *buf, 255);
 335                 }
 336 #endif
 337                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 338             }
 339             buf++;
 340         }
 341     }
 342 }
 343
 344 void _DIBDRV_freetype_blit_8(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 345 {
 346     /* FIXME : MUST BE OPTIMIZED !!! */
 347
 348     DIBDRVBITMAP *dib = physDev->physBitmap;
 349     int bmpX, bmpY;
 350     BYTE *buf;
 351     int dibX, dibY;
 352     int xMin, xMax, yMin, yMax;
 353     DWORD c = physDev->textColor;
 354
 355     /* gets DIB limits */
 356     xMin = clipRec->left;
 357     yMin = clipRec->top;
 358     xMax = clipRec->right;
 359     yMax = clipRec->bottom;
 360
 361     /* loop for every pixel in bitmap */
 362     buf = bmp->buffer;
 363     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 364     {
 365         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 366         {
 367             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 368                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 369             buf++;
 370         }
 371     }
 372 }
 373
 374 void _DIBDRV_freetype_blit_4(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 375 {
 376     /* FIXME : MUST BE OPTIMIZED !!! */
 377
 378     DIBDRVBITMAP *dib = physDev->physBitmap;
 379     int bmpX, bmpY;
 380     BYTE *buf;
 381     int dibX, dibY;
 382     int xMin, xMax, yMin, yMax;
 383     DWORD c = physDev->textColor;
 384
 385     /* gets DIB limits */
 386     xMin = clipRec->left;
 387     yMin = clipRec->top;
 388     xMax = clipRec->right;
 389     yMax = clipRec->bottom;
 390
 391     /* loop for every pixel in bitmap */
 392     buf = bmp->buffer;
 393     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 394     {
 395         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 396         {
 397             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 398                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 399             buf++;
 400         }
 401     }
 402 }
 403
 404 void _DIBDRV_freetype_blit_1(DIBDRVPHYSDEV *physDev, int x, int y, RECT *clipRec, FT_Bitmap *bmp)
 405 {
 406     /* FIXME : MUST BE OPTIMIZED !!! */
 407
 408     DIBDRVBITMAP *dib = physDev->physBitmap;
 409     int bmpX, bmpY;
 410     BYTE *buf;
 411     int dibX, dibY;
 412     int xMin, xMax, yMin, yMax;
 413     DWORD c = physDev->textColor;
 414
 415     /* gets DIB limits */
 416     xMin = clipRec->left;
 417     yMin = clipRec->top;
 418     xMax = clipRec->right;
 419     yMax = clipRec->bottom;
 420
 421     /* loop for every pixel in bitmap */
 422     buf = bmp->buffer;
 423     for(bmpY = 0, dibY = y; bmpY < bmp->rows; bmpY++, dibY++)
 424     {
 425         for(bmpX = 0, dibX = x; bmpX < bmp->width; bmpX++, dibX++)
 426         {
 427             if(dibX < xMax && dibY < yMax && dibX >= xMin && dibY >= yMin && *buf)
 428                 dib->funcs->SetPixel(dib, dibX, dibY, 0, c);
 429             buf++;
 430         }
 431     }
 432 }