projects / reactos.git / blob
? search:


88ee1902993332b93f37076ed4cf6103f592cb07
[reactos.git] / subsystems / win32 / win32k / eng / bitblt.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: GDI BitBlt Functions
5 * FILE: subsys/win32k/eng/bitblt.c
6 * PROGRAMER: Jason Filby
7 * Timo Kreuzer
8 * REVISION HISTORY:
9 * 2/10/1999: Created
10 */
11
12 #include <w32k.h>
13
14 #define NDEBUG
15 #include <debug.h>
16
17 typedef BOOLEAN (APIENTRY *PBLTRECTFUNC)(SURFOBJ* OutputObj,
18 SURFOBJ* InputObj,
19 SURFOBJ* Mask,
20 XLATEOBJ* ColorTranslation,
21 RECTL* OutputRect,
22 POINTL* InputPoint,
23 POINTL* MaskOrigin,
24 BRUSHOBJ* pbo,
25 POINTL* BrushOrigin,
26 ROP4 Rop4);
27
28 static BOOLEAN APIENTRY
29 BltMask(SURFOBJ* psoDest,
30 SURFOBJ* psoSource, // unused
31 SURFOBJ* psoMask,
32 XLATEOBJ* ColorTranslation, // unused
33 RECTL* prclDest,
34 POINTL* pptlSource, // unused
35 POINTL* pptlMask,
36 BRUSHOBJ* pbo,
37 POINTL* pptlBrush,
38 ROP4 Rop4)
39 {
40 LONG x, y;
41 BYTE *pjMskLine, *pjMskCurrent;
42 BYTE fjMaskBit0, fjMaskBit;
43 /* Pattern brushes */
44 PEBRUSHOBJ pebo = NULL;
45 SURFOBJ *psoPattern = NULL;
46 PSURFACE psurfPattern;
47 ULONG PatternWidth = 0, PatternHeight = 0;
48 LONG PatternX0 = 0, PatternX = 0, PatternY = 0;
49 PFN_DIB_PutPixel fnDest_PutPixel = NULL;
50 PFN_DIB_GetPixel fnPattern_GetPixel = NULL;
51 ULONG Pattern = 0;
52 HBITMAP hbmPattern;
53
54 if (psoMask == NULL)
55 {
56 return FALSE;
57 }
58
59 if (pbo && pbo->iSolidColor == 0xFFFFFFFF)
60 {
61 pebo = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
62
63 hbmPattern = EBRUSHOBJ_pvGetEngBrush(pebo);
64 psurfPattern = SURFACE_LockSurface(hbmPattern);
65 if (psurfPattern != NULL)
66 {
67 psoPattern = &psurfPattern->SurfObj;
68 PatternWidth = psoPattern->sizlBitmap.cx;
69 PatternHeight = psoPattern->sizlBitmap.cy;
70 fnPattern_GetPixel = DibFunctionsForBitmapFormat[psoPattern->iBitmapFormat].DIB_GetPixel;
71 }
72 }
73 else
74 psurfPattern = NULL;
75
76 pjMskLine = (PBYTE)psoMask->pvScan0 + pptlMask->y * psoMask->lDelta + (pptlMask->x >> 3);
77 fjMaskBit0 = 0x80 >> (pptlMask->x & 0x07);
78
79 fnDest_PutPixel = DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_PutPixel;
80 if (psurfPattern)
81 {
82 PatternY = (prclDest->top - pptlBrush->y) % PatternHeight;
83 if (PatternY < 0)
84 {
85 PatternY += PatternHeight;
86 }
87 PatternX0 = (prclDest->left - pptlBrush->x) % PatternWidth;
88 if (PatternX0 < 0)
89 {
90 PatternX0 += PatternWidth;
91 }
92
93 for (y = prclDest->top; y < prclDest->bottom; y++)
94 {
95 pjMskCurrent = pjMskLine;
96 fjMaskBit = fjMaskBit0;
97 PatternX = PatternX0;
98
99 for (x = prclDest->left; x < prclDest->right; x++)
100 {
101 if (*pjMskCurrent & fjMaskBit)
102 {
103 fnDest_PutPixel(psoDest, x, y,
104 fnPattern_GetPixel(psoPattern, PatternX, PatternY));
105 }
106 fjMaskBit = _rotr8(fjMaskBit, 1);
107 pjMskCurrent += (fjMaskBit >> 7);
108 PatternX++;
109 PatternX %= PatternWidth;
110 }
111 pjMskLine += psoMask->lDelta;
112 PatternY++;
113 PatternY %= PatternHeight;
114 }
115 }
116 else
117 {
118 Pattern = pbo ? pbo->iSolidColor : 0;
119 for (y = prclDest->top; y < prclDest->bottom; y++)
120 {
121 pjMskCurrent = pjMskLine;
122 fjMaskBit = fjMaskBit0;
123
124 for (x = prclDest->left; x < prclDest->right; x++)
125 {
126 if (*pjMskCurrent & fjMaskBit)
127 {
128 fnDest_PutPixel(psoDest, x, y, Pattern);
129 }
130 fjMaskBit = _rotr8(fjMaskBit, 1);
131 pjMskCurrent += (fjMaskBit >> 7);
132 }
133 pjMskLine += psoMask->lDelta;
134 }
135 }
136
137 if (psurfPattern)
138 SURFACE_UnlockSurface(psurfPattern);
139
140 return TRUE;
141 }
142
143 static BOOLEAN APIENTRY
144 BltPatCopy(SURFOBJ* Dest,
145 SURFOBJ* Source,
146 SURFOBJ* Mask,
147 XLATEOBJ* ColorTranslation,
148 RECTL* DestRect,
149 POINTL* SourcePoint,
150 POINTL* MaskPoint,
151 BRUSHOBJ* pbo,
152 POINTL* BrushPoint,
153 ROP4 Rop4)
154 {
155 // These functions are assigned if we're working with a DIB
156 // The assigned functions depend on the bitsPerPixel of the DIB
157
158 DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_ColorFill(Dest, DestRect, pbo ? pbo->iSolidColor : 0);
159
160 return TRUE;
161 }
162
163 static BOOLEAN APIENTRY
164 CallDibBitBlt(SURFOBJ* OutputObj,
165 SURFOBJ* InputObj,
166 SURFOBJ* Mask,
167 XLATEOBJ* ColorTranslation,
168 RECTL* OutputRect,
169 POINTL* InputPoint,
170 POINTL* MaskOrigin,
171 BRUSHOBJ* pbo,
172 POINTL* BrushOrigin,
173 ROP4 Rop4)
174 {
175 BLTINFO BltInfo;
176 PEBRUSHOBJ GdiBrush = NULL;
177 SURFACE *psurfPattern;
178 BOOLEAN Result;
179 HBITMAP hbmPattern;
180
181 BltInfo.DestSurface = OutputObj;
182 BltInfo.SourceSurface = InputObj;
183 BltInfo.PatternSurface = NULL;
184 BltInfo.XlateSourceToDest = ColorTranslation;
185 BltInfo.DestRect = *OutputRect;
186 BltInfo.SourcePoint = *InputPoint;
187
188 if (ROP3_TO_ROP4(SRCCOPY) == Rop4)
189 return DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBltSrcCopy(&BltInfo);
190
191 BltInfo.Brush = pbo;
192 BltInfo.BrushOrigin = *BrushOrigin;
193 BltInfo.Rop4 = Rop4;
194
195 /* Pattern brush */
196 if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF)
197 {
198 GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
199 hbmPattern = EBRUSHOBJ_pvGetEngBrush(GdiBrush);
200 psurfPattern = SURFACE_LockSurface(hbmPattern);
201 if (psurfPattern)
202 {
203 BltInfo.PatternSurface = &psurfPattern->SurfObj;
204 }
205 else
206 {
207 /* FIXME - What to do here? */
208 }
209 }
210 else
211 {
212 psurfPattern = NULL;
213 }
214
215 Result = DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_BitBlt(&BltInfo);
216
217 /* Pattern brush */
218 if (psurfPattern)
219 {
220 SURFACE_UnlockSurface(psurfPattern);
221 }
222
223 return Result;
224 }
225
226 INT __cdecl abs(INT nm);
227
228
229 /*
230 * @implemented
231 */
232 BOOL APIENTRY
233 NtGdiEngBitBlt(
234 IN SURFOBJ *psoTrg,
235 IN SURFOBJ *psoSrc,
236 IN SURFOBJ *psoMask,
237 IN CLIPOBJ *pco,
238 IN XLATEOBJ *pxlo,
239 IN RECTL *prclTrg,
240 IN POINTL *pptlSrc,
241 IN POINTL *pptlMask,
242 IN BRUSHOBJ *pbo,
243 IN POINTL *pptlBrush,
244 IN ROP4 rop4 )
245 {
246 RECTL rclTrg;
247 POINTL ptlSrc;
248 POINTL ptlMask;
249 POINTL ptlBrush;
250
251 _SEH2_TRY
252 {
253 ProbeForRead(prclTrg, sizeof(RECTL), 1);
254 RtlCopyMemory(&rclTrg,prclTrg, sizeof(RECTL));
255
256 ProbeForRead(pptlSrc, sizeof(POINTL), 1);
257 RtlCopyMemory(&ptlSrc, pptlSrc, sizeof(POINTL));
258
259 ProbeForRead(pptlMask, sizeof(POINTL), 1);
260 RtlCopyMemory(&ptlMask, pptlMask, sizeof(POINTL));
261
262 ProbeForRead(pptlBrush, sizeof(POINTL), 1);
263 RtlCopyMemory(&ptlBrush, pptlBrush, sizeof(POINTL));
264
265 }
266 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
267 {
268 _SEH2_YIELD(return FALSE);
269 }
270 _SEH2_END;
271
272 return EngBitBlt(psoTrg, psoSrc, psoMask, pco, pxlo, &rclTrg, &ptlSrc, &ptlMask, pbo, &ptlBrush, rop4);
273 }
274
275 /*
276 * @implemented
277 */
278 BOOL APIENTRY
279 EngBitBlt(SURFOBJ *DestObj,
280 SURFOBJ *SourceObj,
281 SURFOBJ *Mask,
282 CLIPOBJ *ClipRegion,
283 XLATEOBJ *ColorTranslation,
284 RECTL *DestRect,
285 POINTL *SourcePoint,
286 POINTL *MaskOrigin,
287 BRUSHOBJ *pbo,
288 POINTL *BrushOrigin,
289 ROP4 rop4)
290 {
291 BYTE clippingType;
292 RECTL CombinedRect;
293 RECT_ENUM RectEnum;
294 BOOL EnumMore;
295 POINTL InputPoint;
296 RECTL InputRect;
297 RECTL OutputRect;
298 SURFOBJ* InputObj = 0;
299 SURFOBJ* OutputObj;
300 PBLTRECTFUNC BltRectFunc;
301 BOOLEAN Ret = TRUE;
302 RECTL ClipRect;
303 unsigned i;
304 POINTL Pt;
305 ULONG Direction;
306 BOOL UsesSource;
307 BOOL UsesPattern;
308 POINTL AdjustedBrushOrigin;
309
310 UsesSource = ROP4_USES_SOURCE(rop4);
311 UsesPattern = ROP4_USES_PATTERN(rop4);
312 if (R4_NOOP == rop4)
313 {
314 /* Copy destination onto itself: nop */
315 return TRUE;
316 }
317
318 OutputRect = *DestRect;
319 if (OutputRect.right < OutputRect.left)
320 {
321 OutputRect.left = DestRect->right;
322 OutputRect.right = DestRect->left;
323 }
324 if (OutputRect.bottom < OutputRect.top)
325 {
326 OutputRect.left = DestRect->right;
327 OutputRect.right = DestRect->left;
328 }
329
330 if (UsesSource)
331 {
332 if (NULL == SourcePoint)
333 {
334 return FALSE;
335 }
336
337 /* Make sure we don't try to copy anything outside the valid source
338 region */
339 InputPoint = *SourcePoint;
340 if (InputPoint.x < 0)
341 {
342 OutputRect.left -= InputPoint.x;
343 InputPoint.x = 0;
344 }
345 if (InputPoint.y < 0)
346 {
347 OutputRect.top -= InputPoint.y;
348 InputPoint.y = 0;
349 }
350 if (SourceObj->sizlBitmap.cx < InputPoint.x +
351 OutputRect.right - OutputRect.left)
352 {
353 OutputRect.right = OutputRect.left +
354 SourceObj->sizlBitmap.cx - InputPoint.x;
355 }
356 if (SourceObj->sizlBitmap.cy < InputPoint.y +
357 OutputRect.bottom - OutputRect.top)
358 {
359 OutputRect.bottom = OutputRect.top +
360 SourceObj->sizlBitmap.cy - InputPoint.y;
361 }
362
363 InputRect.left = InputPoint.x;
364 InputRect.right = InputPoint.x + (OutputRect.right - OutputRect.left);
365 InputRect.top = InputPoint.y;
366 InputRect.bottom = InputPoint.y + (OutputRect.bottom - OutputRect.top);
367
368 InputObj = SourceObj;
369 }
370 else
371 {
372 InputRect.left = 0;
373 InputRect.right = DestRect->right - DestRect->left;
374 InputRect.top = 0;
375 InputRect.bottom = DestRect->bottom - DestRect->top;
376 }
377
378 if (NULL != ClipRegion)
379 {
380 if (OutputRect.left < ClipRegion->rclBounds.left)
381 {
382 InputRect.left += ClipRegion->rclBounds.left - OutputRect.left;
383 InputPoint.x += ClipRegion->rclBounds.left - OutputRect.left;
384 OutputRect.left = ClipRegion->rclBounds.left;
385 }
386 if (ClipRegion->rclBounds.right < OutputRect.right)
387 {
388 InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right;
389 OutputRect.right = ClipRegion->rclBounds.right;
390 }
391 if (OutputRect.top < ClipRegion->rclBounds.top)
392 {
393 InputRect.top += ClipRegion->rclBounds.top - OutputRect.top;
394 InputPoint.y += ClipRegion->rclBounds.top - OutputRect.top;
395 OutputRect.top = ClipRegion->rclBounds.top;
396 }
397 if (ClipRegion->rclBounds.bottom < OutputRect.bottom)
398 {
399 InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom;
400 OutputRect.bottom = ClipRegion->rclBounds.bottom;
401 }
402 }
403
404 /* Check for degenerate case: if height or width of OutputRect is 0 pixels
405 there's nothing to do */
406 if (OutputRect.right <= OutputRect.left ||
407 OutputRect.bottom <= OutputRect.top)
408 {
409 return TRUE;
410 }
411
412 OutputObj = DestObj;
413
414 if (BrushOrigin)
415 {
416 AdjustedBrushOrigin.x = BrushOrigin->x;
417 AdjustedBrushOrigin.y = BrushOrigin->y;
418 }
419 else
420 {
421 AdjustedBrushOrigin.x = 0;
422 AdjustedBrushOrigin.y = 0;
423 }
424
425 /* Determine clipping type */
426 if (ClipRegion == (CLIPOBJ *) NULL)
427 {
428 clippingType = DC_TRIVIAL;
429 }
430 else
431 {
432 clippingType = ClipRegion->iDComplexity;
433 }
434
435 if (R4_MASK == rop4)
436 {
437 BltRectFunc = BltMask;
438 }
439 else if (ROP3_TO_ROP4(PATCOPY) == rop4)
440 {
441 if (pbo && pbo->iSolidColor == 0xFFFFFFFF)
442 BltRectFunc = CallDibBitBlt;
443 else
444 BltRectFunc = BltPatCopy;
445 }
446 else
447 {
448 BltRectFunc = CallDibBitBlt;
449 }
450
451
452 switch (clippingType)
453 {
454 case DC_TRIVIAL:
455 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation,
456 &OutputRect, &InputPoint, MaskOrigin, pbo,
457 &AdjustedBrushOrigin, rop4);
458 break;
459 case DC_RECT:
460 /* Clip the blt to the clip rectangle */
461 ClipRect.left = ClipRegion->rclBounds.left;
462 ClipRect.right = ClipRegion->rclBounds.right;
463 ClipRect.top = ClipRegion->rclBounds.top;
464 ClipRect.bottom = ClipRegion->rclBounds.bottom;
465 if (RECTL_bIntersectRect(&CombinedRect, &OutputRect, &ClipRect))
466 {
467 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
468 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
469 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask, ColorTranslation,
470 &CombinedRect, &Pt, MaskOrigin, pbo,
471 &AdjustedBrushOrigin, rop4);
472 }
473 break;
474 case DC_COMPLEX:
475 Ret = TRUE;
476 if (OutputObj == InputObj)
477 {
478 if (OutputRect.top < InputPoint.y)
479 {
480 Direction = OutputRect.left < InputPoint.x ?
481 CD_RIGHTDOWN : CD_LEFTDOWN;
482 }
483 else
484 {
485 Direction = OutputRect.left < InputPoint.x ?
486 CD_RIGHTUP : CD_LEFTUP;
487 }
488 }
489 else
490 {
491 Direction = CD_ANY;
492 }
493 CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0);
494 do
495 {
496 EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum),
497 (PVOID) &RectEnum);
498
499 for (i = 0; i < RectEnum.c; i++)
500 {
501 ClipRect.left = RectEnum.arcl[i].left;
502 ClipRect.right = RectEnum.arcl[i].right;
503 ClipRect.top = RectEnum.arcl[i].top;
504 ClipRect.bottom = RectEnum.arcl[i].bottom;
505 if (RECTL_bIntersectRect(&CombinedRect, &OutputRect, &ClipRect))
506 {
507 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
508 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
509 Ret = (*BltRectFunc)(OutputObj, InputObj, Mask,
510 ColorTranslation, &CombinedRect, &Pt,
511 MaskOrigin, pbo, &AdjustedBrushOrigin,
512 rop4) && Ret;
513 }
514 }
515 }
516 while (EnumMore);
517 break;
518 }
519
520 return Ret;
521 }
522
523 BOOL APIENTRY
524 IntEngBitBltEx(
525 SURFOBJ *psoTrg,
526 SURFOBJ *psoSrc,
527 SURFOBJ *psoMask,
528 CLIPOBJ *pco,
529 XLATEOBJ *pxlo,
530 RECTL *prclTrg,
531 POINTL *pptlSrc,
532 POINTL *pptlMask,
533 BRUSHOBJ *pbo,
534 POINTL *pptlBrush,
535 ROP4 rop4,
536 BOOL bRemoveMouse)
537 {
538 SURFACE *psurfTrg;
539 SURFACE *psurfSrc = NULL;
540 BOOL bResult;
541 RECTL rclClipped;
542 RECTL rclSrc;
543 // INTENG_ENTER_LEAVE EnterLeaveSource;
544 // INTENG_ENTER_LEAVE EnterLeaveDest;
545 PFN_DrvBitBlt pfnBitBlt;
546
547 ASSERT(psoTrg);
548 psurfTrg = CONTAINING_RECORD(psoTrg, SURFACE, SurfObj);
549
550 /* FIXME: Should we really allow to pass non-well-ordered rects? */
551 rclClipped = *prclTrg;
552 RECTL_vMakeWellOrdered(&rclClipped);
553
554 /* Clip target rect against the bounds of the clipping region */
555 if (pco)
556 {
557 if (!RECTL_bIntersectRect(&rclClipped, &rclClipped, &pco->rclBounds))
558 {
559 /* Nothing left */
560 return TRUE;
561 }
562
563 /* Don't pass a clipobj with only a single rect */
564 if (pco->iDComplexity == DC_RECT)
565 pco = NULL;
566 }
567
568 if (ROP4_USES_SOURCE(rop4))
569 {
570 ASSERT(psoSrc);
571 psurfSrc = CONTAINING_RECORD(psoSrc, SURFACE, SurfObj);
572
573 /* Calculate source rect */
574 rclSrc.left = pptlSrc->x + rclClipped.left - prclTrg->left;
575 rclSrc.top = pptlSrc->y + rclClipped.top - prclTrg->top;
576 rclSrc.right = rclSrc.left + rclClipped.right - rclClipped.left;
577 rclSrc.bottom = rclSrc.top + rclClipped.bottom - rclClipped.top;
578 }
579 else
580 {
581 psoSrc = NULL;
582 psurfSrc = NULL;
583 }
584
585 if (bRemoveMouse)
586 {
587 SURFACE_LockBitmapBits(psurfTrg);
588
589 if (psoSrc)
590 {
591 if (psoSrc != psoTrg)
592 {
593 SURFACE_LockBitmapBits(psurfSrc);
594 }
595 }
596 }
597
598 /* Is the target surface device managed? */
599 if (psurfTrg->flHooks & HOOK_BITBLT)
600 {
601 /* Is the source a different device managed surface? */
602 if (psoSrc && psoSrc->hdev != psoTrg->hdev && psurfSrc->flHooks & HOOK_BITBLT)
603 {
604 DPRINT1("Need to copy to standard bitmap format!\n");
605 ASSERT(FALSE);
606 }
607
608 pfnBitBlt = GDIDEVFUNCS(psoTrg).BitBlt;
609 }
610
611 /* Is the source surface device managed? */
612 else if (psoSrc && psurfSrc->flHooks & HOOK_BITBLT)
613 {
614 pfnBitBlt = GDIDEVFUNCS(psoSrc).BitBlt;
615 }
616 else
617 {
618 pfnBitBlt = EngBitBlt;
619 }
620
621 bResult = pfnBitBlt(psoTrg,
622 psoSrc,
623 psoMask,
624 pco,
625 pxlo,
626 &rclClipped,
627 (POINTL*)&rclSrc,
628 pptlMask,
629 pbo,
630 pptlBrush,
631 rop4);
632
633 // FIXME: cleanup temp surface!
634
635 if (bRemoveMouse)
636 {
637 if (psoSrc)
638 {
639 if (psoSrc != psoTrg)
640 {
641 SURFACE_UnlockBitmapBits(psurfSrc);
642 }
643 }
644 SURFACE_UnlockBitmapBits(psurfTrg);
645 }
646
647 return bResult;
648 }
649
650
651 /**** REACTOS FONT RENDERING CODE *********************************************/
652
653 /* renders the alpha mask bitmap */
654 static BOOLEAN APIENTRY
655 AlphaBltMask(SURFOBJ* psoDest,
656 SURFOBJ* psoSource, // unused
657 SURFOBJ* psoMask,
658 XLATEOBJ* ColorTranslation,
659 XLATEOBJ* SrcColorTranslation,
660 RECTL* prclDest,
661 POINTL* pptlSource, // unused
662 POINTL* pptlMask,
663 BRUSHOBJ* pbo,
664 POINTL* pptlBrush)
665 {
666 LONG i, j, dx, dy;
667 int r, g, b;
668 ULONG Background, BrushColor, NewColor;
669 BYTE *tMask, *lMask;
670
671 dx = prclDest->right - prclDest->left;
672 dy = prclDest->bottom - prclDest->top;
673
674 if (psoMask != NULL)
675 {
676 BrushColor = XLATEOBJ_iXlate(SrcColorTranslation, pbo ? pbo->iSolidColor : 0);
677 r = (int)GetRValue(BrushColor);
678 g = (int)GetGValue(BrushColor);
679 b = (int)GetBValue(BrushColor);
680
681 tMask = (PBYTE)psoMask->pvScan0 + (pptlMask->y * psoMask->lDelta) + pptlMask->x;
682 for (j = 0; j < dy; j++)
683 {
684 lMask = tMask;
685 for (i = 0; i < dx; i++)
686 {
687 if (*lMask > 0)
688 {
689 if (*lMask == 0xff)
690 {
691 DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_PutPixel(
692 psoDest, prclDest->left + i, prclDest->top + j, pbo ? pbo->iSolidColor : 0);
693 }
694 else
695 {
696 Background = DIB_GetSource(psoDest, prclDest->left + i, prclDest->top + j,
697 SrcColorTranslation);
698
699 NewColor =
700 RGB((*lMask * (r - GetRValue(Background)) >> 8) + GetRValue(Background),
701 (*lMask * (g - GetGValue(Background)) >> 8) + GetGValue(Background),
702 (*lMask * (b - GetBValue(Background)) >> 8) + GetBValue(Background));
703
704 Background = XLATEOBJ_iXlate(ColorTranslation, NewColor);
705 DibFunctionsForBitmapFormat[psoDest->iBitmapFormat].DIB_PutPixel(
706 psoDest, prclDest->left + i, prclDest->top + j, Background);
707 }
708 }
709 lMask++;
710 }
711 tMask += psoMask->lDelta;
712 }
713 return TRUE;
714 }
715 else
716 {
717 return FALSE;
718 }
719 }
720
721 static
722 BOOL APIENTRY
723 EngMaskBitBlt(SURFOBJ *psoDest,
724 SURFOBJ *psoMask,
725 CLIPOBJ *ClipRegion,
726 XLATEOBJ *DestColorTranslation,
727 XLATEOBJ *SourceColorTranslation,
728 RECTL *DestRect,
729 POINTL *pptlMask,
730 BRUSHOBJ *pbo,
731 POINTL *BrushOrigin)
732 {
733 BYTE clippingType;
734 RECTL CombinedRect;
735 RECT_ENUM RectEnum;
736 BOOL EnumMore;
737 POINTL InputPoint;
738 RECTL InputRect;
739 RECTL OutputRect;
740 POINTL Translate;
741 INTENG_ENTER_LEAVE EnterLeaveSource;
742 INTENG_ENTER_LEAVE EnterLeaveDest;
743 SURFOBJ* psoInput;
744 SURFOBJ* psoOutput;
745 BOOLEAN Ret = TRUE;
746 RECTL ClipRect;
747 unsigned i;
748 POINTL Pt;
749 ULONG Direction;
750 POINTL AdjustedBrushOrigin;
751
752 ASSERT(psoMask);
753
754 if (pptlMask)
755 {
756 InputRect.left = pptlMask->x;
757 InputRect.right = pptlMask->x + (DestRect->right - DestRect->left);
758 InputRect.top = pptlMask->y;
759 InputRect.bottom = pptlMask->y + (DestRect->bottom - DestRect->top);
760 }
761 else
762 {
763 InputRect.left = 0;
764 InputRect.right = DestRect->right - DestRect->left;
765 InputRect.top = 0;
766 InputRect.bottom = DestRect->bottom - DestRect->top;
767 }
768
769 OutputRect = *DestRect;
770 if (NULL != ClipRegion)
771 {
772 if (OutputRect.left < ClipRegion->rclBounds.left)
773 {
774 InputRect.left += ClipRegion->rclBounds.left - OutputRect.left;
775 OutputRect.left = ClipRegion->rclBounds.left;
776 }
777 if (ClipRegion->rclBounds.right < OutputRect.right)
778 {
779 InputRect.right -= OutputRect.right - ClipRegion->rclBounds.right;
780 OutputRect.right = ClipRegion->rclBounds.right;
781 }
782 if (OutputRect.top < ClipRegion->rclBounds.top)
783 {
784 InputRect.top += ClipRegion->rclBounds.top - OutputRect.top;
785 OutputRect.top = ClipRegion->rclBounds.top;
786 }
787 if (ClipRegion->rclBounds.bottom < OutputRect.bottom)
788 {
789 InputRect.bottom -= OutputRect.bottom - ClipRegion->rclBounds.bottom;
790 OutputRect.bottom = ClipRegion->rclBounds.bottom;
791 }
792 }
793
794 if (! IntEngEnter(&EnterLeaveSource, psoMask, &InputRect, TRUE, &Translate, &psoInput))
795 {
796 return FALSE;
797 }
798
799 InputPoint.x = InputRect.left + Translate.x;
800 InputPoint.y = InputRect.top + Translate.y;
801
802 /* Check for degenerate case: if height or width of OutputRect is 0 pixels there's
803 nothing to do */
804 if (OutputRect.right <= OutputRect.left || OutputRect.bottom <= OutputRect.top)
805 {
806 IntEngLeave(&EnterLeaveSource);
807 return TRUE;
808 }
809
810 if (! IntEngEnter(&EnterLeaveDest, psoDest, &OutputRect, FALSE, &Translate, &psoOutput))
811 {
812 IntEngLeave(&EnterLeaveSource);
813 return FALSE;
814 }
815
816 OutputRect.left = DestRect->left + Translate.x;
817 OutputRect.right = DestRect->right + Translate.x;
818 OutputRect.top = DestRect->top + Translate.y;
819 OutputRect.bottom = DestRect->bottom + Translate.y;
820
821 if (BrushOrigin)
822 {
823 AdjustedBrushOrigin.x = BrushOrigin->x + Translate.x;
824 AdjustedBrushOrigin.y = BrushOrigin->y + Translate.y;
825 }
826 else
827 AdjustedBrushOrigin = Translate;
828
829 // Determine clipping type
830 if (ClipRegion == (CLIPOBJ *) NULL)
831 {
832 clippingType = DC_TRIVIAL;
833 } else {
834 clippingType = ClipRegion->iDComplexity;
835 }
836
837 switch (clippingType)
838 {
839 case DC_TRIVIAL:
840 if (psoMask->iBitmapFormat == BMF_8BPP)
841 Ret = AlphaBltMask(psoOutput, NULL , psoInput, DestColorTranslation, SourceColorTranslation,
842 &OutputRect, &InputPoint, pptlMask, pbo, &AdjustedBrushOrigin);
843 else
844 Ret = BltMask(psoOutput, NULL, psoInput, DestColorTranslation,
845 &OutputRect, &InputPoint, pptlMask, pbo, &AdjustedBrushOrigin,
846 R4_MASK);
847 break;
848 case DC_RECT:
849 // Clip the blt to the clip rectangle
850 ClipRect.left = ClipRegion->rclBounds.left + Translate.x;
851 ClipRect.right = ClipRegion->rclBounds.right + Translate.x;
852 ClipRect.top = ClipRegion->rclBounds.top + Translate.y;
853 ClipRect.bottom = ClipRegion->rclBounds.bottom + Translate.y;
854 if (RECTL_bIntersectRect(&CombinedRect, &OutputRect, &ClipRect))
855 {
856 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
857 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
858 if (psoMask->iBitmapFormat == BMF_8BPP)
859 {
860 Ret = AlphaBltMask(psoOutput, psoInput, psoMask, DestColorTranslation, SourceColorTranslation,
861 &CombinedRect, &Pt, pptlMask, pbo, &AdjustedBrushOrigin);
862 }
863 else
864 {
865 Ret = BltMask(psoOutput, psoInput, psoMask, DestColorTranslation,
866 &CombinedRect, &Pt, pptlMask, pbo, &AdjustedBrushOrigin, R4_MASK);
867 }
868 }
869 break;
870 case DC_COMPLEX:
871 Ret = TRUE;
872 if (psoOutput == psoInput)
873 {
874 if (OutputRect.top < InputPoint.y)
875 {
876 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTDOWN : CD_LEFTDOWN;
877 }
878 else
879 {
880 Direction = OutputRect.left < InputPoint.x ? CD_RIGHTUP : CD_LEFTUP;
881 }
882 }
883 else
884 {
885 Direction = CD_ANY;
886 }
887 CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, Direction, 0);
888 do
889 {
890 EnumMore = CLIPOBJ_bEnum(ClipRegion,(ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
891
892 for (i = 0; i < RectEnum.c; i++)
893 {
894 ClipRect.left = RectEnum.arcl[i].left + Translate.x;
895 ClipRect.right = RectEnum.arcl[i].right + Translate.x;
896 ClipRect.top = RectEnum.arcl[i].top + Translate.y;
897 ClipRect.bottom = RectEnum.arcl[i].bottom + Translate.y;
898 if (RECTL_bIntersectRect(&CombinedRect, &OutputRect, &ClipRect))
899 {
900 Pt.x = InputPoint.x + CombinedRect.left - OutputRect.left;
901 Pt.y = InputPoint.y + CombinedRect.top - OutputRect.top;
902 if (psoMask->iBitmapFormat == BMF_8BPP)
903 {
904 Ret = AlphaBltMask(psoOutput, psoInput, psoMask,
905 DestColorTranslation,
906 SourceColorTranslation,
907 &CombinedRect, &Pt, pptlMask, pbo,
908 &AdjustedBrushOrigin) && Ret;
909 }
910 else
911 {
912 Ret = BltMask(psoOutput, psoInput, psoMask,
913 DestColorTranslation, &CombinedRect, &Pt,
914 pptlMask, pbo, &AdjustedBrushOrigin,
915 R4_MASK) && Ret;
916 }
917 }
918 }
919 }
920 while (EnumMore);
921 break;
922 }
923
924
925 IntEngLeave(&EnterLeaveDest);
926 IntEngLeave(&EnterLeaveSource);
927
928 return Ret;
929 }
930
931 BOOL APIENTRY
932 IntEngMaskBlt(SURFOBJ *psoDest,
933 SURFOBJ *psoMask,
934 CLIPOBJ *ClipRegion,
935 XLATEOBJ *DestColorTranslation,
936 XLATEOBJ *SourceColorTranslation,
937 RECTL *DestRect,
938 POINTL *pptlMask,
939 BRUSHOBJ *pbo,
940 POINTL *BrushOrigin)
941 {
942 BOOLEAN ret;
943 RECTL OutputRect;
944 POINTL InputPoint;
945 SURFACE *psurfDest;
946
947 ASSERT(psoMask);
948
949 if (pptlMask)
950 {
951 InputPoint = *pptlMask;
952 }
953
954 /* Clip against the bounds of the clipping region so we won't try to write
955 * outside the surface */
956 if (NULL != ClipRegion)
957 {
958 if (!RECTL_bIntersectRect(&OutputRect, DestRect, &ClipRegion->rclBounds))
959 {
960 return TRUE;
961 }
962 InputPoint.x += OutputRect.left - DestRect->left;
963 InputPoint.y += OutputRect.top - DestRect->top;
964 }
965 else
966 {
967 OutputRect = *DestRect;
968 }
969
970 /* No success yet */
971 ret = FALSE;
972 ASSERT(psoDest);
973 psurfDest = CONTAINING_RECORD(psoDest, SURFACE, SurfObj);
974
975 SURFACE_LockBitmapBits(psurfDest);
976
977 /* Dummy BitBlt to let driver know that it should flush its changes.
978 This should really be done using a call to DrvSynchronizeSurface,
979 but the VMware driver doesn't hook that call. */
980 IntEngBitBltEx(psoDest, NULL, psoMask, ClipRegion, DestColorTranslation,
981 DestRect, pptlMask, pptlMask, pbo, BrushOrigin,
982 R4_NOOP, FALSE);
983
984 ret = EngMaskBitBlt(psoDest, psoMask, ClipRegion, DestColorTranslation, SourceColorTranslation,
985 &OutputRect, &InputPoint, pbo, BrushOrigin);
986
987 /* Dummy BitBlt to let driver know that something has changed. */
988 IntEngBitBltEx(psoDest, NULL, psoMask, ClipRegion, DestColorTranslation,
989 DestRect, pptlMask, pptlMask, pbo, BrushOrigin,
990 R4_NOOP, FALSE);
991
992 SURFACE_UnlockBitmapBits(psurfDest);
993
994 return ret;
995 }
996
997 /* EOF */
A free Windows-compatible Operating System