ntdll: Remove unneeded casts.
[wine] / 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 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 widthbytes;
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     widthbytes = get_dib_width_bytes(fullSrcWidth, bpp);
245
246     TRACE("full size=%dx%d bpp=%d compression=%d rop=%08x\n", fullSrcWidth,
247           fullSrcHeight, bpp, compression, dwRop);
248
249
250     if(compression != BI_RGB) {
251         FIXME("Compression not supported\n");
252         return FALSE;
253     }
254
255     pt[0].x = xDst;
256     pt[0].y = yDst;
257     pt[1].x = xDst + widthDst;
258     pt[1].y = yDst + heightDst;
259     LPtoDP( physDev->hdc, pt, 2 );
260     xDst = pt[0].x;
261     yDst = pt[0].y;
262     widthDst = pt[1].x - pt[0].x;
263     heightDst = pt[1].y - pt[0].y;
264
265     switch(bpp) {
266
267     case 1:
268         PSDRV_SetClip(physDev);
269         PSDRV_WriteGSave(physDev);
270
271         /* Use imagemask rather than image */
272         PSDRV_WriteImageMaskHeader(physDev, info, xDst, yDst, widthDst, heightDst,
273                                    widthSrc, heightSrc);
274         src_ptr = bits;
275         src_ptr += (ySrc * widthbytes);
276         if(xSrc & 7)
277             FIXME("This won't work...\n");
278         bitmap_size = heightSrc * ((widthSrc + 7) / 8);
279         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
280         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes, dst_ptr += ((widthSrc + 7) / 8))
281             memcpy(dst_ptr, src_ptr + xSrc / 8, (widthSrc + 7) / 8);
282         break;
283
284     case 4:
285         PSDRV_SetClip(physDev);
286         PSDRV_WriteGSave(physDev);
287         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
288                                widthSrc, heightSrc);
289         src_ptr = bits;
290         src_ptr += (ySrc * widthbytes);
291         if(xSrc & 1)
292             FIXME("This won't work...\n");
293         bitmap_size = heightSrc * ((widthSrc + 1) / 2);
294         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
295         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes, dst_ptr += ((widthSrc + 1) / 2))
296             memcpy(dst_ptr, src_ptr + xSrc/2, (widthSrc+1)/2);
297         break;
298
299     case 8:
300         PSDRV_SetClip(physDev);
301         PSDRV_WriteGSave(physDev);
302         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
303                                widthSrc, heightSrc);
304         src_ptr = bits;
305         src_ptr += (ySrc * widthbytes);
306         bitmap_size = heightSrc * widthSrc;
307         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
308         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes, dst_ptr += widthSrc)
309             memcpy(dst_ptr, src_ptr + xSrc, widthSrc);
310         break;
311
312     case 15:
313     case 16:
314         PSDRV_SetClip(physDev);
315         PSDRV_WriteGSave(physDev);
316         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
317                                widthSrc, heightSrc);
318
319
320         src_ptr = bits;
321         src_ptr += (ySrc * widthbytes);
322         bitmap_size = heightSrc * widthSrc * 3;
323         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
324         
325         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes) {
326             const WORD *words = (const WORD *)src_ptr + xSrc;
327             int i;
328             for(i = 0; i < widthSrc; i++) {
329                 BYTE r, g, b;
330
331                 /* We want 0x0 -- 0x1f to map to 0x0 -- 0xff */
332                 r = words[i] >> 10 & 0x1f;
333                 r = r << 3 | r >> 2;
334                 g = words[i] >> 5 & 0x1f;
335                 g = g << 3 | g >> 2;
336                 b = words[i] & 0x1f;
337                 b = b << 3 | b >> 2;
338                 dst_ptr[0] = r;
339                 dst_ptr[1] = g;
340                 dst_ptr[2] = b;
341                 dst_ptr += 3;
342             }
343         }
344         break;
345
346     case 24:
347         PSDRV_SetClip(physDev);
348         PSDRV_WriteGSave(physDev);
349         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
350                                widthSrc, heightSrc);
351
352         src_ptr = bits;
353         src_ptr += (ySrc * widthbytes);
354         bitmap_size = heightSrc * widthSrc * 3;
355         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
356         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes) {
357             const BYTE *byte = src_ptr + xSrc * 3;
358             int i;
359             for(i = 0; i < widthSrc; i++) {
360                 dst_ptr[0] = byte[i * 3 + 2];
361                 dst_ptr[1] = byte[i * 3 + 1];
362                 dst_ptr[2] = byte[i * 3];
363                 dst_ptr += 3;
364             }
365         }
366         break;
367
368     case 32:
369         PSDRV_SetClip(physDev);
370         PSDRV_WriteGSave(physDev);
371         PSDRV_WriteImageHeader(physDev, info, xDst, yDst, widthDst, heightDst,
372                                widthSrc, heightSrc);
373
374         src_ptr = bits;
375         src_ptr += (ySrc * widthbytes);
376         bitmap_size = heightSrc * widthSrc * 3;
377         dst_ptr = bitmap = HeapAlloc(GetProcessHeap(), 0, bitmap_size);
378         for(line = 0; line < heightSrc; line++, src_ptr += widthbytes) {
379             const BYTE *byte = src_ptr + xSrc * 4;
380             int i;
381             for(i = 0; i < widthSrc; i++) {
382                 dst_ptr[0] = byte[i * 4 + 2];
383                 dst_ptr[1] = byte[i * 4 + 1];
384                 dst_ptr[2] = byte[i * 4];
385                 dst_ptr += 3;
386             }
387         }
388         break;
389
390     default:
391         FIXME("Unsupported depth\n");
392         return FALSE;
393
394     }
395
396     rle = HeapAlloc(GetProcessHeap(), 0, max_rle_size(bitmap_size));
397     rle_len = RLE_encode(bitmap, bitmap_size, rle);
398     HeapFree(GetProcessHeap(), 0, bitmap);
399     ascii85 = HeapAlloc(GetProcessHeap(), 0, max_ascii85_size(rle_len));
400     ascii85_len = ASCII85_encode(rle, rle_len, ascii85);
401     HeapFree(GetProcessHeap(), 0, rle);
402     PSDRV_WriteData(physDev, ascii85, ascii85_len);
403     HeapFree(GetProcessHeap(), 0, ascii85);
404     PSDRV_WriteSpool(physDev, "~>\n", 3);
405     PSDRV_WriteGRestore(physDev);
406     PSDRV_ResetClip(physDev);
407     return abs(heightSrc);
408 }