dlls/wineps.drv/bitmap.c

   1 /*
   2  *      PostScript driver bitmap functions
   3  *
   4  * Copyright 1998  Huw D M 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 <assert.h>
  22 #include <stdlib.h>
  23
  24 #include "psdrv.h"
  25 #include "winbase.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  29
  30
  31 /* Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. */
  32 static inline int get_dib_width_bytes( int width, int depth )
  33 {
  34     int words;
  35
  36     switch(depth)
  37     {
  38     case 1:  words = (width + 31) / 32; break;
  39     case 4:  words = (width + 7) / 8; break;
  40     case 8:  words = (width + 3) / 4; break;
  41     case 15:
  42     case 16: words = (width + 1) / 2; break;
  43     case 24: words = (width * 3 + 3)/4; break;
  44     default:
  45         WARN("(%d): Unsupported depth\n", depth );
  46         /* fall through */
  47     case 32: words = width; break;
  48     }
  49     return 4 * words;
  50 }
  51
  52 /* get the bitmap info from either an INFOHEADER or COREHEADER bitmap */
  53 static BOOL get_bitmap_info( const void *ptr, LONG *width, LONG *height, WORD *bpp, WORD *compr )
  54 {
  55     const BITMAPINFOHEADER *header = ptr;
  56
  57     switch(header->biSize)
  58     {
  59     case sizeof(BITMAPCOREHEADER):
  60         {
  61             const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
  62             *width  = core->bcWidth;
  63             *height = core->bcHeight;
  64             *bpp    = core->bcBitCount;
  65             *compr  = 0;
  66         }
  67         return TRUE;
  68     case sizeof(BITMAPINFOHEADER):
  69     case sizeof(BITMAPV4HEADER):
  70     case sizeof(BITMAPV5HEADER):
  71         /* V4 and V5 structures are a superset of the INFOHEADER structure */
  72         *width  = header->biWidth;
  73         *height = header->biHeight;
  74         *bpp    = header->biBitCount;
  75         *compr  = header->biCompression;
  76         return TRUE;
  77     default:
  78         ERR("(%d): unknown/wrong size for header\n", header->biSize );
  79         return FALSE;
  80     }
  81 }
  82
  83
  84 /***************************************************************************
  85  *                PSDRV_WriteImageHeader
  86  *
  87  * Helper for PSDRV_StretchDIBits
  88  *
  89  * BUGS
  90  *  Uses level 2 PostScript
  91  */
  92
  93 static BOOL PSDRV_WriteImageHeader(PSDRV_PDEVICE *physDev, const BITMAPINFO *info, INT xDst,
  94                                    INT yDst, INT widthDst, INT heightDst,
  95                                    INT widthSrc, INT heightSrc)
  96 {
  97     COLORREF map[256];
  98     int i;
  99
 100     switch(info->bmiHeader.biBitCount) {
 101     case 8:
 102         PSDRV_WriteIndexColorSpaceBegin(physDev, 255);
 103         for(i = 0; i < 256; i++) {
 104             map[i] =  info->bmiColors[i].rgbRed |
 105               info->bmiColors[i].rgbGreen << 8 |
 106               info->bmiColors[i].rgbBlue << 16;
 107         }
 108         PSDRV_WriteRGB(physDev, map, 256);
 109         PSDRV_WriteIndexColorSpaceEnd(physDev);
 110         break;
 111
 112     case 4:
 113         PSDRV_WriteIndexColorSpaceBegin(physDev, 15);
 114         for(i = 0; i < 16; i++) {
 115             map[i] =  info->bmiColors[i].rgbRed |
 116               info->bmiColors[i].rgbGreen << 8 |
 117               info->bmiColors[i].rgbBlue << 16;
 118         }
 119         PSDRV_WriteRGB(physDev, map, 16);
 120         PSDRV_WriteIndexColorSpaceEnd(physDev);
 121         break;
 122
 123     case 1:
 124         PSDRV_WriteIndexColorSpaceBegin(physDev, 1);
 125         for(i = 0; i < 2; i++) {
 126             map[i] =  info->bmiColors[i].rgbRed |
 127               info->bmiColors[i].rgbGreen << 8 |
 128               info->bmiColors[i].rgbBlue << 16;
 129         }
 130         PSDRV_WriteRGB(physDev, map, 2);
 131         PSDRV_WriteIndexColorSpaceEnd(physDev);
 132         break;
 133
 134     case 15:
 135     case 16:
 136     case 24:
 137     case 32:
 138       {
 139         PSCOLOR pscol;
 140         pscol.type = PSCOLOR_RGB;
 141         pscol.value.rgb.r = pscol.value.rgb.g = pscol.value.rgb.b = 0.0;
 142         PSDRV_WriteSetColor(physDev, &pscol);
 143         break;
 144       }
 145
 146     default:
 147         FIXME("Not implemented yet\n");
 148         return FALSE;
 149     }
 150
 151     PSDRV_WriteImage(physDev, info->bmiHeader.biBitCount, xDst, yDst,
 152                      widthDst, heightDst, widthSrc, heightSrc, FALSE);
 153     return TRUE;
 154 }
 155
 156
 157 /***************************************************************************
 158  *                PSDRV_WriteImageMaskHeader
 159  *
 160  * Helper for PSDRV_StretchDIBits
 161  *
 162  * We use the imagemask operator for 1bpp bitmaps since the output
 163  * takes much less time for the printer to render.
 164  *
 165  * BUGS
 166  *  Uses level 2 PostScript
 167  */
 168
 169 static BOOL PSDRV_WriteImageMaskHeader(PSDRV_PDEVICE *physDev, const BITMAPINFO *info, INT xDst,
 170                                        INT yDst, INT widthDst, INT heightDst,
 171                                        INT widthSrc, INT heightSrc)
 172 {
 173     COLORREF map[2];
 174     PSCOLOR bkgnd, foregnd;
 175     int i;
 176
 177     assert(info->bmiHeader.biBitCount == 1);
 178
 179     for(i = 0; i < 2; i++) {
 180         map[i] =  info->bmiColors[i].rgbRed |
 181             info->bmiColors[i].rgbGreen << 8 |
 182             info->bmiColors[i].rgbBlue << 16;
 183     }
 184
 185     /* We'll write the mask with -ve polarity so that
 186        the foregnd color corresponds to a bit equal to
 187        0 in the bitmap.
 188     */
 189     PSDRV_CreateColor(physDev, &foregnd, map[0]);
 190     PSDRV_CreateColor(physDev, &bkgnd, map[1]);
 191
 192     PSDRV_WriteGSave(physDev);
 193     PSDRV_WriteNewPath(physDev);
 194     PSDRV_WriteRectangle(physDev, xDst, yDst, widthDst, heightDst);
 195     PSDRV_WriteSetColor(physDev, &bkgnd);
 196     PSDRV_WriteFill(physDev);
 197     PSDRV_WriteGRestore(physDev);
 198
 199     PSDRV_WriteSetColor(physDev, &foregnd);
 200     PSDRV_WriteImage(physDev, 1, xDst, yDst, widthDst, heightDst,
 201                      widthSrc, heightSrc, TRUE);
 202
 203     return TRUE;
 204 }
 205
 206 static inline DWORD max_rle_size(DWORD size)
 207 {
 208     return size + (size + 127) / 128 + 1;
 209 }
 210
 211 static inline DWORD max_ascii85_size(DWORD size)
 212 {
 213     return (size + 3) / 4 * 5;
 214 }
 215
 216 /***************************************************************************
 217  *
 218  *      PSDRV_StretchDIBits
 219  *
 220  * BUGS
 221  *  Doesn't work correctly if xSrc isn't byte aligned - this affects 1 and 4
 222  *  bit depths.
 223  *  Compression not implemented.
 224  */
 225 INT CDECL PSDRV_StretchDIBits( PSDRV_PDEVICE *physDev, INT xDst, INT yDst, INT widthDst,
 226                                INT heightDst, INT xSrc, INT ySrc,
 227                                INT widthSrc, INT heightSrc, const void *bits,
 228                                const BITMAPINFO *info, UINT wUsage, DWORD dwRop )
 229 {
 230     LONG fullSrcWidth, fullSrcHeight;
 231     INT stride;
 232     WORD bpp, compression;
 233     INT line;
 234     POINT pt[2];
 235     const BYTE *src_ptr;
 236     BYTE *dst_ptr, *bitmap, *rle, *ascii85;
 237     DWORD rle_len, ascii85_len, bitmap_size;
 238
 239     TRACE("%p (%d,%d %dx%d) -> (%d,%d %dx%d)\n", physDev->hdc,
 240           xSrc, ySrc, widthSrc, heightSrc, xDst, yDst, widthDst, heightDst);
 241
 242     if (!get_bitmap_info( info, &fullSrcWidth, &fullSrcHeight, &bpp, &compression )) return FALSE;
 243
 244     stride = get_dib_width_bytes(fullSrcWidth, bpp);
 245     if(fullSrcHeight < 0) stride = -stride; /* top-down */
 246
 247     TRACE("full size=%dx%d bpp=%d compression=%d rop=%08x\n", fullSrcWidth,
 248           fullSrcHeight, bpp, compression, dwRop);
 249
 250
 251     if(compression != BI_RGB) {
 252         FIXME("Compression not supported\n");
 253         return FALSE;
 254     }
 255
 256     pt[0].x = xDst;
 257     pt[0].y = yDst;
 258     pt[1].x = xDst + widthDst;
 259     pt[1].y = yDst + heightDst;
 260     LPtoDP( physDev->hdc, pt, 2 );
 261     xDst = pt[0].x;
 262     yDst = pt[0].y;
 263     widthDst = pt[1].x - pt[0].x;
 264     heightDst = pt[1].y - pt[0].y;
 265
 266     switch(bpp) {
 267
 268     case 1:
 269         PSDRV_SetClip(physDev);
 270         PSDRV_WriteGSave(physDev);
 271
 272         /* Use imagemask rather than image */
 273         PSDRV_WriteImageMaskHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 274                                    widthSrc, heightSrc);
 275         src_ptr = bits;
 276         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 277         src_ptr += (ySrc * stride);
 278         if(xSrc & 7)
 279             FIXME("This won't work...\n");
 280         bitmap_size = heightSrc * ((widthSrc + 7) / 8);
 281         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 282         for(line = 0; line < heightSrc; line++, src_ptr += stride, dst_ptr += ((widthSrc + 7) / 8))
 283             memcpy(dst_ptr, src_ptr + xSrc / 8, (widthSrc + 7) / 8);
 284         break;
 285
 286     case 4:
 287         PSDRV_SetClip(physDev);
 288         PSDRV_WriteGSave(physDev);
 289         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 290                                widthSrc, heightSrc);
 291         src_ptr = bits;
 292         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 293         src_ptr += (ySrc * stride);
 294         if(xSrc & 1)
 295             FIXME("This won't work...\n");
 296         bitmap_size = heightSrc * ((widthSrc + 1) / 2);
 297         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 298         for(line = 0; line < heightSrc; line++, src_ptr += stride, dst_ptr += ((widthSrc + 1) / 2))
 299             memcpy(dst_ptr, src_ptr + xSrc/2, (widthSrc+1)/2);
 300         break;
 301
 302     case 8:
 303         PSDRV_SetClip(physDev);
 304         PSDRV_WriteGSave(physDev);
 305         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 306                                widthSrc, heightSrc);
 307         src_ptr = bits;
 308         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 309         src_ptr += (ySrc * stride);
 310         bitmap_size = heightSrc * widthSrc;
 311         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 312         for(line = 0; line < heightSrc; line++, src_ptr += stride, dst_ptr += widthSrc)
 313             memcpy(dst_ptr, src_ptr + xSrc, widthSrc);
 314         break;
 315
 316     case 15:
 317     case 16:
 318         PSDRV_SetClip(physDev);
 319         PSDRV_WriteGSave(physDev);
 320         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 321                                widthSrc, heightSrc);
 322
 323
 324         src_ptr = bits;
 325         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 326         src_ptr += (ySrc * stride);
 327         bitmap_size = heightSrc * widthSrc * 3;
 328         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 329
 330         for(line = 0; line < heightSrc; line++, src_ptr += stride) {
 331             const WORD *words = (const WORD *)src_ptr + xSrc;
 332             int i;
 333             for(i = 0; i < widthSrc; i++) {
 334                 BYTE r, g, b;
 335
 336                 /* We want 0x0 -- 0x1f to map to 0x0 -- 0xff */
 337                 r = words[i] >> 10 & 0x1f;
 338                 r = r << 3 | r >> 2;
 339                 g = words[i] >> 5 & 0x1f;
 340                 g = g << 3 | g >> 2;
 341                 b = words[i] & 0x1f;
 342                 b = b << 3 | b >> 2;
 343                 dst_ptr[0] = r;
 344                 dst_ptr[1] = g;
 345                 dst_ptr[2] = b;
 346                 dst_ptr += 3;
 347             }
 348         }
 349         break;
 350
 351     case 24:
 352         PSDRV_SetClip(physDev);
 353         PSDRV_WriteGSave(physDev);
 354         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 355                                widthSrc, heightSrc);
 356
 357         src_ptr = bits;
 358         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 359         src_ptr += (ySrc * stride);
 360         bitmap_size = heightSrc * widthSrc * 3;
 361         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 362         for(line = 0; line < heightSrc; line++, src_ptr += stride) {
 363             const BYTE *byte = src_ptr + xSrc * 3;
 364             int i;
 365             for(i = 0; i < widthSrc; i++) {
 366                 dst_ptr[0] = byte[i * 3 + 2];
 367                 dst_ptr[1] = byte[i * 3 + 1];
 368                 dst_ptr[2] = byte[i * 3];
 369                 dst_ptr += 3;
 370             }
 371         }
 372         break;
 373
 374     case 32:
 375         PSDRV_SetClip(physDev);
 376         PSDRV_WriteGSave(physDev);
 377         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
 378                                widthSrc, heightSrc);
 379
 380         src_ptr = bits;
 381         if(stride < 0) src_ptr += (fullSrcHeight + 1) * stride;
 382         src_ptr += (ySrc * stride);
 383         bitmap_size = heightSrc * widthSrc * 3;
 384         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
 385         for(line = 0; line < heightSrc; line++, src_ptr += stride) {
 386             const BYTE *byte = src_ptr + xSrc * 4;
 387             int i;
 388             for(i = 0; i < widthSrc; i++) {
 389                 dst_ptr[0] = byte[i * 4 + 2];
 390                 dst_ptr[1] = byte[i * 4 + 1];
 391                 dst_ptr[2] = byte[i * 4];
 392                 dst_ptr += 3;
 393             }
 394         }
 395         break;
 396
 397     default:
 398         FIXME("Unsupported depth\n");
 399         return FALSE;
 400
 401     }
 402
 403     rle = HeapAlloc(GetProcessHeap(), 0, max_rle_size(bitmap_size));
 404     rle_len = RLE_encode(bitmap, bitmap_size, rle);
 405     HeapFree(GetProcessHeap(), 0, bitmap);
 406     ascii85 = HeapAlloc(GetProcessHeap(), 0, max_ascii85_size(rle_len));
 407     ascii85_len = ASCII85_encode(rle, rle_len, ascii85);
 408     HeapFree(GetProcessHeap(), 0, rle);
 409     PSDRV_WriteData(physDev, ascii85, ascii85_len);
 410     HeapFree(GetProcessHeap(), 0, ascii85);
 411     PSDRV_WriteSpool(physDev, "~>\n", 3);
 412     PSDRV_WriteGRestore(physDev);
 413     PSDRV_ResetClip(physDev);
 414     return abs(heightSrc);
 415 }