came across small potential kmode crash while researching another bug fix
[reactos.git] / reactos / subsys / win32k / eng / bitblt.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id: bitblt.c,v 1.62 2004/12/14 03:23:14 royce Exp $
20 *
21 * COPYRIGHT: See COPYING in the top level directory
22 * PROJECT: ReactOS kernel
23 * PURPOSE: GDI BitBlt Functions
24 * FILE: subsys/win32k/eng/bitblt.c
25 * PROGRAMER: Jason Filby
26 * REVISION HISTORY:
27 * 2/10/1999: Created
28 */
29 #include <w32k.h>
30
31 typedef BOOLEAN STDCALL (*PBLTRECTFUNC)(SURFOBJ* OutputObj,
32 SURFOBJ* InputObj,
33 SURFOBJ* Mask,
34 XLATEOBJ* ColorTranslation,
35 RECTL* OutputRect,
36 POINTL* InputPoint,
37 POINTL* MaskOrigin,
38 BRUSHOBJ* Brush,
39 POINTL* BrushOrigin,
40 ROP4 Rop4);
41 typedef BOOLEAN STDCALL (*PSTRETCHRECTFUNC)(SURFOBJ* OutputObj,
42 SURFOBJ* InputObj,
43 SURFOBJ* Mask,
44 CLIPOBJ* ClipRegion,
45 XLATEOBJ* ColorTranslation,
46 RECTL* OutputRect,
47 RECTL* InputRect,
48 POINTL* MaskOrigin,
49 POINTL* BrushOrigin,
50 ULONG Mode);
51
52 BOOL STDCALL EngIntersectRect(RECTL* prcDst, RECTL* prcSrc1, RECTL* prcSrc2)
53 {
54 static const RECTL rclEmpty = { 0, 0, 0, 0 };
55
56 prcDst->left = max(prcSrc1->left, prcSrc2->left);
57 prcDst->right = min(prcSrc1->right, prcSrc2->right);
58
59 if (prcDst->left < prcDst->right)
60 {
61 prcDst->top = max(prcSrc1->top, prcSrc2->top);
62 prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom);
63
64 if (prcDst->top < prcDst->bottom)
65 {
66 return TRUE;
67 }
68 }
69
70 *prcDst = rclEmpty;
71
72 return FALSE;
73 }
74
75 static BOOLEAN STDCALL
76 BltMask(SURFOBJ* Dest,
77 SURFOBJ* Source,
78 SURFOBJ* Mask,
79 XLATEOBJ* ColorTranslation,
80 RECTL* DestRect,
81 POINTL* SourcePoint,
82 POINTL* MaskPoint,
83 BRUSHOBJ* Brush,
84 POINTL* BrushPoint,
85 ROP4 Rop4)
86 {
87 LONG i, j, dx, dy, c8;
88 BYTE *tMask, *lMask;
89 static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
90 /* Pattern brushes */
91 PGDIBRUSHINST GdiBrush = NULL;
92 HBITMAP PatternSurface = NULL;
93 SURFOBJ *PatternObj = NULL;
94 PBITMAPOBJ PatternBitmap;
95 ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0;
96
97 if (Mask == NULL)
98 {
99 return FALSE;
100 }
101
102 dx = DestRect->right - DestRect->left;
103 dy = DestRect->bottom - DestRect->top;
104
105 if (Brush->iSolidColor == 0xFFFFFFFF)
106 {
107 GdiBrush = CONTAINING_RECORD(
108 Brush,
109 GDIBRUSHINST,
110 BrushObject);
111
112 PatternSurface = GdiBrush->GdiBrushObject->hbmPattern;
113 PatternBitmap = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern);
114 if(PatternBitmap != NULL)
115 {
116 PatternObj = &PatternBitmap->SurfObj;
117 PatternWidth = PatternObj->sizlBitmap.cx;
118 PatternHeight = PatternObj->sizlBitmap.cy;
119 }
120 }
121 else
122 PatternBitmap = NULL;
123
124 tMask = Mask->pvScan0 + SourcePoint->y * Mask->lDelta + (SourcePoint->x >> 3);
125 for (j = 0; j < dy; j++)
126 {
127 lMask = tMask;
128 c8 = SourcePoint->x & 0x07;
129
130 if(PatternBitmap != NULL)
131 PatternY = (DestRect->top + j) % PatternHeight;
132
133 for (i = 0; i < dx; i++)
134 {
135 if (0 != (*lMask & maskbit[c8]))
136 {
137 if (PatternBitmap == NULL)
138 {
139 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel(
140 Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor);
141 }
142 else
143 {
144 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel(
145 Dest, DestRect->left + i, DestRect->top + j,
146 DIB_GetSource(PatternObj, (DestRect->left + i) % PatternWidth, PatternY, GdiBrush->XlateObject));
147 }
148 }
149 c8++;
150 if (8 == c8)
151 {
152 lMask++;
153 c8 = 0;
154 }
155 }
156 tMask += Mask->lDelta;
157 }
158
159 if (PatternBitmap != NULL)
160 BITMAPOBJ_UnlockBitmap(PatternSurface);
161
162 return TRUE;
163 }
164
165 static BOOLEAN STDCALL
166 BltPatCopy(SURFOBJ* Dest,
167 SURFOBJ* Source,
168 SURFOBJ* Mask,
169 XLATEOBJ* ColorTranslation,
170 RECTL* DestRect,
171 POINTL* SourcePoint,
172 POINTL* MaskPoint,
173 BRUSHOBJ* Brush,
174 POINTL* BrushPoint,
175 ROP4 Rop4)
176 {
177 // These functions are assigned if we're working with a DIB
178 // The assigned functions depend on the bitsPerPixel of the DIB
179 LONG y;
180 ULONG LineWidth;
181
182 LineWidth = DestRect->right - DestRect->left;
183 for (y = DestRect->top; y < DestRect->bottom; y++)
184 {
185 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_HLine(
186 Dest, DestRect->left, DestRect->right, y, Brush->iSolidColor);
187 }
188
189 return TRUE;
190 }
191
192 static BOOLEAN STDCALL
193 CallDibBitBlt(SURFOBJ* OutputObj,
194 SURFOBJ* InputObj,
195 SURFOBJ* Mask,
196 XLATEOBJ* ColorTranslation,
197 RECTL* OutputRect,
198 POINTL* InputPoint,
199 POINTL* MaskOrigin,
200 BRUSHOBJ* Brush,
201 POINTL* BrushOrigin,
202 ROP4 Rop4)
203 {
204 BLTINFO BltInfo;
205 PGDIBRUSHINST GdiBrush = NULL;
206 BITMAPOBJ *bmPattern;
207 BOOLEAN Result;
208
209 BltInfo.DestSurface = OutputObj;
210 BltInfo.SourceSurface = InputObj;
211 BltInfo.PatternSurface = NULL;
212 BltInfo.XlateSourceToDest = ColorTranslation;
213 BltInfo.DestRect = *OutputRect;
214 BltInfo.SourcePoint = *InputPoint;
215
216 if (Rop4 == SRCCOPY)
217 return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo);
218
219 BltInfo.XlatePatternToDest = NULL;
220 BltInfo.Brush = Brush;
221 BltInfo.BrushOrigin = *BrushOrigin;
222 BltInfo.Rop4 = Rop4;
223
224 /* Pattern brush */
225 if (ROP_USES_PATTERN(Rop4) && Brush->iSolidColor == 0xFFFFFFFF)
226 {
227 GdiBrush = CONTAINING_RECORD(Brush, GDIBRUSHINST, BrushObject);
228 if((bmPattern = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern)))
229 {
230 BltInfo.PatternSurface = &bmPattern->SurfObj;
231 }
232 else
233 {
234 /* FIXME - What to do here? */
235 }
236 BltInfo.XlatePatternToDest = GdiBrush->XlateObject;
237 }
238 else
239 {
240 bmPattern = NULL;
241 }
242
243 Result = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBlt(&BltInfo);
244
245 /* Pattern brush */
246 if (bmPattern != NULL)
247 {
248 BITMAPOBJ_UnlockBitmap(BltInfo.PatternSurface->hsurf);
249 }
250
251 return Result;
252 }
253
254 INT abs(INT nm);
255
256 /*
257 * @implemented
258 */
259 BOOL STDCALL
260 EngBitBlt(SURFOBJ *DestObj,
261 SURFOBJ *SourceObj,
262 SURFOBJ *Mask,
263 CLIPOBJ *ClipRegion,
264 XLATEOBJ *ColorTranslation,
265 RECTL *DestRect,
266 POINTL *SourcePoint,
267 POINTL *MaskOrigin,
268 BRUSHOBJ *Brush,
269 POINTL *BrushOrigin,
270 ROP4 Rop4)
271 {
272 BYTE clippingType;
273 RECTL CombinedRect;
274 RECT_ENUM RectEnum;
275 BOOL EnumMore;
276 POINTL InputPoint;
277 RECTL InputRect;
278 RECTL OutputRect;
279 POINTL Translate;
280 INTENG_ENTER_LEAVE EnterLeaveSource;
281 INTENG_ENTER_LEAVE EnterLeaveDest;
282 SURFOBJ* InputObj;
283 SURFOBJ* OutputObj;
284 PBLTRECTFUNC BltRectFunc;
285 BOOLEAN Ret = TRUE;
286 RECTL ClipRect;
287 unsigned i;
288 POINTL Pt;
289 ULONG Direction;
290 BOOL UsesSource;
291 BOOL UsesPattern;
292 POINTL AdjustedBrushOrigin;
293
294 UsesSource = ((Rop4 & 0xCC0000) >> 2) != (Rop4 & 0x330000);
295 UsesPattern = ((Rop4 & 0xF00000) >> 4) != (Rop4 & 0x0F0000);
296 if (ROP_NOOP == Rop4)
297 {
298 /* Copy destination onto itself: nop */
299 return TRUE;
300 }
301
302 if (NULL != SourcePoint)
303 {
304 InputRect.left = SourcePoint->x;
305 InputRect.right = SourcePoint->x + (DestRect->right - DestRect->left);
306 InputRect.top = SourcePoint->y;
307 InputRect.bottom = SourcePoint->y + (DestRect->bottom - DestRect->top);
308 }
309 else
310 {
311 InputRect.left = 0;
312 InputRect.right = DestRect->right - DestRect->left;
313 InputRect.top = 0;
314 InputRect.bottom = DestRect->bottom - DestRect->top;
315 }
316
317 if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, &Translate, &InputObj))
318 {
319 return FALSE;
320 }
321
322 if (NULL != SourcePoint)
323 {
324 InputPoint.x = SourcePoint->x + Translate.x;
325 InputPoint.y = SourcePoint->y + Translate.y;
326 }
327 else
328 {
329 InputPoint.x = 0;
330 InputPoint.y = 0;
331 }
332
333 OutputRect = *DestRect;
334 if (NULL != ClipRegion)
335 {
336 if (OutputRect.left < ClipRegion->rclBounds.left)
337 {
338 InputRect.left += ClipRegion->rclBounds.left - OutputRect.left;
339 InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left;
340 OutputRect.left = ClipRegion->rclBounds.left;
341 }
342 if (ClipRegion->rclBounds.right < OutputRect.right)
343 {
344 InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right;
345 OutputRect.right = ClipRegion->rclBounds.right;
346 }
347 if (OutputRect.top < ClipRegion->rclBounds.top)
348 {
349 InputRect.top += ClipRegion->rclBounds.top - OutputRect.top;
350 InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top;
351 OutputRect.top = ClipRegion->rclBounds.top;
352 }
353 if (ClipRegion->rclBounds.bottom < OutputRect.bottom)
354 {
355 InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom;
356 OutputRect.bottom = ClipRegion->rclBounds.bottom;
357 }
358 }
359
360 /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's
361 nothing to do */
362 if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top)
363 {
364 IntEngLeave(&EnterLeaveSource);
365 return TRUE;
366 }
367
368 if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj))
369 {
370 IntEngLeave(&EnterLeaveSource);
371 return FALSE;
372 }
373
374 OutputRect.left = DestRect->left + Translate.x;
375 OutputRect.right = DestRect->right + Translate.x;
376 OutputRect.top = DestRect->top + Translate.y;
377 OutputRect.bottom = DestRect->bottom + Translate.y;
378
379 if(BrushOrigin)
380 {
381 AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x;
382 AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y;
383 }
384 else
385 AdjustedBrushOrigin = Translate;
386
387 // Determine clipping type
388 if (ClipRegion == (CLIPOBJ *) NULL)
389 {
390 clippingType = DC_TRIVIAL;
391 } else {
392 clippingType = ClipRegion->iDComplexity;
393 }
394
395 if (0xaacc == Rop4)
396 {
397 BltRectFunc = BltMask;
398 }
399 else if (PATCOPY == Rop4)
400 {
401 #if 0
402 BltRectFunc = BltPatCopy;
403 #else
404 if (Brush->iSolidColor == 0xFFFFFFFF)
405 BltRectFunc = CallDibBitBlt;
406 else
407 BltRectFunc = BltPatCopy;
408 #endif
409 }
410 else
411 {
412 BltRectFunc = CallDibBitBlt;
413 }
414
415
416 switch(clippingType)
417 {
418 case DC_TRIVIAL:
419 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation,
420 &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin, Rop4);
421 break;
422 case DC_RECT:
423 // Clip the blt to the clip rectangle
424 ClipRect.left = ClipRegion->rclBounds.left + Translate.x;
425 ClipRect.right = ClipRegion->rclBounds.right + Translate.x;
426 ClipRect.top = ClipRegion->rclBounds.top + Translate.y;
427 ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y;
428 EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect);
429 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
430 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
431 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation,
432 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, Rop4);
433 break;
434 case DC_COMPLEX:
435 Ret = TRUE;
436 if (OutputObj == InputObj)
437 {
438 if (OutputRect.top < InputPoint.y)
439 {
440 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTDOWN : CD_LEFTDOWN;
441 }
442 else
443 {
444 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTUP : CD_LEFTUP;
445 }
446 }
447 else
448 {
449 Direction = CD_ANY;
450 }
451 CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0);
452 do
453 {
454 EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
455
456 for (i = 0; i < RectEnum.c; i++)
457 {
458 ClipRect.left = RectEnum.arcl[i].left + Translate.x;
459 ClipRect.right = RectEnum.arcl[i].right + Translate.x;
460 ClipRect.top = RectEnum.arcl[i].top + Translate.y;
461 ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y;
462 EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect);
463 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
464 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
465 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation,
466 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, Rop4) &&
467 Ret;
468 }
469 }
470 while(EnumMore);
471 break;
472 }
473
474
475 IntEngLeave(&EnterLeaveDest);
476 IntEngLeave(&EnterLeaveSource);
477
478 return Ret;
479 }
480
481 BOOL STDCALL
482 IntEngBitBlt(BITMAPOBJ *DestObj,
483 BITMAPOBJ *SourceObj,
484 BITMAPOBJ *MaskObj,
485 CLIPOBJ *ClipRegion,
486 XLATEOBJ *ColorTranslation,
487 RECTL *DestRect,
488 POINTL *SourcePoint,
489 POINTL *MaskOrigin,
490 BRUSHOBJ *Brush,
491 POINTL *BrushOrigin,
492 ROP4 Rop4)
493 {
494 BOOLEAN ret;
495 RECTL InputClippedRect;
496 RECTL OutputRect;
497 POINTL InputPoint;
498 BOOLEAN UsesSource;
499 SURFOBJ *DestSurf = &DestObj->SurfObj;
500 SURFOBJ *SourceSurf = SourceObj ? &SourceObj->SurfObj : NULL;
501 SURFOBJ *MaskSurf = MaskObj ? &MaskObj->SurfObj : NULL;
502
503 InputClippedRect = *DestRect;
504 if (InputClippedRect.right < InputClippedRect.left)
505 {
506 InputClippedRect.left = DestRect->right;
507 InputClippedRect.right = DestRect->left;
508 }
509 if (InputClippedRect.bottom < InputClippedRect.top)
510 {
511 InputClippedRect.top = DestRect->bottom;
512 InputClippedRect.bottom = DestRect->top;
513 }
514 UsesSource = ((Rop4 & 0xCC0000) >> 2) != (Rop4 & 0x330000);
515 if (UsesSource)
516 {
517 if (NULL == SourcePoint || NULL == SourceSurf)
518 {
519 return FALSE;
520 }
521 InputPoint = *SourcePoint;
522
523 /* Make sure we don't try to copy anything outside the valid source region */
524 if (InputPoint.x < 0)
525 {
526 InputClippedRect.left -= InputPoint.x;
527 InputPoint.x = 0;
528 }
529 if (InputPoint.y < 0)
530 {
531 InputClippedRect.top -= InputPoint.y;
532 InputPoint.y = 0;
533 }
534 if (SourceSurf->sizlBitmap.cx < InputPoint.x + InputClippedRect.right - InputClippedRect.left)
535 {
536 InputClippedRect.right = InputClippedRect.left + SourceSurf->sizlBitmap.cx - InputPoint.x;
537 }
538 if (SourceSurf->sizlBitmap.cy < InputPoint.y + InputClippedRect.bottom - InputClippedRect.top)
539 {
540 InputClippedRect.bottom = InputClippedRect.top + SourceSurf->sizlBitmap.cy - InputPoint.y;
541 }
542
543 if (InputClippedRect.right < InputClippedRect.left ||
544 InputClippedRect.bottom < InputClippedRect.top)
545 {
546 /* Everything clipped away, nothing to do */
547 return TRUE;
548 }
549 }
550
551 /* Clip against the bounds of the clipping region so we won't try to write
552 * outside the surface */
553 if (NULL != ClipRegion)
554 {
555 if (! EngIntersectRect(&OutputRect, &InputClippedRect, &ClipRegion->rclBounds))
556 {
557 return TRUE;
558 }
559 InputPoint.x += OutputRect.left - DestRect->left;
560 InputPoint.y += OutputRect.top - DestRect->top;
561 }
562 else
563 {
564 OutputRect = InputClippedRect;
565 }
566
567 if (UsesSource)
568 {
569 MouseSafetyOnDrawStart(SourceSurf, InputPoint.x, InputPoint.y,
570 (InputPoint.x + abs(DestRect->right - DestRect->left)),
571 (InputPoint.y + abs(DestRect->bottom - DestRect->top)));
572 }
573
574 /* No success yet */
575 ret = FALSE;
576 MouseSafetyOnDrawStart(DestSurf, OutputRect.left, OutputRect.top,
577 OutputRect.right, OutputRect.bottom);
578
579 /* Call the driver's DrvBitBlt if available */
580 if (DestObj->flHooks & HOOK_BITBLT)
581 {
582 ret = GDIDEVFUNCS(DestSurf).BitBlt(
583 DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation,
584 &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin,
585 Rop4);
586 }
587
588 if (! ret)
589 {
590 ret = EngBitBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation,
591 &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin,
592 Rop4);
593 }
594
595 MouseSafetyOnDrawEnd(DestSurf);
596 if (UsesSource)
597 {
598 MouseSafetyOnDrawEnd(SourceSurf);
599 }
600
601 return ret;
602 }
603
604 static BOOLEAN STDCALL
605 CallDibStretchBlt(SURFOBJ* OutputObj,
606 SURFOBJ* InputObj,
607 SURFOBJ* Mask,
608 CLIPOBJ* ClipRegion,
609 XLATEOBJ* ColorTranslation,
610 RECTL* OutputRect,
611 RECTL* InputRect,
612 POINTL* MaskOrigin,
613 POINTL* BrushOrigin,
614 ULONG Mode)
615 {
616 POINTL RealBrushOrigin;
617 if (BrushOrigin == NULL)
618 {
619 RealBrushOrigin.x = RealBrushOrigin.y = 0;
620 }
621 else
622 {
623 RealBrushOrigin = *BrushOrigin;
624 }
625 return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_StretchBlt(
626 OutputObj, InputObj, OutputRect, InputRect, MaskOrigin, RealBrushOrigin, ClipRegion, ColorTranslation, Mode);
627 }
628
629
630 BOOL
631 STDCALL
632 EngStretchBlt(
633 IN SURFOBJ *DestObj,
634 IN SURFOBJ *SourceObj,
635 IN SURFOBJ *Mask,
636 IN CLIPOBJ *ClipRegion,
637 IN XLATEOBJ *ColorTranslation,
638 IN COLORADJUSTMENT *pca,
639 IN POINTL *BrushOrigin,
640 IN RECTL *prclDest,
641 IN RECTL *prclSrc,
642 IN POINTL *MaskOrigin,
643 IN ULONG Mode
644 )
645 {
646 // www.osr.com/ddk/graphics/gdifncs_0bs7.htm
647
648 POINTL InputPoint;
649 RECTL InputRect;
650 RECTL OutputRect;
651 POINTL Translate;
652 INTENG_ENTER_LEAVE EnterLeaveSource;
653 INTENG_ENTER_LEAVE EnterLeaveDest;
654 SURFOBJ* InputObj;
655 SURFOBJ* OutputObj;
656 PSTRETCHRECTFUNC BltRectFunc;
657 BOOLEAN Ret;
658 POINTL AdjustedBrushOrigin;
659
660 InputRect.left = prclSrc->left;
661 InputRect.right = prclSrc->right;
662 InputRect.top = prclSrc->top;
663 InputRect.bottom = prclSrc->bottom;
664
665 if (! IntEngEnter(&EnterLeaveSource, SourceObj, &InputRect, TRUE, &Translate, &InputObj))
666 {
667 return FALSE;
668 }
669
670 InputPoint.x = InputRect.left + Translate.x;
671 InputPoint.y = InputRect.top + Translate.y;
672
673 OutputRect = *prclDest;
674
675 /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's
676 nothing to do */
677 if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top)
678 {
679 IntEngLeave(&EnterLeaveSource);
680 return TRUE;
681 }
682
683 if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj))
684 {
685 IntEngLeave(&EnterLeaveSource);
686 return FALSE;
687 }
688
689 OutputRect.left = prclDest->left + Translate.x;
690 OutputRect.right = prclDest->right + Translate.x;
691 OutputRect.top = prclDest->top + Translate.y;
692 OutputRect.bottom = prclDest->bottom + Translate.y;
693
694 if (NULL != BrushOrigin)
695 {
696 AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x;
697 AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y;
698 }
699 else
700 {
701 AdjustedBrushOrigin = Translate;
702 }
703
704 if (Mask != NULL)
705 {
706 //BltRectFunc = BltMask;
707 DPRINT("EngStretchBlt isn't capable of handling mask yet.\n");
708 IntEngLeave(&EnterLeaveDest);
709 IntEngLeave(&EnterLeaveSource);
710
711 return FALSE;
712 }
713 else
714 {
715 BltRectFunc = CallDibStretchBlt;
716 }
717
718
719 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ClipRegion,
720 ColorTranslation, &OutputRect, &InputRect, MaskOrigin,
721 &AdjustedBrushOrigin, Mode);
722
723 IntEngLeave(&EnterLeaveDest);
724 IntEngLeave(&EnterLeaveSource);
725
726 return Ret;
727 }
728
729 BOOL STDCALL
730 IntEngStretchBlt(BITMAPOBJ *DestObj,
731 BITMAPOBJ *SourceObj,
732 BITMAPOBJ *MaskObj,
733 CLIPOBJ *ClipRegion,
734 XLATEOBJ *ColorTranslation,
735 RECTL *DestRect,
736 RECTL *SourceRect,
737 POINTL *pMaskOrigin,
738 BRUSHOBJ *Brush,
739 POINTL *BrushOrigin,
740 ULONG Mode)
741 {
742 BOOLEAN ret;
743 COLORADJUSTMENT ca;
744 POINT MaskOrigin;
745 SURFOBJ *DestSurf = &DestObj->SurfObj;
746 SURFOBJ *SourceSurf = SourceObj ? &SourceObj->SurfObj : NULL;
747 SURFOBJ *MaskSurf = MaskObj ? &MaskObj->SurfObj : NULL;
748
749 if (pMaskOrigin != NULL)
750 {
751 MaskOrigin.x = pMaskOrigin->x; MaskOrigin.y = pMaskOrigin->y;
752 }
753
754 if (NULL != SourceObj)
755 {
756 MouseSafetyOnDrawStart(SourceSurf, SourceRect->left, SourceRect->top,
757 SourceRect->right, SourceRect->bottom);
758 }
759
760 /* No success yet */
761 ret = FALSE;
762 MouseSafetyOnDrawStart(DestSurf, DestRect->left, DestRect->top,
763 DestRect->right, DestRect->bottom);
764
765 /* Prepare color adjustment */
766
767 /* Call the driver's DrvStretchBlt if available */
768 if (DestObj->flHooks & HOOK_STRETCHBLT)
769 {
770 /* Drv->StretchBlt (look at http://www.osr.com/ddk/graphics/ddifncs_3ew7.htm )
771 SURFOBJ *psoMask // optional, if it exists, then rop4=0xCCAA, otherwise rop4=0xCCCC */
772 // FIXME: MaskOrigin is always NULL !
773 ret = GDIDEVFUNCS(DestSurf).StretchBlt(
774 DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation,
775 &ca, BrushOrigin, DestRect, SourceRect, NULL, Mode);
776 }
777
778 if (! ret)
779 {
780 // FIXME: see previous fixme
781 ret = EngStretchBlt(DestSurf, SourceSurf, MaskSurf, ClipRegion, ColorTranslation,
782 &ca, BrushOrigin, DestRect, SourceRect, NULL, Mode);
783 }
784
785 MouseSafetyOnDrawEnd(DestSurf);
786 if (NULL != SourceSurf)
787 {
788 MouseSafetyOnDrawEnd(SourceSurf);
789 }
790
791 return ret;
792 }
793
794 /**** REACTOS FONT RENDERING CODE *********************************************/
795
796 /* renders the alpha mask bitmap */
797 static BOOLEAN STDCALL
798 AlphaBltMask(SURFOBJ* Dest,
799 SURFOBJ* Source,
800 SURFOBJ* Mask,
801 XLATEOBJ* ColorTranslation,
802 XLATEOBJ* SrcColorTranslation,
803 RECTL* DestRect,
804 POINTL* SourcePoint,
805 POINTL* MaskPoint,
806 BRUSHOBJ* Brush,
807 POINTL* BrushPoint)
808 {
809 LONG i, j, dx, dy;
810 int r, g, b;
811 ULONG Background, BrushColor, NewColor;
812 BYTE *tMask, *lMask;
813
814 dx = DestRect->right - DestRect->left;
815 dy = DestRect->bottom - DestRect->top;
816
817 if (Mask != NULL)
818 {
819 BrushColor = XLATEOBJ_iXlate(SrcColorTranslation, Brush->iSolidColor);
820 r = (int)GetRValue(BrushColor);
821 g = (int)GetGValue(BrushColor);
822 b = (int)GetBValue(BrushColor);
823
824 tMask = Mask->pvBits + (SourcePoint->y * Mask->lDelta) + SourcePoint->x;
825 for (j = 0; j < dy; j++)
826 {
827 lMask = tMask;
828 for (i = 0; i < dx; i++)
829 {
830 if (*lMask > 0)
831 {
832 if(*lMask == 0xff)
833 {
834 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel(
835 Dest, DestRect->left + i, DestRect->top + j, Brush->iSolidColor);
836 }
837 else
838 {
839 Background = DIB_GetSource(Dest, DestRect->left + i, DestRect->top + j, SrcColorTranslation);
840
841 NewColor =
842 RGB((*lMask * (r - GetRValue(Background)) >> 8) + GetRValue(Background),
843 (*lMask * (g - GetGValue(Background)) >> 8) + GetGValue(Background),
844 (*lMask * (b - GetBValue(Background)) >> 8) + GetBValue(Background));
845
846 Background = XLATEOBJ_iXlate(ColorTranslation, NewColor);
847 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel(
848 Dest, DestRect->left + i, DestRect->top + j, Background);
849 }
850 }
851 lMask++;
852 }
853 tMask += Mask->lDelta;
854 }
855 return TRUE;
856 }
857 else
858 {
859 return FALSE;
860 }
861 }
862
863 BOOL STDCALL
864 EngMaskBitBlt(SURFOBJ *DestObj,
865 SURFOBJ *Mask,
866 CLIPOBJ *ClipRegion,
867 XLATEOBJ *DestColorTranslation,
868 XLATEOBJ *SourceColorTranslation,
869 RECTL *DestRect,
870 POINTL *SourcePoint,
871 POINTL *MaskOrigin,
872 BRUSHOBJ *Brush,
873 POINTL *BrushOrigin)
874 {
875 BYTE clippingType;
876 RECTL CombinedRect;
877 RECT_ENUM RectEnum;
878 BOOL EnumMore;
879 POINTL InputPoint;
880 RECTL InputRect;
881 RECTL OutputRect;
882 POINTL Translate;
883 INTENG_ENTER_LEAVE EnterLeaveSource;
884 INTENG_ENTER_LEAVE EnterLeaveDest;
885 SURFOBJ* InputObj;
886 SURFOBJ* OutputObj;
887 BOOLEAN Ret = TRUE;
888 RECTL ClipRect;
889 unsigned i;
890 POINTL Pt;
891 ULONG Direction;
892 POINTL AdjustedBrushOrigin;
893
894 if (NULL != SourcePoint)
895 {
896 InputRect.left = SourcePoint->x;
897 InputRect.right = SourcePoint->x + (DestRect->right - DestRect->left);
898 InputRect.top = SourcePoint->y;
899 InputRect.bottom = SourcePoint->y + (DestRect->bottom - DestRect->top);
900 }
901 else
902 {
903 InputRect.left = 0;
904 InputRect.right = DestRect->right - DestRect->left;
905 InputRect.top = 0;
906 InputRect.bottom = DestRect->bottom - DestRect->top;
907 }
908
909 if (! IntEngEnter(&EnterLeaveSource, NULL, &InputRect, TRUE, &Translate, &InputObj))
910 {
911 return FALSE;
912 }
913
914 if (NULL != SourcePoint)
915 {
916 InputPoint.x = SourcePoint->x + Translate.x;
917 InputPoint.y = SourcePoint->y + Translate.y;
918 }
919 else
920 {
921 InputPoint.x = 0;
922 InputPoint.y = 0;
923 }
924
925 OutputRect = *DestRect;
926 if (NULL != ClipRegion)
927 {
928 if (OutputRect.left < ClipRegion->rclBounds.left)
929 {
930 InputRect.left += ClipRegion->rclBounds.left - OutputRect.left;
931 InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left;
932 OutputRect.left = ClipRegion->rclBounds.left;
933 }
934 if (ClipRegion->rclBounds.right < OutputRect.right)
935 {
936 InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right;
937 OutputRect.right = ClipRegion->rclBounds.right;
938 }
939 if (OutputRect.top < ClipRegion->rclBounds.top)
940 {
941 InputRect.top += ClipRegion->rclBounds.top - OutputRect.top;
942 InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top;
943 OutputRect.top = ClipRegion->rclBounds.top;
944 }
945 if (ClipRegion->rclBounds.bottom < OutputRect.bottom)
946 {
947 InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom;
948 OutputRect.bottom = ClipRegion->rclBounds.bottom;
949 }
950 }
951
952 /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's
953 nothing to do */
954 if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top)
955 {
956 IntEngLeave(&EnterLeaveSource);
957 return TRUE;
958 }
959
960 if (! IntEngEnter(&EnterLeaveDest, DestObj, &OutputRect, FALSE, &Translate, &OutputObj))
961 {
962 IntEngLeave(&EnterLeaveSource);
963 return FALSE;
964 }
965
966 OutputRect.left = DestRect->left + Translate.x;
967 OutputRect.right = DestRect->right + Translate.x;
968 OutputRect.top = DestRect->top + Translate.y;
969 OutputRect.bottom = DestRect->bottom + Translate.y;
970
971 if(BrushOrigin)
972 {
973 AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x;
974 AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y;
975 }
976 else
977 AdjustedBrushOrigin = Translate;
978
979 // Determine clipping type
980 if (ClipRegion == (CLIPOBJ *) NULL)
981 {
982 clippingType = DC_TRIVIAL;
983 } else {
984 clippingType = ClipRegion->iDComplexity;
985 }
986
987 switch(clippingType)
988 {
989 case DC_TRIVIAL:
990 if(Mask->iBitmapFormat == BMF_8BPP)
991 Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation,
992 &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin);
993 else
994 Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation,
995 &OutputRect, &InputPoint, MaskOrigin, Brush, &AdjustedBrushOrigin, 0xAACC);
996 break;
997 case DC_RECT:
998 // Clip the blt to the clip rectangle
999 ClipRect.left = ClipRegion->rclBounds.left + Translate.x;
1000 ClipRect.right = ClipRegion->rclBounds.right + Translate.x;
1001 ClipRect.top = ClipRegion->rclBounds.top + Translate.y;
1002 ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y;
1003 EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect);
1004 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
1005 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
1006 if(Mask->iBitmapFormat == BMF_8BPP)
1007 Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation,
1008 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin);
1009 else
1010 Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation,
1011 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, 0xAACC);
1012 break;
1013 case DC_COMPLEX:
1014 Ret = TRUE;
1015 if (OutputObj == InputObj)
1016 {
1017 if (OutputRect.top < InputPoint.y)
1018 {
1019 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTDOWN : CD_LEFTDOWN;
1020 }
1021 else
1022 {
1023 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTUP : CD_LEFTUP;
1024 }
1025 }
1026 else
1027 {
1028 Direction = CD_ANY;
1029 }
1030 CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0);
1031 do
1032 {
1033 EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
1034
1035 for (i = 0; i < RectEnum.c; i++)
1036 {
1037 ClipRect.left = RectEnum.arcl[i].left + Translate.x;
1038 ClipRect.right = RectEnum.arcl[i].right + Translate.x;
1039 ClipRect.top = RectEnum.arcl[i].top + Translate.y;
1040 ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y;
1041 EngIntersectRect(&CombinedRect, &OutputRect, &ClipRect);
1042 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
1043 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
1044 if(Mask->iBitmapFormat == BMF_8BPP)
1045 Ret = AlphaBltMask(OutputObj, InputObj, Mask, DestColorTranslation, SourceColorTranslation,
1046 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin) && Ret;
1047 else
1048 Ret = BltMask(OutputObj, InputObj, Mask, DestColorTranslation,
1049 &CombinedRect, &Pt, MaskOrigin, Brush, &AdjustedBrushOrigin, 0xAACC) && Ret;
1050 }
1051 }
1052 while(EnumMore);
1053 break;
1054 }
1055
1056
1057 IntEngLeave(&EnterLeaveDest);
1058 IntEngLeave(&EnterLeaveSource);
1059
1060 /* Dummy BitBlt to let driver know that something has changed.
1061 0x00AA0029 is the Rop for D (no-op) */
1062 /* FIXME: Remove the typecast! */
1063 IntEngBitBlt((BITMAPOBJ*)DestObj, NULL, (BITMAPOBJ*)Mask, ClipRegion, DestColorTranslation,
1064 DestRect, SourcePoint, MaskOrigin, Brush, BrushOrigin, ROP_NOOP);
1065
1066 return Ret;
1067 }
1068
1069 BOOL STDCALL
1070 IntEngMaskBlt(SURFOBJ *DestObj,
1071 SURFOBJ *Mask,
1072 CLIPOBJ *ClipRegion,
1073 XLATEOBJ *DestColorTranslation,
1074 XLATEOBJ *SourceColorTranslation,
1075 RECTL *DestRect,
1076 POINTL *SourcePoint,
1077 POINTL *MaskOrigin,
1078 BRUSHOBJ *Brush,
1079 POINTL *BrushOrigin)
1080 {
1081 BOOLEAN ret;
1082 RECTL OutputRect;
1083 POINTL InputPoint;
1084
1085 if (NULL != SourcePoint)
1086 {
1087 InputPoint = *SourcePoint;
1088 }
1089
1090 /* Clip against the bounds of the clipping region so we won't try to write
1091 * outside the surface */
1092 if (NULL != ClipRegion)
1093 {
1094 if (! EngIntersectRect(&OutputRect, DestRect, &ClipRegion->rclBounds))
1095 {
1096 return TRUE;
1097 }
1098 InputPoint.x += OutputRect.left - DestRect->left;
1099 InputPoint.y += OutputRect.top - DestRect->top;
1100 }
1101 else
1102 {
1103 OutputRect = *DestRect;
1104 }
1105
1106 /* No success yet */
1107 ret = FALSE;
1108 MouseSafetyOnDrawStart(DestObj, OutputRect.left, OutputRect.top,
1109 OutputRect.right, OutputRect.bottom);
1110
1111 ret = EngMaskBitBlt(DestObj, Mask, ClipRegion, DestColorTranslation, SourceColorTranslation,
1112 &OutputRect, &InputPoint, MaskOrigin, Brush, BrushOrigin);
1113
1114 MouseSafetyOnDrawEnd(DestObj);
1115
1116 return ret;
1117 }
1118 /* EOF */