?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Add missing check for empty visible rects in the non-stretching case.
[wine/multimedia.git] / dlls / gdi32 / bitblt.c
blobabd4dfc7fe94127caf687c9b75d63758ad57cb0d
1 /*
2 * GDI bit-blit operations
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
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 <limits.h>
25 #include <math.h>
26 #ifdef HAVE_FLOAT_H
27 #include <float.h>
28 #endif
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "gdi_private.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(bitblt);
37
38 static inline BOOL rop_uses_src( DWORD rop )
39 {
40 return ((rop >> 2) & 0x330000) != (rop & 0x330000);
41 }
42
43 static inline void swap_ints( int *i, int *j )
44 {
45 int tmp = *i;
46 *i = *j;
47 *j = tmp;
48 }
49
50 BOOL intersect_vis_rectangles( struct bitblt_coords *dst, struct bitblt_coords *src )
51 {
52 RECT rect;
53
54 /* intersect the rectangles */
55
56 if ((src->width == dst->width) && (src->height == dst->height)) /* no stretching */
57 {
58 offset_rect( &src->visrect, dst->x - src->x, dst->y - src->y );
59 if (!intersect_rect( &rect, &src->visrect, &dst->visrect )) return FALSE;
60 src->visrect = dst->visrect = rect;
61 offset_rect( &src->visrect, src->x - dst->x, src->y - dst->y );
62 }
63 else /* stretching */
64 {
65 /* map source rectangle into destination coordinates */
66 rect = src->visrect;
67 offset_rect( &rect, -min( src->x, src->x + src->width + 1),
68 -min( src->y, src->y + src->height + 1) );
69 rect.left = dst->x + rect.left * dst->width / abs(src->width);
70 rect.top = dst->y + rect.top * dst->height / abs(src->height);
71 rect.right = dst->x + rect.right * dst->width / abs(src->width);
72 rect.bottom = dst->y + rect.bottom * dst->height / abs(src->height);
73 if (rect.left > rect.right) swap_ints( &rect.left, &rect.right );
74 if (rect.top > rect.bottom) swap_ints( &rect.top, &rect.bottom );
75
76 /* avoid rounding errors */
77 rect.left--;
78 rect.top--;
79 rect.right++;
80 rect.bottom++;
81 if (!intersect_rect( &dst->visrect, &rect, &dst->visrect )) return FALSE;
82
83 /* map destination rectangle back to source coordinates */
84 rect = dst->visrect;
85 offset_rect( &rect, -min( dst->x, dst->x + dst->width + 1),
86 -min( dst->y, dst->y + dst->height + 1) );
87 rect.left = src->x + rect.left * src->width / abs(dst->width);
88 rect.top = src->y + rect.top * src->height / abs(dst->height);
89 rect.right = src->x + rect.right * src->width / abs(dst->width);
90 rect.bottom = src->y + rect.bottom * src->height / abs(dst->height);
91 if (rect.left > rect.right) swap_ints( &rect.left, &rect.right );
92 if (rect.top > rect.bottom) swap_ints( &rect.top, &rect.bottom );
93
94 /* avoid rounding errors */
95 rect.left--;
96 rect.top--;
97 rect.right++;
98 rect.bottom++;
99 if (!intersect_rect( &src->visrect, &rect, &src->visrect )) return FALSE;
100 }
101 return TRUE;
102 }
103
104 static BOOL get_vis_rectangles( DC *dc_dst, struct bitblt_coords *dst,
105 DC *dc_src, struct bitblt_coords *src )
106 {
107 RECT rect;
108
109 /* get the destination visible rectangle */
110
111 rect.left = dst->log_x;
112 rect.top = dst->log_y;
113 rect.right = dst->log_x + dst->log_width;
114 rect.bottom = dst->log_y + dst->log_height;
115 LPtoDP( dc_dst->hSelf, (POINT *)&rect, 2 );
116 dst->x = rect.left;
117 dst->y = rect.top;
118 dst->width = rect.right - rect.left;
119 dst->height = rect.bottom - rect.top;
120 if (dst->layout & LAYOUT_RTL && dst->layout & LAYOUT_BITMAPORIENTATIONPRESERVED)
121 {
122 dst->x += dst->width;
123 dst->width = -dst->width;
124 }
125 get_bounding_rect( &rect, dst->x, dst->y, dst->width, dst->height );
126
127 clip_visrect( dc_dst, &dst->visrect, &rect );
128
129 /* get the source visible rectangle */
130
131 if (!src) return !is_rect_empty( &dst->visrect );
132
133 rect.left = src->log_x;
134 rect.top = src->log_y;
135 rect.right = src->log_x + src->log_width;
136 rect.bottom = src->log_y + src->log_height;
137 LPtoDP( dc_src->hSelf, (POINT *)&rect, 2 );
138 src->x = rect.left;
139 src->y = rect.top;
140 src->width = rect.right - rect.left;
141 src->height = rect.bottom - rect.top;
142 if (src->layout & LAYOUT_RTL && src->layout & LAYOUT_BITMAPORIENTATIONPRESERVED)
143 {
144 src->x += src->width;
145 src->width = -src->width;
146 }
147 get_bounding_rect( &rect, src->x, src->y, src->width, src->height );
148
149 /* source is not clipped */
150 if (dc_src->header.type == OBJ_MEMDC)
151 intersect_rect( &src->visrect, &rect, &dc_src->vis_rect );
152 else
153 src->visrect = rect; /* FIXME: clip to device size */
154
155 if (is_rect_empty( &src->visrect )) return FALSE;
156 if (is_rect_empty( &dst->visrect )) return FALSE;
157
158 return intersect_vis_rectangles( dst, src );
159 }
160
161 void free_heap_bits( struct gdi_image_bits *bits )
162 {
163 HeapFree( GetProcessHeap(), 0, bits->ptr );
164 }
165
166 DWORD convert_bits( const BITMAPINFO *src_info, struct bitblt_coords *src,
167 BITMAPINFO *dst_info, struct gdi_image_bits *bits, BOOL add_alpha )
168 {
169 void *ptr;
170 DWORD err;
171
172 dst_info->bmiHeader.biWidth = src->visrect.right - src->visrect.left;
173 if (!(ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( dst_info ))))
174 return ERROR_OUTOFMEMORY;
175
176 err = convert_bitmapinfo( src_info, bits->ptr, src, dst_info, ptr, add_alpha );
177 if (bits->free) bits->free( bits );
178 bits->ptr = ptr;
179 bits->is_copy = TRUE;
180 bits->free = free_heap_bits;
181 return err;
182 }
183
184 DWORD stretch_bits( const BITMAPINFO *src_info, struct bitblt_coords *src,
185 BITMAPINFO *dst_info, struct bitblt_coords *dst,
186 struct gdi_image_bits *bits, int mode )
187 {
188 void *ptr;
189 DWORD err;
190
191 dst_info->bmiHeader.biWidth = dst->visrect.right - dst->visrect.left;
192 dst_info->bmiHeader.biHeight = dst->visrect.bottom - dst->visrect.top;
193 if (src_info->bmiHeader.biHeight < 0) dst_info->bmiHeader.biHeight = -dst_info->bmiHeader.biHeight;
194 if (!(ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( dst_info ))))
195 return ERROR_OUTOFMEMORY;
196
197 err = stretch_bitmapinfo( src_info, bits->ptr, src, dst_info, ptr, dst, mode );
198 if (bits->free) bits->free( bits );
199 bits->ptr = ptr;
200 bits->is_copy = TRUE;
201 bits->free = free_heap_bits;
202 return err;
203 }
204
205 static DWORD blend_bits( const BITMAPINFO *src_info, const struct gdi_image_bits *src_bits,
206 struct bitblt_coords *src, BITMAPINFO *dst_info,
207 struct gdi_image_bits *dst_bits, struct bitblt_coords *dst, BLENDFUNCTION blend )
208 {
209 if (!dst_bits->is_copy)
210 {
211 int size = get_dib_image_size( dst_info );
212 void *ptr = HeapAlloc( GetProcessHeap(), 0, size );
213 if (!ptr) return ERROR_OUTOFMEMORY;
214 memcpy( ptr, dst_bits->ptr, size );
215 if (dst_bits->free) dst_bits->free( dst_bits );
216 dst_bits->ptr = ptr;
217 dst_bits->is_copy = TRUE;
218 dst_bits->free = free_heap_bits;
219 }
220 return blend_bitmapinfo( src_info, src_bits->ptr, src, dst_info, dst_bits->ptr, dst, blend );
221 }
222
223 /***********************************************************************
224 * null driver fallback implementations
225 */
226
227 BOOL nulldrv_StretchBlt( PHYSDEV dst_dev, struct bitblt_coords *dst,
228 PHYSDEV src_dev, struct bitblt_coords *src, DWORD rop )
229 {
230 DC *dc_src, *dc_dst = get_nulldrv_dc( dst_dev );
231 char src_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
232 char dst_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
233 BITMAPINFO *src_info = (BITMAPINFO *)src_buffer;
234 BITMAPINFO *dst_info = (BITMAPINFO *)dst_buffer;
235 DWORD err;
236 struct gdi_image_bits bits;
237
238 if (!(dc_src = get_dc_ptr( src_dev->hdc ))) return FALSE;
239 src_dev = GET_DC_PHYSDEV( dc_src, pGetImage );
240 err = src_dev->funcs->pGetImage( src_dev, 0, src_info, &bits, src );
241 release_dc_ptr( dc_src );
242 if (err) return FALSE;
243
244 /* 1-bpp source without a color table uses the destination DC colors */
245 if (src_info->bmiHeader.biBitCount == 1 && !src_info->bmiHeader.biClrUsed)
246 {
247 COLORREF color = GetTextColor( dst_dev->hdc );
248 src_info->bmiColors[0].rgbRed = GetRValue( color );
249 src_info->bmiColors[0].rgbGreen = GetGValue( color );
250 src_info->bmiColors[0].rgbBlue = GetBValue( color );
251 src_info->bmiColors[0].rgbReserved = 0;
252 color = GetBkColor( dst_dev->hdc );
253 src_info->bmiColors[1].rgbRed = GetRValue( color );
254 src_info->bmiColors[1].rgbGreen = GetGValue( color );
255 src_info->bmiColors[1].rgbBlue = GetBValue( color );
256 src_info->bmiColors[1].rgbReserved = 0;
257 src_info->bmiHeader.biClrUsed = 2;
258 }
259
260 dst_dev = GET_DC_PHYSDEV( dc_dst, pPutImage );
261 copy_bitmapinfo( dst_info, src_info );
262 err = dst_dev->funcs->pPutImage( dst_dev, 0, 0, dst_info, &bits, src, dst, rop );
263 if (err == ERROR_BAD_FORMAT)
264 {
265 /* 1-bpp destination without a color table requires a fake 1-entry table
266 * that contains only the background color */
267 if (dst_info->bmiHeader.biBitCount == 1 && !dst_info->bmiHeader.biClrUsed)
268 {
269 COLORREF color = GetBkColor( src_dev->hdc );
270 dst_info->bmiColors[0].rgbRed = GetRValue( color );
271 dst_info->bmiColors[0].rgbGreen = GetGValue( color );
272 dst_info->bmiColors[0].rgbBlue = GetBValue( color );
273 dst_info->bmiColors[0].rgbReserved = 0;
274 dst_info->bmiHeader.biClrUsed = 1;
275 }
276
277 if (!(err = convert_bits( src_info, src, dst_info, &bits, FALSE )))
278 {
279 /* get rid of the fake 1-bpp table */
280 if (dst_info->bmiHeader.biClrUsed == 1) dst_info->bmiHeader.biClrUsed = 0;
281 err = dst_dev->funcs->pPutImage( dst_dev, 0, 0, dst_info, &bits, src, dst, rop );
282 }
283 }
284
285 if (err == ERROR_TRANSFORM_NOT_SUPPORTED &&
286 ((src->width != dst->width) || (src->height != dst->height)))
287 {
288 copy_bitmapinfo( src_info, dst_info );
289 err = stretch_bits( src_info, src, dst_info, dst, &bits, GetStretchBltMode( dst_dev->hdc ));
290 if (!err) err = dst_dev->funcs->pPutImage( dst_dev, 0, 0, dst_info, &bits, src, dst, rop );
291 }
292
293 if (bits.free) bits.free( &bits );
294 return !err;
295 }
296
297
298 BOOL nulldrv_AlphaBlend( PHYSDEV dst_dev, struct bitblt_coords *dst,
299 PHYSDEV src_dev, struct bitblt_coords *src, BLENDFUNCTION func )
300 {
301 DC *dc_src, *dc_dst = get_nulldrv_dc( dst_dev );
302 char src_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
303 char dst_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
304 BITMAPINFO *src_info = (BITMAPINFO *)src_buffer;
305 BITMAPINFO *dst_info = (BITMAPINFO *)dst_buffer;
306 DWORD err;
307 struct gdi_image_bits bits;
308
309 if (!(dc_src = get_dc_ptr( src_dev->hdc ))) return FALSE;
310 src_dev = GET_DC_PHYSDEV( dc_src, pGetImage );
311 err = src_dev->funcs->pGetImage( src_dev, 0, src_info, &bits, src );
312 release_dc_ptr( dc_src );
313 if (err) goto done;
314
315 dst_dev = GET_DC_PHYSDEV( dc_dst, pBlendImage );
316 copy_bitmapinfo( dst_info, src_info );
317 err = dst_dev->funcs->pBlendImage( dst_dev, dst_info, &bits, src, dst, func );
318 if (err == ERROR_BAD_FORMAT)
319 {
320 /* 1-bpp source without a color table uses black & white */
321 if (src_info->bmiHeader.biBitCount == 1 && !src_info->bmiHeader.biClrUsed)
322 {
323 src_info->bmiColors[0].rgbRed = 0;
324 src_info->bmiColors[0].rgbGreen = 0;
325 src_info->bmiColors[0].rgbBlue = 0;
326 src_info->bmiColors[0].rgbReserved = 0;
327 src_info->bmiColors[1].rgbRed = 0xff;
328 src_info->bmiColors[1].rgbGreen = 0xff;
329 src_info->bmiColors[1].rgbBlue = 0xff;
330 src_info->bmiColors[1].rgbReserved = 0;
331 src_info->bmiHeader.biClrUsed = 2;
332 }
333
334 err = convert_bits( src_info, src, dst_info, &bits, TRUE );
335 if (!err) err = dst_dev->funcs->pBlendImage( dst_dev, dst_info, &bits, src, dst, func );
336 }
337
338 if (err == ERROR_TRANSFORM_NOT_SUPPORTED &&
339 ((src->width != dst->width) || (src->height != dst->height)))
340 {
341 copy_bitmapinfo( src_info, dst_info );
342 err = stretch_bits( src_info, src, dst_info, dst, &bits, COLORONCOLOR );
343 if (!err) err = dst_dev->funcs->pBlendImage( dst_dev, dst_info, &bits, src, dst, func );
344 }
345
346 if (bits.free) bits.free( &bits );
347 done:
348 if (err) SetLastError( err );
349 return !err;
350 }
351
352
353 DWORD nulldrv_BlendImage( PHYSDEV dev, BITMAPINFO *info, const struct gdi_image_bits *bits,
354 struct bitblt_coords *src, struct bitblt_coords *dst, BLENDFUNCTION blend )
355 {
356 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
357 BITMAPINFO *dst_info = (BITMAPINFO *)buffer;
358 struct gdi_image_bits dst_bits;
359 struct bitblt_coords orig_dst;
360 DC *dc = get_nulldrv_dc( dev );
361 DWORD err;
362
363 if (info->bmiHeader.biPlanes != 1) goto update_format;
364 if (info->bmiHeader.biBitCount != 32) goto update_format;
365 if (info->bmiHeader.biCompression == BI_BITFIELDS)
366 {
367 DWORD *masks = (DWORD *)info->bmiColors;
368 if (masks[0] != 0xff0000 || masks[1] != 0x00ff00 || masks[2] != 0x0000ff)
369 goto update_format;
370 }
371
372 if (!bits) return ERROR_SUCCESS;
373 if ((src->width != dst->width) || (src->height != dst->height)) return ERROR_TRANSFORM_NOT_SUPPORTED;
374
375 dev = GET_DC_PHYSDEV( dc, pGetImage );
376 orig_dst = *dst;
377 err = dev->funcs->pGetImage( dev, 0, dst_info, &dst_bits, dst );
378 if (err) return err;
379
380 dev = GET_DC_PHYSDEV( dc, pPutImage );
381 err = blend_bits( info, bits, src, dst_info, &dst_bits, dst, blend );
382 if (!err) err = dev->funcs->pPutImage( dev, 0, 0, dst_info, &dst_bits, dst, &orig_dst, SRCCOPY );
383
384 if (dst_bits.free) dst_bits.free( &dst_bits );
385 return err;
386
387 update_format:
388 if (blend.AlphaFormat & AC_SRC_ALPHA) /* source alpha requires A8R8G8B8 format */
389 return ERROR_INVALID_PARAMETER;
390
391 info->bmiHeader.biPlanes = 1;
392 info->bmiHeader.biBitCount = 32;
393 info->bmiHeader.biCompression = BI_RGB;
394 info->bmiHeader.biClrUsed = 0;
395 return ERROR_BAD_FORMAT;
396 }
397
398 BOOL nulldrv_GradientFill( PHYSDEV dev, TRIVERTEX *vert_array, ULONG nvert,
399 void * grad_array, ULONG ngrad, ULONG mode )
400 {
401 DC *dc = get_nulldrv_dc( dev );
402 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
403 BITMAPINFO *info = (BITMAPINFO *)buffer;
404 struct bitblt_coords src, dst;
405 struct gdi_image_bits bits;
406 unsigned int i;
407 POINT *pts;
408 BOOL ret = TRUE;
409 DWORD err;
410 HRGN rgn;
411
412 if (!(pts = HeapAlloc( GetProcessHeap(), 0, nvert * sizeof(*pts) ))) return FALSE;
413 for (i = 0; i < nvert; i++)
414 {
415 pts[i].x = vert_array[i].x;
416 pts[i].y = vert_array[i].y;
417 }
418 LPtoDP( dev->hdc, pts, nvert );
419
420 /* compute bounding rect of all the rectangles/triangles */
421 dst.visrect.left = dst.visrect.top = INT_MAX;
422 dst.visrect.right = dst.visrect.bottom = INT_MIN;
423 for (i = 0; i < ngrad * (mode == GRADIENT_FILL_TRIANGLE ? 3 : 2); i++)
424 {
425 ULONG v = ((ULONG *)grad_array)[i];
426 dst.visrect.left = min( dst.visrect.left, pts[v].x );
427 dst.visrect.top = min( dst.visrect.top, pts[v].y );
428 dst.visrect.right = max( dst.visrect.right, pts[v].x );
429 dst.visrect.bottom = max( dst.visrect.bottom, pts[v].y );
430 }
431
432 dst.x = dst.visrect.left;
433 dst.y = dst.visrect.top;
434 dst.width = dst.visrect.right - dst.visrect.left;
435 dst.height = dst.visrect.bottom - dst.visrect.top;
436 if (!clip_visrect( dc, &dst.visrect, &dst.visrect )) goto done;
437
438 /* query the bitmap format */
439 info->bmiHeader.biSize = sizeof(info->bmiHeader);
440 info->bmiHeader.biPlanes = 1;
441 info->bmiHeader.biBitCount = 0;
442 info->bmiHeader.biCompression = BI_RGB;
443 info->bmiHeader.biXPelsPerMeter = 0;
444 info->bmiHeader.biYPelsPerMeter = 0;
445 info->bmiHeader.biClrUsed = 0;
446 info->bmiHeader.biClrImportant = 0;
447 info->bmiHeader.biWidth = dst.visrect.right - dst.visrect.left;
448 info->bmiHeader.biHeight = dst.visrect.bottom - dst.visrect.top;
449 info->bmiHeader.biSizeImage = 0;
450 dev = GET_DC_PHYSDEV( dc, pPutImage );
451 err = dev->funcs->pPutImage( dev, 0, 0, info, NULL, NULL, NULL, 0 );
452 if ((err && err != ERROR_BAD_FORMAT) ||
453 !(bits.ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, get_dib_image_size( info ))))
454 {
455 ret = FALSE;
456 goto done;
457 }
458 bits.is_copy = TRUE;
459 bits.free = free_heap_bits;
460
461 /* make src and points relative to the bitmap */
462 src = dst;
463 src.x -= dst.visrect.left;
464 src.y -= dst.visrect.top;
465 offset_rect( &src.visrect, -dst.visrect.left, -dst.visrect.top );
466 for (i = 0; i < nvert; i++)
467 {
468 pts[i].x -= dst.visrect.left;
469 pts[i].y -= dst.visrect.top;
470 }
471
472 rgn = CreateRectRgn( 0, 0, 0, 0 );
473 gradient_bitmapinfo( info, bits.ptr, vert_array, nvert, grad_array, ngrad, mode, pts, rgn );
474 OffsetRgn( rgn, dst.visrect.left, dst.visrect.top );
475 if (dev->funcs->pPutImage( dev, 0, rgn, info, &bits, &src, &dst, SRCCOPY )) ret = FALSE;
476
477 if (bits.free) bits.free( &bits );
478 DeleteObject( rgn );
479
480 done:
481 HeapFree( GetProcessHeap(), 0, pts );
482 return ret;
483 }
484
485 /***********************************************************************
486 * PatBlt (GDI32.@)
487 */
488 BOOL WINAPI PatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop)
489 {
490 DC * dc;
491 BOOL ret = FALSE;
492
493 if (rop_uses_src( rop )) return FALSE;
494 if ((dc = get_dc_ptr( hdc )))
495 {
496 struct bitblt_coords dst;
497 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pPatBlt );
498
499 update_dc( dc );
500
501 dst.log_x = left;
502 dst.log_y = top;
503 dst.log_width = width;
504 dst.log_height = height;
505 dst.layout = dc->layout;
506 if (rop & NOMIRRORBITMAP)
507 {
508 dst.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED;
509 rop &= ~NOMIRRORBITMAP;
510 }
511 ret = !get_vis_rectangles( dc, &dst, NULL, NULL );
512
513 TRACE("dst %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s rop=%06x\n",
514 hdc, dst.log_x, dst.log_y, dst.log_width, dst.log_height,
515 dst.x, dst.y, dst.width, dst.height, wine_dbgstr_rect(&dst.visrect), rop );
516
517 if (!ret) ret = physdev->funcs->pPatBlt( physdev, &dst, rop );
518
519 release_dc_ptr( dc );
520 }
521 return ret;
522 }
523
524
525 /***********************************************************************
526 * BitBlt (GDI32.@)
527 */
528 BOOL WINAPI BitBlt( HDC hdcDst, INT xDst, INT yDst, INT width,
529 INT height, HDC hdcSrc, INT xSrc, INT ySrc, DWORD rop )
530 {
531 if (!rop_uses_src( rop )) return PatBlt( hdcDst, xDst, yDst, width, height, rop );
532 else return StretchBlt( hdcDst, xDst, yDst, width, height,
533 hdcSrc, xSrc, ySrc, width, height, rop );
534 }
535
536
537 /***********************************************************************
538 * StretchBlt (GDI32.@)
539 */
540 BOOL WINAPI StretchBlt( HDC hdcDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
541 HDC hdcSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, DWORD rop )
542 {
543 BOOL ret = FALSE;
544 DC *dcDst, *dcSrc;
545
546 if (!rop_uses_src( rop )) return PatBlt( hdcDst, xDst, yDst, widthDst, heightDst, rop );
547
548 if (!(dcDst = get_dc_ptr( hdcDst ))) return FALSE;
549
550 if ((dcSrc = get_dc_ptr( hdcSrc )))
551 {
552 struct bitblt_coords src, dst;
553 PHYSDEV src_dev = GET_DC_PHYSDEV( dcSrc, pStretchBlt );
554 PHYSDEV dst_dev = GET_DC_PHYSDEV( dcDst, pStretchBlt );
555
556 update_dc( dcSrc );
557 update_dc( dcDst );
558
559 src.log_x = xSrc;
560 src.log_y = ySrc;
561 src.log_width = widthSrc;
562 src.log_height = heightSrc;
563 src.layout = dcSrc->layout;
564 dst.log_x = xDst;
565 dst.log_y = yDst;
566 dst.log_width = widthDst;
567 dst.log_height = heightDst;
568 dst.layout = dcDst->layout;
569 if (rop & NOMIRRORBITMAP)
570 {
571 src.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED;
572 dst.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED;
573 rop &= ~NOMIRRORBITMAP;
574 }
575 ret = !get_vis_rectangles( dcDst, &dst, dcSrc, &src );
576
577 TRACE("src %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s dst %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s rop=%06x\n",
578 hdcSrc, src.log_x, src.log_y, src.log_width, src.log_height,
579 src.x, src.y, src.width, src.height, wine_dbgstr_rect(&src.visrect),
580 hdcDst, dst.log_x, dst.log_y, dst.log_width, dst.log_height,
581 dst.x, dst.y, dst.width, dst.height, wine_dbgstr_rect(&dst.visrect), rop );
582
583 if (!ret) ret = dst_dev->funcs->pStretchBlt( dst_dev, &dst, src_dev, &src, rop );
584 release_dc_ptr( dcSrc );
585 }
586 release_dc_ptr( dcDst );
587 return ret;
588 }
589
590 #define FRGND_ROP3(ROP4) ((ROP4) & 0x00FFFFFF)
591 #define BKGND_ROP3(ROP4) (ROP3Table[((ROP4)>>24) & 0xFF])
592
593 /***********************************************************************
594 * MaskBlt [GDI32.@]
595 */
596 BOOL WINAPI MaskBlt(HDC hdcDest, INT nXDest, INT nYDest,
597 INT nWidth, INT nHeight, HDC hdcSrc,
598 INT nXSrc, INT nYSrc, HBITMAP hbmMask,
599 INT xMask, INT yMask, DWORD dwRop)
600 {
601 HBITMAP hBitmap1, hOldBitmap1, hBitmap2, hOldBitmap2;
602 HDC hDC1, hDC2;
603 HBRUSH hbrMask, hbrDst, hbrTmp;
604
605 static const DWORD ROP3Table[256] =
606 {
607 0x00000042, 0x00010289,
608 0x00020C89, 0x000300AA,
609 0x00040C88, 0x000500A9,
610 0x00060865, 0x000702C5,
611 0x00080F08, 0x00090245,
612 0x000A0329, 0x000B0B2A,
613 0x000C0324, 0x000D0B25,
614 0x000E08A5, 0x000F0001,
615 0x00100C85, 0x001100A6,
616 0x00120868, 0x001302C8,
617 0x00140869, 0x001502C9,
618 0x00165CCA, 0x00171D54,
619 0x00180D59, 0x00191CC8,
620 0x001A06C5, 0x001B0768,
621 0x001C06CA, 0x001D0766,
622 0x001E01A5, 0x001F0385,
623 0x00200F09, 0x00210248,
624 0x00220326, 0x00230B24,
625 0x00240D55, 0x00251CC5,
626 0x002606C8, 0x00271868,
627 0x00280369, 0x002916CA,
628 0x002A0CC9, 0x002B1D58,
629 0x002C0784, 0x002D060A,
630 0x002E064A, 0x002F0E2A,
631 0x0030032A, 0x00310B28,
632 0x00320688, 0x00330008,
633 0x003406C4, 0x00351864,
634 0x003601A8, 0x00370388,
635 0x0038078A, 0x00390604,
636 0x003A0644, 0x003B0E24,
637 0x003C004A, 0x003D18A4,
638 0x003E1B24, 0x003F00EA,
639 0x00400F0A, 0x00410249,
640 0x00420D5D, 0x00431CC4,
641 0x00440328, 0x00450B29,
642 0x004606C6, 0x0047076A,
643 0x00480368, 0x004916C5,
644 0x004A0789, 0x004B0605,
645 0x004C0CC8, 0x004D1954,
646 0x004E0645, 0x004F0E25,
647 0x00500325, 0x00510B26,
648 0x005206C9, 0x00530764,
649 0x005408A9, 0x00550009,
650 0x005601A9, 0x00570389,
651 0x00580785, 0x00590609,
652 0x005A0049, 0x005B18A9,
653 0x005C0649, 0x005D0E29,
654 0x005E1B29, 0x005F00E9,
655 0x00600365, 0x006116C6,
656 0x00620786, 0x00630608,
657 0x00640788, 0x00650606,
658 0x00660046, 0x006718A8,
659 0x006858A6, 0x00690145,
660 0x006A01E9, 0x006B178A,
661 0x006C01E8, 0x006D1785,
662 0x006E1E28, 0x006F0C65,
663 0x00700CC5, 0x00711D5C,
664 0x00720648, 0x00730E28,
665 0x00740646, 0x00750E26,
666 0x00761B28, 0x007700E6,
667 0x007801E5, 0x00791786,
668 0x007A1E29, 0x007B0C68,
669 0x007C1E24, 0x007D0C69,
670 0x007E0955, 0x007F03C9,
671 0x008003E9, 0x00810975,
672 0x00820C49, 0x00831E04,
673 0x00840C48, 0x00851E05,
674 0x008617A6, 0x008701C5,
675 0x008800C6, 0x00891B08,
676 0x008A0E06, 0x008B0666,
677 0x008C0E08, 0x008D0668,
678 0x008E1D7C, 0x008F0CE5,
679 0x00900C45, 0x00911E08,
680 0x009217A9, 0x009301C4,
681 0x009417AA, 0x009501C9,
682 0x00960169, 0x0097588A,
683 0x00981888, 0x00990066,
684 0x009A0709, 0x009B07A8,
685 0x009C0704, 0x009D07A6,
686 0x009E16E6, 0x009F0345,
687 0x00A000C9, 0x00A11B05,
688 0x00A20E09, 0x00A30669,
689 0x00A41885, 0x00A50065,
690 0x00A60706, 0x00A707A5,
691 0x00A803A9, 0x00A90189,
692 0x00AA0029, 0x00AB0889,
693 0x00AC0744, 0x00AD06E9,
694 0x00AE0B06, 0x00AF0229,
695 0x00B00E05, 0x00B10665,
696 0x00B21974, 0x00B30CE8,
697 0x00B4070A, 0x00B507A9,
698 0x00B616E9, 0x00B70348,
699 0x00B8074A, 0x00B906E6,
700 0x00BA0B09, 0x00BB0226,
701 0x00BC1CE4, 0x00BD0D7D,
702 0x00BE0269, 0x00BF08C9,
703 0x00C000CA, 0x00C11B04,
704 0x00C21884, 0x00C3006A,
705 0x00C40E04, 0x00C50664,
706 0x00C60708, 0x00C707AA,
707 0x00C803A8, 0x00C90184,
708 0x00CA0749, 0x00CB06E4,
709 0x00CC0020, 0x00CD0888,
710 0x00CE0B08, 0x00CF0224,
711 0x00D00E0A, 0x00D1066A,
712 0x00D20705, 0x00D307A4,
713 0x00D41D78, 0x00D50CE9,
714 0x00D616EA, 0x00D70349,
715 0x00D80745, 0x00D906E8,
716 0x00DA1CE9, 0x00DB0D75,
717 0x00DC0B04, 0x00DD0228,
718 0x00DE0268, 0x00DF08C8,
719 0x00E003A5, 0x00E10185,
720 0x00E20746, 0x00E306EA,
721 0x00E40748, 0x00E506E5,
722 0x00E61CE8, 0x00E70D79,
723 0x00E81D74, 0x00E95CE6,
724 0x00EA02E9, 0x00EB0849,
725 0x00EC02E8, 0x00ED0848,
726 0x00EE0086, 0x00EF0A08,
727 0x00F00021, 0x00F10885,
728 0x00F20B05, 0x00F3022A,
729 0x00F40B0A, 0x00F50225,
730 0x00F60265, 0x00F708C5,
731 0x00F802E5, 0x00F90845,
732 0x00FA0089, 0x00FB0A09,
733 0x00FC008A, 0x00FD0A0A,
734 0x00FE02A9, 0x00FF0062,
735 };
736
737 if (!hbmMask)
738 return BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop));
739
740 hbrMask = CreatePatternBrush(hbmMask);
741 hbrDst = SelectObject(hdcDest, GetStockObject(NULL_BRUSH));
742
743 /* make bitmap */
744 hDC1 = CreateCompatibleDC(hdcDest);
745 hBitmap1 = CreateCompatibleBitmap(hdcDest, nWidth, nHeight);
746 hOldBitmap1 = SelectObject(hDC1, hBitmap1);
747
748 /* draw using bkgnd rop */
749 BitBlt(hDC1, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, SRCCOPY);
750 hbrTmp = SelectObject(hDC1, hbrDst);
751 BitBlt(hDC1, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, BKGND_ROP3(dwRop));
752 SelectObject(hDC1, hbrTmp);
753
754 /* make bitmap */
755 hDC2 = CreateCompatibleDC(hdcDest);
756 hBitmap2 = CreateCompatibleBitmap(hdcDest, nWidth, nHeight);
757 hOldBitmap2 = SelectObject(hDC2, hBitmap2);
758
759 /* draw using foregnd rop */
760 BitBlt(hDC2, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, SRCCOPY);
761 hbrTmp = SelectObject(hDC2, hbrDst);
762 BitBlt(hDC2, 0, 0, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, FRGND_ROP3(dwRop));
763
764 /* combine both using the mask as a pattern brush */
765 SelectObject(hDC2, hbrMask);
766 BitBlt(hDC2, 0, 0, nWidth, nHeight, hDC1, 0, 0, 0xac0744 ); /* (D & P) | (S & ~P) */
767 SelectObject(hDC2, hbrTmp);
768
769 /* blit to dst */
770 BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hDC2, 0, 0, SRCCOPY);
771
772 /* restore all objects */
773 SelectObject(hdcDest, hbrDst);
774 SelectObject(hDC1, hOldBitmap1);
775 SelectObject(hDC2, hOldBitmap2);
776
777 /* delete all temp objects */
778 DeleteObject(hBitmap1);
779 DeleteObject(hBitmap2);
780 DeleteObject(hbrMask);
781
782 DeleteDC(hDC1);
783 DeleteDC(hDC2);
784
785 return TRUE;
786 }
787
788 /******************************************************************************
789 * GdiTransparentBlt [GDI32.@]
790 */
791 BOOL WINAPI GdiTransparentBlt( HDC hdcDest, int xDest, int yDest, int widthDest, int heightDest,
792 HDC hdcSrc, int xSrc, int ySrc, int widthSrc, int heightSrc,
793 UINT crTransparent )
794 {
795 BOOL ret = FALSE;
796 HDC hdcWork;
797 HBITMAP bmpWork;
798 HGDIOBJ oldWork;
799 HDC hdcMask = NULL;
800 HBITMAP bmpMask = NULL;
801 HBITMAP oldMask = NULL;
802 COLORREF oldBackground;
803 COLORREF oldForeground;
804 int oldStretchMode;
805
806 if(widthDest < 0 || heightDest < 0 || widthSrc < 0 || heightSrc < 0) {
807 TRACE("Cannot mirror\n");
808 return FALSE;
809 }
810
811 oldBackground = SetBkColor(hdcDest, RGB(255,255,255));
812 oldForeground = SetTextColor(hdcDest, RGB(0,0,0));
813
814 /* Stretch bitmap */
815 oldStretchMode = GetStretchBltMode(hdcSrc);
816 if(oldStretchMode == BLACKONWHITE || oldStretchMode == WHITEONBLACK)
817 SetStretchBltMode(hdcSrc, COLORONCOLOR);
818 hdcWork = CreateCompatibleDC(hdcDest);
819 bmpWork = CreateCompatibleBitmap(hdcDest, widthDest, heightDest);
820 oldWork = SelectObject(hdcWork, bmpWork);
821 if(!StretchBlt(hdcWork, 0, 0, widthDest, heightDest, hdcSrc, xSrc, ySrc, widthSrc, heightSrc, SRCCOPY)) {
822 TRACE("Failed to stretch\n");
823 goto error;
824 }
825 SetBkColor(hdcWork, crTransparent);
826
827 /* Create mask */
828 hdcMask = CreateCompatibleDC(hdcDest);
829 bmpMask = CreateCompatibleBitmap(hdcMask, widthDest, heightDest);
830 oldMask = SelectObject(hdcMask, bmpMask);
831 if(!BitBlt(hdcMask, 0, 0, widthDest, heightDest, hdcWork, 0, 0, SRCCOPY)) {
832 TRACE("Failed to create mask\n");
833 goto error;
834 }
835
836 /* Replace transparent color with black */
837 SetBkColor(hdcWork, RGB(0,0,0));
838 SetTextColor(hdcWork, RGB(255,255,255));
839 if(!BitBlt(hdcWork, 0, 0, widthDest, heightDest, hdcMask, 0, 0, SRCAND)) {
840 TRACE("Failed to mask out background\n");
841 goto error;
842 }
843
844 /* Replace non-transparent area on destination with black */
845 if(!BitBlt(hdcDest, xDest, yDest, widthDest, heightDest, hdcMask, 0, 0, SRCAND)) {
846 TRACE("Failed to clear destination area\n");
847 goto error;
848 }
849
850 /* Draw the image */
851 if(!BitBlt(hdcDest, xDest, yDest, widthDest, heightDest, hdcWork, 0, 0, SRCPAINT)) {
852 TRACE("Failed to paint image\n");
853 goto error;
854 }
855
856 ret = TRUE;
857 error:
858 SetStretchBltMode(hdcSrc, oldStretchMode);
859 SetBkColor(hdcDest, oldBackground);
860 SetTextColor(hdcDest, oldForeground);
861 if(hdcWork) {
862 SelectObject(hdcWork, oldWork);
863 DeleteDC(hdcWork);
864 }
865 if(bmpWork) DeleteObject(bmpWork);
866 if(hdcMask) {
867 SelectObject(hdcMask, oldMask);
868 DeleteDC(hdcMask);
869 }
870 if(bmpMask) DeleteObject(bmpMask);
871 return ret;
872 }
873
874 /******************************************************************************
875 * GdiAlphaBlend [GDI32.@]
876 */
877 BOOL WINAPI GdiAlphaBlend(HDC hdcDst, int xDst, int yDst, int widthDst, int heightDst,
878 HDC hdcSrc, int xSrc, int ySrc, int widthSrc, int heightSrc,
879 BLENDFUNCTION blendFunction)
880 {
881 BOOL ret = FALSE;
882 DC *dcDst, *dcSrc;
883
884 dcSrc = get_dc_ptr( hdcSrc );
885 if (!dcSrc) return FALSE;
886
887 if ((dcDst = get_dc_ptr( hdcDst )))
888 {
889 struct bitblt_coords src, dst;
890 PHYSDEV src_dev = GET_DC_PHYSDEV( dcSrc, pAlphaBlend );
891 PHYSDEV dst_dev = GET_DC_PHYSDEV( dcDst, pAlphaBlend );
892
893 update_dc( dcSrc );
894 update_dc( dcDst );
895
896 src.log_x = xSrc;
897 src.log_y = ySrc;
898 src.log_width = widthSrc;
899 src.log_height = heightSrc;
900 src.layout = GetLayout( src_dev->hdc );
901 dst.log_x = xDst;
902 dst.log_y = yDst;
903 dst.log_width = widthDst;
904 dst.log_height = heightDst;
905 dst.layout = GetLayout( dst_dev->hdc );
906 ret = !get_vis_rectangles( dcDst, &dst, dcSrc, &src );
907
908 TRACE("src %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s dst %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s blend=%02x/%02x/%02x/%02x\n",
909 hdcSrc, src.log_x, src.log_y, src.log_width, src.log_height,
910 src.x, src.y, src.width, src.height, wine_dbgstr_rect(&src.visrect),
911 hdcDst, dst.log_x, dst.log_y, dst.log_width, dst.log_height,
912 dst.x, dst.y, dst.width, dst.height, wine_dbgstr_rect(&dst.visrect),
913 blendFunction.BlendOp, blendFunction.BlendFlags,
914 blendFunction.SourceConstantAlpha, blendFunction.AlphaFormat );
915
916 if (src.x < 0 || src.y < 0 || src.width < 0 || src.height < 0 ||
917 (dcSrc->header.type == OBJ_MEMDC &&
918 (src.width > dcSrc->vis_rect.right - dcSrc->vis_rect.left - src.x ||
919 src.height > dcSrc->vis_rect.bottom - dcSrc->vis_rect.top - src.y)))
920 {
921 WARN( "Invalid src coords: (%d,%d), size %dx%d\n", src.x, src.y, src.width, src.height );
922 SetLastError( ERROR_INVALID_PARAMETER );
923 ret = FALSE;
924 }
925 else if (dst.width < 0 || dst.height < 0)
926 {
927 WARN( "Invalid dst coords: (%d,%d), size %dx%d\n", dst.x, dst.y, dst.width, dst.height );
928 SetLastError( ERROR_INVALID_PARAMETER );
929 ret = FALSE;
930 }
931 else if (dcSrc == dcDst && src.x + src.width > dst.x && src.x < dst.x + dst.width &&
932 src.y + src.height > dst.y && src.y < dst.y + dst.height)
933 {
934 WARN( "Overlapping coords: (%d,%d), %dx%d and (%d,%d), %dx%d\n",
935 src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height );
936 SetLastError( ERROR_INVALID_PARAMETER );
937 ret = FALSE;
938 }
939 else if (!ret) ret = dst_dev->funcs->pAlphaBlend( dst_dev, &dst, src_dev, &src, blendFunction );
940
941 release_dc_ptr( dcDst );
942 }
943 release_dc_ptr( dcSrc );
944 return ret;
945 }
946
947 /*********************************************************************
948 * PlgBlt [GDI32.@]
949 *
950 */
951 BOOL WINAPI PlgBlt( HDC hdcDest, const POINT *lpPoint,
952 HDC hdcSrc, INT nXSrc, INT nYSrc, INT nWidth,
953 INT nHeight, HBITMAP hbmMask, INT xMask, INT yMask)
954 {
955 int oldgMode;
956 /* parallelogram coords */
957 POINT plg[3];
958 /* rect coords */
959 POINT rect[3];
960 XFORM xf;
961 XFORM SrcXf;
962 XFORM oldDestXf;
963 double det;
964
965 /* save actual mode, set GM_ADVANCED */
966 oldgMode = SetGraphicsMode(hdcDest,GM_ADVANCED);
967 if (oldgMode == 0)
968 return FALSE;
969
970 memcpy(plg,lpPoint,sizeof(POINT)*3);
971 rect[0].x = nXSrc;
972 rect[0].y = nYSrc;
973 rect[1].x = nXSrc + nWidth;
974 rect[1].y = nYSrc;
975 rect[2].x = nXSrc;
976 rect[2].y = nYSrc + nHeight;
977 /* calc XFORM matrix to transform hdcDest -> hdcSrc (parallelogram to rectangle) */
978 /* determinant */
979 det = rect[1].x*(rect[2].y - rect[0].y) - rect[2].x*(rect[1].y - rect[0].y) - rect[0].x*(rect[2].y - rect[1].y);
980
981 if (fabs(det) < 1e-5)
982 {
983 SetGraphicsMode(hdcDest,oldgMode);
984 return FALSE;
985 }
986
987 TRACE("hdcSrc=%p %d,%d,%dx%d -> hdcDest=%p %d,%d,%d,%d,%d,%d\n",
988 hdcSrc, nXSrc, nYSrc, nWidth, nHeight, hdcDest, plg[0].x, plg[0].y, plg[1].x, plg[1].y, plg[2].x, plg[2].y);
989
990 /* X components */
991 xf.eM11 = (plg[1].x*(rect[2].y - rect[0].y) - plg[2].x*(rect[1].y - rect[0].y) - plg[0].x*(rect[2].y - rect[1].y)) / det;
992 xf.eM21 = (rect[1].x*(plg[2].x - plg[0].x) - rect[2].x*(plg[1].x - plg[0].x) - rect[0].x*(plg[2].x - plg[1].x)) / det;
993 xf.eDx = (rect[0].x*(rect[1].y*plg[2].x - rect[2].y*plg[1].x) -
994 rect[1].x*(rect[0].y*plg[2].x - rect[2].y*plg[0].x) +
995 rect[2].x*(rect[0].y*plg[1].x - rect[1].y*plg[0].x)
996 ) / det;
997
998 /* Y components */
999 xf.eM12 = (plg[1].y*(rect[2].y - rect[0].y) - plg[2].y*(rect[1].y - rect[0].y) - plg[0].y*(rect[2].y - rect[1].y)) / det;
1000 xf.eM22 = (plg[1].x*(rect[2].y - rect[0].y) - plg[2].x*(rect[1].y - rect[0].y) - plg[0].x*(rect[2].y - rect[1].y)) / det;
1001 xf.eDy = (rect[0].x*(rect[1].y*plg[2].y - rect[2].y*plg[1].y) -
1002 rect[1].x*(rect[0].y*plg[2].y - rect[2].y*plg[0].y) +
1003 rect[2].x*(rect[0].y*plg[1].y - rect[1].y*plg[0].y)
1004 ) / det;
1005
1006 GetWorldTransform(hdcSrc,&SrcXf);
1007 CombineTransform(&xf,&xf,&SrcXf);
1008
1009 /* save actual dest transform */
1010 GetWorldTransform(hdcDest,&oldDestXf);
1011
1012 SetWorldTransform(hdcDest,&xf);
1013 /* now destination and source DCs use same coords */
1014 MaskBlt(hdcDest,nXSrc,nYSrc,nWidth,nHeight,
1015 hdcSrc, nXSrc,nYSrc,
1016 hbmMask,xMask,yMask,
1017 SRCCOPY);
1018 /* restore dest DC */
1019 SetWorldTransform(hdcDest,&oldDestXf);
1020 SetGraphicsMode(hdcDest,oldgMode);
1021
1022 return TRUE;
1023 }
Maarten's multimedia branch