This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | _BLTINFO |
| struct | DIB_FUNCTIONS |
Macros | |
| #define | ROP4_BLACKNESS ((((0x00000042) >> 8) & 0xff00) | (((0x00000042) >> 16) & 0x00ff)) |
| #define | ROP4_NOTSRCERASE ((((0x001100A6) >> 8) & 0xff00) | (((0x001100A6) >> 16) & 0x00ff)) |
| #define | ROP4_NOTSRCCOPY ((((0x00330008) >> 8) & 0xff00) | (((0x00330008) >> 16) & 0x00ff)) |
| #define | ROP4_SRCERASE ((((0x00440328) >> 8) & 0xff00) | (((0x00440328) >> 16) & 0x00ff)) |
| #define | ROP4_DSTINVERT ((((0x00550009) >> 8) & 0xff00) | (((0x00550009) >> 16) & 0x00ff)) |
| #define | ROP4_PATINVERT ((((0x005A0049) >> 8) & 0xff00) | (((0x005A0049) >> 16) & 0x00ff)) |
| #define | ROP4_SRCINVERT ((((0x00660046) >> 8) & 0xff00) | (((0x00660046) >> 16) & 0x00ff)) |
| #define | ROP4_SRCAND ((((0x008800C6) >> 8) & 0xff00) | (((0x008800C6) >> 16) & 0x00ff)) |
| #define | ROP4_MERGEPAINT ((((0x00BB0226) >> 8) & 0xff00) | (((0x00BB0226) >> 16) & 0x00ff)) |
| #define | ROP4_MERGECOPY ((((0x00C000CA) >> 8) & 0xff00) | (((0x00C000CA) >> 16) & 0x00ff)) |
| #define | ROP4_SRCCOPY ((((0x00CC0020) >> 8) & 0xff00) | (((0x00CC0020) >> 16) & 0x00ff)) |
| #define | ROP4_SRCPAINT ((((0x00EE0086) >> 8) & 0xff00) | (((0x00EE0086) >> 16) & 0x00ff)) |
| #define | ROP4_PATCOPY ((((0x00F00021) >> 8) & 0xff00) | (((0x00F00021) >> 16) & 0x00ff)) |
| #define | ROP4_PATPAINT ((((0x00FB0A09) >> 8) & 0xff00) | (((0x00FB0A09) >> 16) & 0x00ff)) |
| #define | ROP4_WHITENESS ((((0x00FF0062) >> 8) & 0xff00) | (((0x00FF0062) >> 16) & 0x00ff)) |
| #define | MASK1BPP(x) (1<<(7-((x)&7))) |
| #define | DIB_GetSource(SourceSurf, sx, sy, ColorTranslation) |
| #define | DIB_GetSourceIndex(SourceSurf, sx, sy) |
Typedefs | |
| typedef struct _BLTINFO | BLTINFO |
| typedef struct _BLTINFO * | PBLTINFO |
| typedef VOID(* | PFN_DIB_PutPixel) (SURFOBJ *, LONG, LONG, ULONG) |
| typedef ULONG(* | PFN_DIB_GetPixel) (SURFOBJ *, LONG, LONG) |
| typedef VOID(* | PFN_DIB_HLine) (SURFOBJ *, LONG, LONG, LONG, ULONG) |
| typedef VOID(* | PFN_DIB_VLine) (SURFOBJ *, LONG, LONG, LONG, ULONG) |
| typedef BOOLEAN(* | PFN_DIB_BitBlt) (PBLTINFO) |
| typedef BOOLEAN(* | PFN_DIB_StretchBlt) (SURFOBJ *, SURFOBJ *, SURFOBJ *, SURFOBJ *, RECTL *, RECTL *, POINTL *, BRUSHOBJ *, POINTL *, XLATEOBJ *, ROP4) |
| typedef BOOLEAN(* | PFN_DIB_TransparentBlt) (SURFOBJ *, SURFOBJ *, RECTL *, RECTL *, XLATEOBJ *, ULONG) |
| typedef BOOLEAN(* | PFN_DIB_ColorFill) (SURFOBJ *, RECTL *, ULONG) |
| typedef BOOLEAN(* | PFN_DIB_AlphaBlend) (SURFOBJ *, SURFOBJ *, RECTL *, RECTL *, CLIPOBJ *, XLATEOBJ *, BLENDOBJ *) |
Variables | |
| DIB_FUNCTIONS | DibFunctionsForBitmapFormat [] |
| unsigned char | notmask [2] |
| unsigned char | altnotmask [2] |
Macro Definition Documentation
◆ DIB_GetSource
| #define DIB_GetSource | ( | SourceSurf, | |
| sx, | |||
| sy, | |||
| ColorTranslation | |||
| ) |
Value:
XLATEOBJ_iXlate(ColorTranslation, \
DibFunctionsForBitmapFormat[SourceSurf->iBitmapFormat]. \
DIB_GetPixel(SourceSurf, sx, sy))
ENGAPI ULONG APIENTRY XLATEOBJ_iXlate(_In_ XLATEOBJ *pxlo, _In_ ULONG iColor)
Definition: xlateobj.c:664
◆ DIB_GetSourceIndex
| #define DIB_GetSourceIndex | ( | SourceSurf, | |
| sx, | |||
| sy | |||
| ) |
Value:
DibFunctionsForBitmapFormat[SourceSurf->iBitmapFormat]. \
DIB_GetPixel(SourceSurf, sx, sy)
◆ MASK1BPP
◆ ROP4_BLACKNESS
| #define ROP4_BLACKNESS ((((0x00000042) >> 8) & 0xff00) | (((0x00000042) >> 16) & 0x00ff)) |
◆ ROP4_DSTINVERT
| #define ROP4_DSTINVERT ((((0x00550009) >> 8) & 0xff00) | (((0x00550009) >> 16) & 0x00ff)) |
◆ ROP4_MERGECOPY
| #define ROP4_MERGECOPY ((((0x00C000CA) >> 8) & 0xff00) | (((0x00C000CA) >> 16) & 0x00ff)) |
◆ ROP4_MERGEPAINT
| #define ROP4_MERGEPAINT ((((0x00BB0226) >> 8) & 0xff00) | (((0x00BB0226) >> 16) & 0x00ff)) |
◆ ROP4_NOTSRCCOPY
| #define ROP4_NOTSRCCOPY ((((0x00330008) >> 8) & 0xff00) | (((0x00330008) >> 16) & 0x00ff)) |
◆ ROP4_NOTSRCERASE
| #define ROP4_NOTSRCERASE ((((0x001100A6) >> 8) & 0xff00) | (((0x001100A6) >> 16) & 0x00ff)) |
◆ ROP4_PATCOPY
| #define ROP4_PATCOPY ((((0x00F00021) >> 8) & 0xff00) | (((0x00F00021) >> 16) & 0x00ff)) |
◆ ROP4_PATINVERT
| #define ROP4_PATINVERT ((((0x005A0049) >> 8) & 0xff00) | (((0x005A0049) >> 16) & 0x00ff)) |
◆ ROP4_PATPAINT
| #define ROP4_PATPAINT ((((0x00FB0A09) >> 8) & 0xff00) | (((0x00FB0A09) >> 16) & 0x00ff)) |
◆ ROP4_SRCAND
| #define ROP4_SRCAND ((((0x008800C6) >> 8) & 0xff00) | (((0x008800C6) >> 16) & 0x00ff)) |
◆ ROP4_SRCCOPY
| #define ROP4_SRCCOPY ((((0x00CC0020) >> 8) & 0xff00) | (((0x00CC0020) >> 16) & 0x00ff)) |
◆ ROP4_SRCERASE
| #define ROP4_SRCERASE ((((0x00440328) >> 8) & 0xff00) | (((0x00440328) >> 16) & 0x00ff)) |
◆ ROP4_SRCINVERT
| #define ROP4_SRCINVERT ((((0x00660046) >> 8) & 0xff00) | (((0x00660046) >> 16) & 0x00ff)) |
◆ ROP4_SRCPAINT
| #define ROP4_SRCPAINT ((((0x00EE0086) >> 8) & 0xff00) | (((0x00EE0086) >> 16) & 0x00ff)) |
◆ ROP4_WHITENESS
| #define ROP4_WHITENESS ((((0x00FF0062) >> 8) & 0xff00) | (((0x00FF0062) >> 16) & 0x00ff)) |
Typedef Documentation
◆ BLTINFO
◆ PBLTINFO
◆ PFN_DIB_AlphaBlend
◆ PFN_DIB_BitBlt
◆ PFN_DIB_ColorFill
◆ PFN_DIB_GetPixel
◆ PFN_DIB_HLine
◆ PFN_DIB_PutPixel
◆ PFN_DIB_StretchBlt
◆ PFN_DIB_TransparentBlt
◆ PFN_DIB_VLine
Function Documentation
◆ DIB_16BPP_AlphaBlend()
| BOOLEAN DIB_16BPP_AlphaBlend | ( | SURFOBJ * | Dest, |
| SURFOBJ * | Source, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| CLIPOBJ * | ClipRegion, | ||
| XLATEOBJ * | ColorTranslation, | ||
| BLENDOBJ * | BlendObj | ||
| ) |
Definition at line 851 of file dib16bpp.c.
854{
855 INT DstX, DstY, SrcX, SrcY;
857 NICEPIXEL32 SrcPixel32;
858 UCHAR Alpha;
859 EXLATEOBJ* pexlo;
860 EXLATEOBJ exloSrcRGB;
861
865
868 {
871 }
873 {
876 }
878 {
881 }
884 {
887 }
888
889 if (!ColorTranslation)
890 {
893 }
894
897
899 {
900 NICEPIXEL16_555 DstPixel16;
901
902 SrcY = SourceRect->top;
903 DstY = DestRect->top;
905 {
906 SrcX = SourceRect->left;
907 DstX = DestRect->left;
909 {
914
918
919 Alpha >>= 3;
920
922 /* Perform bit loss */
923 SrcPixel32.col.red >>= 3;
924 SrcPixel32.col.green >>= 3;
925 SrcPixel32.col.blue >>= 3;
926
927 /* Do the blend in the right bit depth */
929 DstPixel16.col.green = Clamp5((DstPixel16.col.green * (31 - Alpha)) / 31 + SrcPixel32.col.green);
931
933
934 DstX++;
937 }
938 DstY++;
941 }
942 }
943 else
944 {
945 NICEPIXEL16_565 DstPixel16;
946 UCHAR Alpha6, Alpha5;
947
948 SrcY = SourceRect->top;
949 DstY = DestRect->top;
951 {
952 SrcX = SourceRect->left;
953 DstX = DestRect->left;
955 {
960
964
965 Alpha6 = Alpha >> 2;
966 Alpha5 = Alpha >> 3;
967
969 /* Perform bit loss */
970 SrcPixel32.col.red >>= 3;
971 SrcPixel32.col.green >>= 2;
972 SrcPixel32.col.blue >>= 3;
973
974 /* Do the blend in the right bit depth */
976 DstPixel16.col.green = Clamp6((DstPixel16.col.green * (63 - Alpha6)) / 63 + SrcPixel32.col.green);
978
980
981 DstX++;
984 }
985 DstY++;
988 }
989 }
990
991 EXLATEOBJ_vCleanup(&exloSrcRGB);
992
994}
VOID DIB_16BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib16bpp.c:21
ULONG DIB_16BPP_GetPixel(SURFOBJ *SurfObj, LONG x, LONG y)
Definition: dib16bpp.c:30
Definition: wingdi.h:3204
Definition: xlateobj.h:20
Definition: dib16bpp.c:827
struct NICEPIXEL16_555::@5360 col
Definition: dib16bpp.c:816
struct NICEPIXEL16_565::@5359 col
Definition: alphablend.c:15
struct NICEPIXEL32::@5357 col
VOID NTAPI EXLATEOBJ_vInitialize(_Out_ PEXLATEOBJ pexlo, _In_opt_ PALETTE *ppalSrc, _In_opt_ PALETTE *ppalDst, _In_ COLORREF crSrcBackColor, _In_ COLORREF crDstBackColor, _In_ COLORREF crDstForeColor)
Definition: xlateobj.c:358
◆ DIB_16BPP_BitBlt()
◆ DIB_16BPP_BitBltSrcCopy()
Definition at line 144 of file dib16bpp.c.
145{
147 PBYTE SourceBits, DestBits, SourceLine, DestLine;
148 PBYTE SourceBits_4BPP, SourceLine_4BPP;
149 PWORD Source32, Dest32;
151 BOOLEAN bTopToBottom, bLeftToRight;
152
153 DPRINT("DIB_16BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
156 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
157
158 /* Get back left to right flip here */
160
161 /* Check for top to bottom flip needed. */
163
166
167 /* Make WellOrdered with top < bottom and left < right */
169
172
173 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + 2 * BltInfo->DestRect.left;
174
176 {
181
182 /* This sets sy to the top line */
184
185 if (bTopToBottom)
186 {
187 /* This sets sy to the bottom line */
189 }
190
192 {
194
195 if (bLeftToRight)
196 {
197 /* This sets the sx to the rightmost pixel */
201 }
202 else
203 {
206 }
207
209 {
211 {
214 }
215 else
216 {
219 }
220 DEC_OR_INC(sx, bLeftToRight, 1);
221 }
222 DEC_OR_INC(sy, bTopToBottom, 1);
223 }
224 break;
225
229
230 /* This sets SourceBits_4BPP to the top line */
234
235 if (bTopToBottom)
236 {
237 /* This sets SourceBits_4BPP to the bottom line */
238 SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;
239 }
240
242 {
243 SourceLine_4BPP = SourceBits_4BPP;
245 if (bLeftToRight)
246 {
247 /* This sets sx to the rightmost pixel */
249 }
250
251 f1 = sx & 1;
252
254 {
259 {
260 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
261 f1 = 0;
262 }
263 else
264 {
265 f1 = 1;
266 }
267 DEC_OR_INC(sx, bLeftToRight, 1);
268 }
270 }
271 break;
272
276
277 /* This sets SourceLine to the top line */
281 DestLine = DestBits;
282
283 if (bTopToBottom)
284 {
285 /* This sets SourceLine to the bottom line */
288 }
289
291 {
292 SourceBits = SourceLine;
293 DestBits = DestLine;
294
295 if (bLeftToRight)
296 {
297 /* This sets SourceBits to the rightmost pixel */
299 }
300
302 {
304 BltInfo->XlateSourceToDest, *SourceBits);
305 DEC_OR_INC(SourceBits, bLeftToRight, 1);
306 DestBits += 2;
307 }
310 }
311 break;
312
316
321
324 (!bTopToBottom && !bLeftToRight))
325 {
328 {
329 /* This sets SourceBits to the top line */
334
336 {
337 RtlMoveMemory(DestBits, SourceBits,
340
343 }
344 }
345 else
346 {
347 /* This sets SourceBits to the bottom line */
353
358
361 {
362 RtlMoveMemory(DestBits, SourceBits, 2 *
365
368 }
369 }
370 }
371 else
372 {
374 if (!bTopToBottom && !bLeftToRight)
375 /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */
376 {
379 {
384
385 DestLine = DestBits;
387 {
388 SourceBits = SourceLine;
389 DestBits = DestLine;
392 {
394 BltInfo->XlateSourceToDest,
395 *((WORD *)SourceBits));
396 SourceBits += 2;
397 DestBits += 2;
398 }
401 }
402 }
403 else
404 {
411
416
419 {
420 SourceBits = SourceLine;
421 DestBits = DestLine;
424 {
426 BltInfo->XlateSourceToDest,
427 *((WORD *)SourceBits));
428 SourceBits += 2;
429 DestBits += 2;
430 }
433 }
434 }
435 }
436 else
437 {
438 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
440
441 if (bLeftToRight)
442 {
444
445 /* Allocate enough pixels for a row in WORD's */
449 {
452 }
454
455 /* This sets SourceBits to the bottom line */
459
460 /* Sets DestBits to the bottom line */
464
466 {
467 /* Set Dest32 to right pixel */
469 Source32 = (WORD *) SourceBits;
470
471 Index = 0;
472
473 /* Store pixels from left to right */
475 {
477 Index++;
478 }
479
480 Index = 0;
481
482 /* Copy stored data to pixels from right to left */
484 {
486 Index++;
487 }
488
491 }
493 TopToBottomDone = TRUE;
494 }
495
496 if (bTopToBottom)
497 {
499
500 /* Allocate enough pixels for a column in WORD's */
504 {
507 }
508
509 /* This set SourceBits to the top line */
513
514 /* This sets DestBits to the top line */
518
520 {
522 }
523
524 if (bLeftToRight)
525 {
527 DestBits += 2;
528 }
529
530 /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
531 * and have already completed the bLeftToRight. So we will lose our first flip output
532 * unless we work with its output which is at the destination site. So in this case
533 * our new Source becomes the previous outputs Destination. */
534
535 if (TopToBottomDone)
536 {
537 /* This sets SourceBits to the top line */
538 SourceBits = DestBits;
539 }
540
542 {
543 /* Set Dest32 to bottom pixel */
546 Source32 = (WORD *) SourceBits;
547
548 Index = 0;
549
550 /* Store pixels from top to bottom */
552 {
555 Index++;
556 }
557
558 Index = 0;
559
560 /* Copy stored data to pixels from bottom to top */
562 {
563 *Dest32 = store[Index];
565 Index++;
566 }
567 SourceBits += 2;
568 DestBits += 2;
569 }
571 }
572
573 }
574 }
575 break;
576
578
583
584 /* This sets SourceLine to the top line */
588
589 if (bTopToBottom)
590 {
591 /* This sets SourceLine to the bottom line */
592 SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
593 }
594 DestLine = DestBits;
595
597 {
598 SourceBits = SourceLine;
599 DestBits = DestLine;
600
601 if (bLeftToRight)
602 {
603 /* This sets the SourceBits to the rightmost pixel */
605 }
607 {
608 xColor = (*(SourceBits + 2) << 0x10) +
609 (*(SourceBits + 1) << 0x08) + (*(SourceBits));
610
612 BltInfo->XlateSourceToDest, xColor);
613
614 DEC_OR_INC(SourceBits, bLeftToRight, 3);
615 DestBits += 2;
616 }
619 }
620 break;
621
625
629
630 if (bTopToBottom)
631 {
632 /* This sets SourceLine to the bottom line */
634 }
635 DestLine = DestBits;
636
638 {
639 SourceBits = SourceLine;
640 DestBits = DestLine;
641
642 if (bLeftToRight)
643 {
644 /* This sets SourceBits to the rightmost pixel */
646 }
647
649 {
651 BltInfo->XlateSourceToDest,
652 *((PDWORD) SourceBits));
653 DEC_OR_INC(SourceBits, bLeftToRight, 4);
654 DestBits += 2;
655 }
656
659 }
660 break;
661
662 default:
666 }
667
669}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
Definition: rect.c:81
◆ DIB_16BPP_ColorFill()
Definition at line 673 of file dib16bpp.c.
674{
675 LONG DestY;
676
677 /* Make WellOrdered with top < bottom and left < right */
678 RECTL_vMakeWellOrdered(DestRect);
679
680#if defined(_M_IX86) && !defined(_MSC_VER)
681 /* This is about 10% faster than the generic C code below */
684 PULONG pos = (PULONG) ((PBYTE)DestSurface->pvScan0 + DestRect->top * delta + (DestRect->left<<1));
687
689 {
690 __asm__ __volatile__ (
691 "cld\n\t"
692 "mov %1,%%ebx\n\t"
693 "mov %2,%%edi\n\t"
694 "test $0x03, %%edi\n\t" /* Align to fullword boundary */
695 "jz 1f\n\t"
696 "stosw\n\t"
697 "dec %%ebx\n\t"
698 "jz 2f\n"
699 "1:\n\t"
700 "mov %%ebx,%%ecx\n\t" /* Setup count of fullwords to fill */
701 "shr $1,%%ecx\n\t"
702 "rep stosl\n\t" /* The actual fill */
703 "test $0x01, %%ebx\n\t" /* One left to do at the right side? */
704 "jz 2f\n\t"
705 "stosw\n"
706 "2:"
707 :
709 : "%ecx", "%ebx", "%edi");
711 }
712#else /* _M_IX86 */
713
715 {
717 }
718#endif
720}
VOID DIB_16BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
Definition: dib16bpp.c:38
__asm__(".p2align 4, 0x90\n" ".seh_proc __seh2_global_filter_func\n" "__seh2_global_filter_func:\n" "\tsub %rbp, %rax\n" "\tpush %rbp\n" "\t.seh_pushreg %rbp\n" "\tsub $32, %rsp\n" "\t.seh_stackalloc 32\n" "\t.seh_endprologue\n" "\tsub %rax, %rdx\n" "\tmov %rdx, %rbp\n" "\tjmp *%r8\n" "__seh2_global_filter_func_exit:\n" "\t.p2align 4\n" "\tadd $32, %rsp\n" "\tpop %rbp\n" "\tret\n" "\t.seh_endproc")
◆ DIB_16BPP_GetPixel()
Definition at line 30 of file dib16bpp.c.
31{
35}
Referenced by DIB_16BPP_AlphaBlend(), and DIB_1BPP_BitBltSrcCopy().
◆ DIB_16BPP_HLine()
Definition at line 38 of file dib16bpp.c.
39{
41
42#if defined(_M_IX86) && !defined(_MSC_VER)
43 /* This is about 10% faster than the generic C code below */
45
46 __asm__ __volatile__ (
47 " cld\n"
48 " mov %0, %%eax\n"
49 " shl $16, %%eax\n"
50 " andl $0xffff, %0\n" /* If the pixel value is "abcd", put "abcdabcd" in %eax */
51 " or %0, %%eax\n"
52 " mov %2, %%edi\n"
53 " test $0x03, %%edi\n" /* Align to fullword boundary */
54 " jz 0f\n"
55 " stosw\n"
56 " dec %1\n"
57 " jz 1f\n"
58 "0:\n"
59 " mov %1,%%ecx\n" /* Setup count of fullwords to fill */
60 " shr $1,%%ecx\n"
61 " rep stosl\n" /* The actual fill */
62 " test $0x01, %1\n" /* One left to do at the right side? */
63 " jz 1f\n"
64 " stosw\n"
65 "1:\n"
66 : /* no output */
68 : "%eax", "%ecx", "%edi");
69#else /* _M_IX86 */
72
74 {
76 cx++;
78 }
81 {
83 cx += 2;
84 }
86 {
88 }
89#endif /* _M_IX86 */
90}
Referenced by DIB_16BPP_ColorFill().
◆ DIB_16BPP_PutPixel()
◆ DIB_16BPP_TransparentBlt()
| BOOLEAN DIB_16BPP_TransparentBlt | ( | SURFOBJ * | DestSurf, |
| SURFOBJ * | SourceSurf, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| XLATEOBJ * | ColorTranslation, | ||
| ULONG | iTransColor | ||
| ) |
Definition at line 723 of file dib16bpp.c.
726{
729
730 LONG DstHeight;
731 LONG DstWidth;
732 LONG SrcHeight;
733 LONG SrcWidth;
734
739
742 (DestRect->left << 1) +
745
747 {
750 {
751 Dest = *DestBits;
752
754 if (SourceX >= 0 && SourceY >= 0 &&
756 {
759 {
760 Dest &= 0xFFFF0000;
762 }
763 }
764
766 if (SourceX >= 0 && SourceY >= 0 &&
768 {
771 {
772 Dest &= 0xFFFF;
774 }
775 }
776
777 *DestBits = Dest;
778 }
779
781 {
783 if (SourceX >= 0 && SourceY >= 0 &&
785 {
788 {
790 Source);
791 }
792 }
793
795 }
796
798 }
799
801}
Definition: rawriter_test.cpp:12
#define Y(I)
#define X(b, s)
_In_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ RECTL _In_ RECTL _In_ ULONG iTransColor
Definition: winddi.h:4195
◆ DIB_16BPP_VLine()
Definition at line 94 of file dib16bpp.c.
95{
96#if defined(_M_IX86) && !defined(_MSC_VER)
97 asm volatile(
98 " testl %2, %2" "\n\t"
99 " jle 2f" "\n\t"
100 " movl %2, %%ecx" "\n\t"
101 " shrl $2, %2" "\n\t"
102 " andl $3, %%ecx" "\n\t"
103 " jz 1f" "\n\t"
104 "0:" "\n\t"
105 " movw %%ax, (%0)" "\n\t"
106 " addl %1, %0" "\n\t"
107 " decl %%ecx" "\n\t"
108 " jnz 0b" "\n\t"
109 " testl %2, %2" "\n\t"
110 " jz 2f" "\n\t"
111 "1:" "\n\t"
112 " movw %%ax, (%0)" "\n\t"
113 " addl %1, %0" "\n\t"
114 " movw %%ax, (%0)" "\n\t"
115 " addl %1, %0" "\n\t"
116 " movw %%ax, (%0)" "\n\t"
117 " addl %1, %0" "\n\t"
118 " movw %%ax, (%0)" "\n\t"
119 " addl %1, %0" "\n\t"
120 " decl %2" "\n\t"
121 " jnz 1b" "\n\t"
122 "2:" "\n\t"
123 : /* no output */
126 : "cc", "memory", "%ecx");
127#else
131
134 {
136
137 byteaddr += lDelta;
139 }
140#endif
141}
◆ DIB_1BPP_BitBlt()
Definition at line 367 of file dib1bpp.c.
368{
369 LONG DestX, DestY;
370 LONG SourceX, SourceY;
371 LONG PatternY = 0;
374 BOOLEAN UsesSource;
375 BOOLEAN UsesPattern;
376 PULONG DestBits;
377 LONG RoundedRight;
378
381
385
386 if (UsesPattern)
387 {
389 {
392 }
393 else
394 {
395 /* FIXME: Shouldn't it be expanded? */
398 }
399 }
400
402 {
405 DestBits = (PULONG)(
409
410 if (DestX & 31)
411 {
412#if 0
413 /* FIXME: This case is completely untested!!! */
414
415 Dest = *((PBYTE)DestBits);
416 NoBits = 31 - (DestX & 31);
417
418 if (UsesSource)
419 {
420 Source = 0;
421 /* FIXME: This is incorrect! */
423 Source |= (DIB_GetSource(SourceSurf, SourceX + Index, SourceY, ColorTranslation) << (31 - Index));
424 }
425
427 {
428 Pattern = 0;
430 Pattern |= (DIB_GetSourceIndex(PatternObj, (X + BrushOrigin.x + k) % PatternWidth, PatternY) << (31 - k));
431 }
432
434 Dest &= ~((1 << (31 - NoBits)) - 1);
435 Dest |= *((PBYTE)DestBits) & ((1 << (31 - NoBits)) - 1);
436
437 *DestBits = Dest;
438
439 DestX += NoBits;
440 SourceX += NoBits;
441#endif
442 }
443
444 for (; DestX < RoundedRight; DestX += 32, DestBits++, SourceX += 32)
445 {
446 Dest = *DestBits;
447
448 if (UsesSource)
449 {
450 Source = 0;
452 {
453 Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index, SourceY, BltInfo->XlateSourceToDest) << (7 - Index);
454 Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 8, SourceY, BltInfo->XlateSourceToDest) << (8 + (7 - Index));
455 Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 16, SourceY, BltInfo->XlateSourceToDest) << (16 + (7 - Index));
456 Source |= DIB_GetSource(BltInfo->SourceSurface, SourceX + Index + 24, SourceY, BltInfo->XlateSourceToDest) << (24 + (7 - Index));
457 }
458 }
459
461 {
462 Pattern = 0;
464 {
465 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << (7 - Index);
466 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 8) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << (8 + (7 - Index));
467 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 16) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << (16 + (7 - Index));
468 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + Index + 24) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << (24 + (7 - Index));
469 }
470 }
471
473 }
474
475 if (DestX < BltInfo->DestRect.right)
476 {
478 {
480
481 if (UsesSource)
482 {
484 }
485
487 {
488 Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY);
489 }
490
491 DIB_1BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
492 }
493 }
494
495 SourceY++;
497 {
498 PatternY++;
500 }
501 }
502
504}
VOID DIB_1BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib1bpp.c:19
◆ DIB_1BPP_BitBltSrcCopy()
Definition at line 159 of file dib1bpp.c.
160{
163 BOOLEAN bTopToBottom, bLeftToRight;
164
165 // This sets sy to the top line
167
168 DPRINT("DIB_1BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
171 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
172
173 /* Get back left to right flip here */
175
176 /* Check for top to bottom flip needed. */
178
179 // Make WellOrdered with top < bottom and left < right
181
184
186 {
190
193 bTopToBottom, bLeftToRight );
194
198
199 if (bTopToBottom)
200 {
201 // This sets sy to the bottom line
203 }
204
206 {
208
209 if (bLeftToRight)
210 {
211 // This sets the sx to the rightmost pixel
213 }
214
216 {
217 Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
219
220 DEC_OR_INC(sx, bLeftToRight, 1);
221 }
222 DEC_OR_INC(sy, bTopToBottom, 1);
223 }
224 break;
225
231
232 if (bTopToBottom)
233 {
234 // This sets sy to the bottom line
236 }
237
239 {
241
242 if (bLeftToRight)
243 {
244 // This sets sx to the rightmost pixel
246 }
247
249 {
250 Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_8BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
252
253 DEC_OR_INC(sx, bLeftToRight, 1);
254 }
255 DEC_OR_INC(sy, bTopToBottom, 1);
256 }
257 break;
258
264
265 if (bTopToBottom)
266 {
267 // This sets sy to the bottom line
269 }
270
272 {
274
275 if (bLeftToRight)
276 {
277 // This sets the sx to the rightmost pixel
279 }
280
282 {
283 Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_16BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
285 DEC_OR_INC(sx, bLeftToRight, 1);
286 }
287 DEC_OR_INC(sy, bTopToBottom, 1);
288 }
289 break;
290
292
297
298 if (bTopToBottom)
299 {
300 // This sets sy to the bottom line
302 }
303
305 {
307
308 if (bLeftToRight)
309 {
310 // This sets the sx to the rightmost pixel
312 }
313
315 {
316 Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_24BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
318 DEC_OR_INC(sx, bLeftToRight, 1);
319 }
320 DEC_OR_INC(sy, bTopToBottom, 1);
321 }
322 break;
323
325
330
331 if (bTopToBottom)
332 {
333 // This sets sy to the bottom line
335 }
336
338 {
340
341 if (bLeftToRight)
342 {
343 // This sets the sx to the rightmost pixel
345 }
346
348 {
349 Color = XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_32BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
351 DEC_OR_INC(sx, bLeftToRight, 1);
352 }
353 DEC_OR_INC(sy, bTopToBottom, 1);
354 }
355 break;
356
357 default:
358 DbgPrint("DIB_1BPP_BitBlt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
360 }
361
363}
static BOOLEAN DIB_1BPP_BitBltSrcCopy_From1BPP(SURFOBJ *DestSurf, SURFOBJ *SourceSurf, XLATEOBJ *pxlo, PRECTL DestRect, POINTL *SourcePoint, BOOLEAN bTopToBottom, BOOLEAN bLeftToRight)
Definition: dib1bpp.c:59
Definition: gdipluscolor.h:301
◆ DIB_1BPP_ColorFill()
Definition at line 508 of file dib1bpp.c.
509{
510 LONG DestY;
511
512 /* Make WellOrdered with top < bottom and left < right */
513 RECTL_vMakeWellOrdered(DestRect);
514
516 {
518 }
520}
VOID DIB_1BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
Definition: dib1bpp.c:38
◆ DIB_1BPP_GetPixel()
Definition at line 30 of file dib1bpp.c.
31{
33
35}
Referenced by DIB_16BPP_BitBltSrcCopy(), DIB_1BPP_BitBlt(), DIB_1BPP_BitBltSrcCopy_From1BPP(), DIB_24BPP_BitBltSrcCopy(), DIB_32BPP_BitBltSrcCopy(), DIB_4BPP_BitBltSrcCopy(), and DIB_8BPP_BitBltSrcCopy().
◆ DIB_1BPP_HLine()
Definition at line 38 of file dib1bpp.c.
Referenced by DIB_1BPP_ColorFill(), and IntGdiCreateMaskFromRLE().
◆ DIB_1BPP_PutPixel()
Definition at line 19 of file dib1bpp.c.
20{
22
25 else
27}
Referenced by DIB_1BPP_BitBlt(), DIB_1BPP_BitBltSrcCopy(), DIB_1BPP_BitBltSrcCopy_From1BPP(), DIB_1BPP_HLine(), and DIB_1BPP_VLine().
◆ DIB_1BPP_TransparentBlt()
◆ DIB_1BPP_VLine()
◆ DIB_24BPP_AlphaBlend()
| BOOLEAN DIB_24BPP_AlphaBlend | ( | SURFOBJ * | Dest, |
| SURFOBJ * | Source, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| CLIPOBJ * | ClipRegion, | ||
| XLATEOBJ * | ColorTranslation, | ||
| BLENDOBJ * | BlendObj | ||
| ) |
Definition at line 725 of file dib24bpp.c.
728{
733 UCHAR Alpha;
734 //UCHAR SrcBpp;
735
739
742 {
745 }
747 {
750 }
752 {
755 }
758 {
761 }
762
764 (DestRect->left * 3));
765 //SrcBpp = BitsPerFormat(Source->iBitmapFormat);
766
767 Rows = 0;
768 SrcY = SourceRect->top;
770 {
771 Cols = 0;
772 SrcX = SourceRect->left;
774 {
780 {
782 }
783 else
784 {
786 }
787
794 SrcX = SourceRect->left + (Cols*(SourceRect->right - SourceRect->left))/(DestRect->right - DestRect->left);
795 }
797 (DestRect->left*3));
798 SrcY = SourceRect->top + (Rows*(SourceRect->bottom - SourceRect->top))/(DestRect->bottom - DestRect->top);
799 }
800
802}
◆ DIB_24BPP_BitBlt()
Definition at line 485 of file dib24bpp.c.
486{
487 LONG DestX, DestY;
488 LONG SourceX, SourceY;
489 LONG PatternY = 0;
491 BOOL UsesSource;
492 BOOL UsesPattern;
493 PBYTE DestBits;
494
497
499 DestBits = (PBYTE)(
503
504 if (UsesPattern)
505 {
507 {
510 }
511 else
512 {
514 {
516 }
517 }
518 }
519
521 {
523
524 for (DestX = BltInfo->DestRect.left; DestX < BltInfo->DestRect.right; DestX++, DestBits += 3, SourceX++)
525 {
526 Dest = *((PUSHORT)DestBits) + (*(DestBits + 2) << 16);
527
528 if (UsesSource)
529 {
531 }
532
534 {
535 Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX - BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY);
536 }
537
539 *(PUSHORT)(DestBits) = Dest & 0xFFFF;
540 *(DestBits + 2) = (BYTE)(Dest >> 16);
541 }
542
543 SourceY++;
545 {
546 PatternY++;
548 }
551 }
552
554}
◆ DIB_24BPP_BitBltSrcCopy()
Definition at line 54 of file dib24bpp.c.
55{
57 PBYTE SourceBits, DestBits, SourceLine, DestLine;
58 PBYTE SourceBits_4BPP, SourceLine_4BPP;
59 PWORD SourceBits_16BPP, SourceLine_16BPP;
60 BOOLEAN bTopToBottom, bLeftToRight;
61
62 DPRINT("DIB_24BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
65 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
66
67 /* Get back left to right flip here */
69
70 /* Check for top to bottom flip needed. */
72
75
76 /* Make WellOrdered by making top < bottom and left < right */
78
79 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left * 3;
80
82 {
85
86 /* This sets sy to the top line */
88
89 if (bTopToBottom)
90 {
91 /* This sets sy to the bottom line */
93 }
94
96 {
98
99 if (bLeftToRight)
100 {
101 /* This sets sx to the rightmost pixel */
103 }
104
106 {
108 {
110 } else {
112 }
113 DEC_OR_INC(sx, bLeftToRight, 1);
114 }
115 DEC_OR_INC(sy, bTopToBottom, 1);
116 }
117 break;
118
122
123 /* This sets SourceBits_4BPP to the top line */
124 SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1);
125
126 if (bTopToBottom)
127 {
128 /* This sets SourceBits_4BPP to the bottom line */
129 SourceBits_4BPP += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
130 }
131
133 {
134 SourceLine_4BPP = SourceBits_4BPP;
135 DestLine = DestBits;
137
138 if (bLeftToRight)
139 {
140 /* This sets sx to the rightmost pixel */
142 }
143
144 f1 = sx & 1;
145
147 {
150 *DestLine++ = xColor & 0xff;
152 DestLine += 2;
154 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
155 f1 = 0;
156 }
157 else
158 {
159 f1 = 1;
160 }
161 DEC_OR_INC(sx, bLeftToRight, 1);
162 }
165 }
166 break;
167
171
172 /* This sets SourceLine to the top line */
173 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
174
175 if (bTopToBottom)
176 {
177 /* This sets SourceLine to the bottom line */
178 SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
179 }
180 DestLine = DestBits;
181
183 {
184 SourceBits = SourceLine;
185 DestBits = DestLine;
186
187 if (bLeftToRight)
188 {
189 /* This sets the SourceBits to the rightmost pixel */
191 }
192
194 {
196 *DestBits = xColor & 0xff;
198 DEC_OR_INC(SourceBits, bLeftToRight, 1);
199 DestBits += 3;
200 }
201
204 }
205 break;
206
210
211 /* This sets SourceBits_16BPP to the top line */
212 SourceBits_16BPP = (PWORD)((PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x);
213
214 if (bTopToBottom)
215 {
216 /* This sets SourceBits_16BPP to the bottom line */
217 SourceBits_16BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;
218 }
219
221 {
222 SourceLine_16BPP = SourceBits_16BPP;
223 DestLine = DestBits;
224
225 if (bLeftToRight)
226 {
227 /* This sets the SourceLine_16BPP to the rightmost pixel */
229 }
230
232 {
234 *DestLine++ = xColor & 0xff;
236 DestLine += 2;
237 DEC_OR_INC(SourceLine_16BPP, bLeftToRight, 1);
238 }
239 if (bTopToBottom)
240 {
242 }
243 else
244 {
246 }
248 }
249 break;
250
254
255 /* Check for no flips here because we are about to use RtlMoveMemory and it can only do increasing src & dst */
258 (!bTopToBottom && !bLeftToRight))
259 {
262 {
263 /* This sets SourceBits to the top line */
264 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x;
266 {
270 }
271 }
272 else
273 {
274 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x;
275 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + 3 * BltInfo->DestRect.left;
277 {
281 }
282 }
283 }
284 else
285 {
287
288 if (!bTopToBottom && !bLeftToRight)
289 /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */
290 {
293
295 {
298 {
300 DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, pixel));
301 sx++;
302 }
303 sy++;
304 }
305 }
306 else
307 {
308 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
310
311 if (bLeftToRight)
312 {
315
316 /* Allocate enough pixels for a row in DWORD's */
320 {
323 }
324
326 /* This sets sy to the top line */
328
329 /* This sets sx to the rightmost pixel */
331
333 {
334
335 /* This sets sx to the rightmost pixel */
337
338 Index = 0;
339
340 // Read right to left and store
342 {
344 Index++;
345 sx--;
346 }
347
348 Index = 0;
349
350 // Write left to right to pixel
352 {
353 DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, store[Index]));
354 Index++;
355 }
356 sy++;
357 }
359 TopToBottomDone = TRUE;
360 }
361
362 if (bTopToBottom)
363 {
366
367 /* Allocate enough pixels for a column in DWORD's */
371 {
374 }
375
376 /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
377 * and have already completed the bLeftToRight. So we will lose our first flip output
378 * unless we work with its output which is at the destination site. So in this case
379 * our new Source becomes the previous outputs Destination.
380 */
381
382 if (TopToBottomDone)
383 {
386
387 /* This sets sy to the bottom line */
389 }
390 else
391 {
393
394 /* This sets sy to the top line */
396
397 /* This sets sy to the bottom line */
399 }
400
402 {
403
404 /* This sets sy to the bottom line */
406 Index = 0;
407
408 /* Read bottom to top and store */
410 {
411 if (TopToBottomDone)
412 {
414 }
415 else
416 {
418 }
419 Index++;
420 sy--;
421 }
422
423 Index = 0;
424
426 {
427 DIB_24BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, store[Index]));
428 Index++;
429 }
430 sx++;
431 }
433 }
434
435 }
436 }
437 break;
438
442
443 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x;
444
445 if (bTopToBottom)
446 {
447 /* This sets SourceLine to the bottom line */
449 }
450 DestLine = DestBits;
451
453 {
454 SourceBits = SourceLine;
455 DestBits = DestLine;
456
457 if (bLeftToRight)
458 {
459 /* This sets SourceBits to the rightmost pixel */
461 }
463 {
465 *DestBits = xColor & 0xff;
467 DEC_OR_INC(SourceBits, bLeftToRight, 4);
468 DestBits += 3;
469 }
470
473 }
474 break;
475
476 default:
477 DbgPrint("DIB_24BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
479 }
480
482}
VOID DIB_24BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib24bpp.c:21
ULONG DIB_24BPP_GetPixel(SURFOBJ *SurfObj, LONG x, LONG y)
Definition: dib24bpp.c:29
◆ DIB_24BPP_ColorFill()
Definition at line 558 of file dib24bpp.c.
559{
560 LONG DestY;
561
562 /* Make WellOrdered by making top < bottom and left < right */
563 RECTL_vMakeWellOrdered(DestRect);
564
565#if defined(_M_IX86) && !defined(_MSC_VER)
566 PBYTE xaddr = (PBYTE)DestSurface->pvScan0 + DestRect->top * DestSurface->lDelta + (DestRect->left << 1) + DestRect->left;
570
572 {
573 Count = xCount;
574 addr = xaddr;
576
578 {
579 /* For small fills, don't bother doing anything fancy */
581 {
583 addr += 2;
585 addr += 1;
586 }
587 }
588 else
589 {
590 /* Align to 4-byte address */
592 {
594 addr += 2;
596 addr += 1;
597 Count--;
598 }
599 /* If the color we need to fill with is 0ABC, then the final mem pattern
600 * (note little-endianness) would be:
601 *
602 * |C.B.A|C.B.A|C.B.A|C.B.A| <- pixel borders
603 * |C.B.A.C|B.A.C.B|A.C.B.A| <- ULONG borders
604 *
605 * So, taking endianness into account again, we need to fill with these
606 * ULONGs: CABC BCAB ABCA */
607
608 /* This is about 30% faster than the generic C code below */
609 __asm__ __volatile__ (
610 "movl %1, %%ecx\n\t"
611 "andl $0xffffff, %%ecx\n\t" /* 0ABC */
612 "movl %%ecx, %%ebx\n\t" /* Construct BCAB in ebx */
613 "shrl $8, %%ebx\n\t"
614 "movl %%ecx, %%eax\n\t"
615 "shll $16, %%eax\n\t"
616 "orl %%eax, %%ebx\n\t"
617 "movl %%ecx, %%edx\n\t" /* Construct ABCA in edx */
618 "shll $8, %%edx\n\t"
619 "movl %%ecx, %%eax\n\t"
620 "shrl $16, %%eax\n\t"
621 "orl %%eax, %%edx\n\t"
622 "movl %%ecx, %%eax\n\t" /* Construct CABC in eax */
623 "shll $24, %%eax\n\t"
624 "orl %%ecx, %%eax\n\t"
625 "movl %2, %%ecx\n\t" /* Load count */
626 "shr $2, %%ecx\n\t"
627 "movl %3, %%edi\n" /* Load dest */
628 "1:\n\t"
629 "movl %%eax, (%%edi)\n\t" /* Store 4 pixels, 12 bytes */
630 "movl %%ebx, 4(%%edi)\n\t"
631 "movl %%edx, 8(%%edi)\n\t"
632 "addl $12, %%edi\n\t"
633 "dec %%ecx\n\t"
634 "jnz 1b\n\t"
635 "movl %%edi, %0"
638 : "%eax", "%ebx", "%ecx", "%edx", "%edi");
641 {
643 addr += 2;
645 addr += 1;
646 }
647 }
648 }
649#else
650
652 {
654 }
655#endif
657}
◆ DIB_24BPP_GetPixel()
Definition at line 29 of file dib24bpp.c.
30{
33}
Referenced by DIB_1BPP_BitBltSrcCopy(), and DIB_24BPP_BitBltSrcCopy().
◆ DIB_24BPP_HLine()
Definition at line 16 of file dib24bppc.c.
17{
20
22 {
23 /* For small fills, don't bother doing anything fancy */
25 {
27 addr += 2;
29 addr += 1;
30 }
31 }
32 else
33 {
35 ULONG MultiCount;
36
37 /* Align to 4-byte address */
39 {
41 addr += 2;
43 addr += 1;
44 Count--;
45 }
46 /* If the color we need to fill with is 0ABC, then the final mem pattern
47 * (note little-endianness) would be:
48 *
49 * |C.B.A|C.B.A|C.B.A|C.B.A| <- pixel borders
50 * |C.B.A.C|B.A.C.B|A.C.B.A| <- ULONG borders
51 *
52 * So, taking endianness into account again, we need to fill with these
53 * ULONGs: CABC BCAB ABCA */
54
59 MultiCount = Count / 4;
60 do
61 {
63 addr += 4;
65 addr += 4;
67 addr += 4;
68 }
69 while (0 != --MultiCount);
70
73 {
75 addr += 2;
77 addr += 1;
78 }
79 }
80}
Referenced by DIB_24BPP_ColorFill().
◆ DIB_24BPP_PutPixel()
◆ DIB_24BPP_TransparentBlt()
| BOOLEAN DIB_24BPP_TransparentBlt | ( | SURFOBJ * | DestSurf, |
| SURFOBJ * | SourceSurf, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| XLATEOBJ * | ColorTranslation, | ||
| ULONG | iTransColor | ||
| ) |
Definition at line 660 of file dib24bpp.c.
663{
666 BYTE *DestBits;
667
668 LONG DstHeight;
669 LONG DstWidth;
670 LONG SrcHeight;
671 LONG SrcWidth;
672
677
679 (DestRect->left * 3) +
682
684 {
687 {
689 if (SourceX >= 0 && SourceY >= 0 &&
691 {
694 {
696 *(PUSHORT)(DestBits) = Dest & 0xFFFF;
697 *(DestBits + 2) = (BYTE)(Dest >> 16);
698 }
699 }
700 }
701
703 }
704
706}
◆ DIB_24BPP_VLine()
Definition at line 38 of file dib24bpp.c.
◆ DIB_32BPP_AlphaBlend()
| BOOLEAN DIB_32BPP_AlphaBlend | ( | SURFOBJ * | Dest, |
| SURFOBJ * | Source, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| CLIPOBJ * | ClipRegion, | ||
| XLATEOBJ * | ColorTranslation, | ||
| BLENDOBJ * | BlendObj | ||
| ) |
Definition at line 763 of file dib32bpp.c.
766{
771 UCHAR Alpha, SrcBpp;
772
776
779 {
782 }
784 {
787 }
789 {
792 }
795 {
798 }
799
801 (DestRect->left << 2));
803
804 Rows = 0;
805 SrcY = SourceRect->top;
807 {
808 Cols = 0;
809 SrcX = SourceRect->left;
811 {
816 SrcPixel.col.alpha = (32 == SrcBpp) ?
819
822
829 SrcX = SourceRect->left + (Cols*(SourceRect->right - SourceRect->left))/(DestRect->right - DestRect->left);
830 }
832 (DestRect->left << 2));
833 SrcY = SourceRect->top + (Rows*(SourceRect->bottom - SourceRect->top))/(DestRect->bottom - DestRect->top);
834 }
835
837}
◆ DIB_32BPP_BitBlt()
◆ DIB_32BPP_BitBltSrcCopy()
Definition at line 54 of file dib32bpp.c.
55{
57 PBYTE SourceBits, DestBits, SourceLine, DestLine;
58 PBYTE SourceBitsT, SourceBitsB, DestBitsT, DestBitsB;
59 PBYTE SourceBits_4BPP, SourceLine_4BPP;
60 PDWORD Source32, Dest32;
62 LONG DestWidth, DestHeight;
63 BOOLEAN bTopToBottom, bLeftToRight;
64 BOOLEAN blDeltaSrcNeg, blDeltaDestNeg;
66
68 "DestSurface cx/cy (%d/%d) DestRect: (%d,%d)-(%d,%d)\n",
72 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
73
76
77 DPRINT("iBitmapFormat is %d and width,height is (%d,%d).\n", BltInfo->SourceSurface->iBitmapFormat,
78 BltInfo->DestRect.right - BltInfo->DestRect.left, BltInfo->DestRect.bottom - BltInfo->DestRect.top);
79
82
83 /* Do not deal with negative numbers for these values */
87
88 /* Detect negative lDelta's meaning Bottom-Up bitmaps */
91
92 /* Get back left to right flip here */
94
95 /* Check for top to bottom flip needed. */
97
98 DPRINT("bTopToBottom is '%d' and DestSurface->lDelta < 0 is '%d' and SourceSurface->lDelta < 0 is '%d'.\n",
99 bTopToBottom, BltInfo->DestSurface->lDelta < 0 ? 1 : 0, BltInfo->SourceSurface->lDelta < 0 ? 1 : 0);
100
101 /* Make WellOrdered with top < bottom and left < right */
103
106
110
111 DPRINT("iBitmapFormat is %d and width,height is (%d,%d).\n", BltInfo->SourceSurface->iBitmapFormat,
112 DestWidth, DestHeight);
113
115 {
118 DestWidth);
119
120 if (bLeftToRight || bTopToBottom)
122
124
125 /* This sets sy to the top line */
127
128 if (bTopToBottom)
129 {
130 /* This sets sy to the bottom line */
132 }
133
135 {
137
138 if (bLeftToRight)
139 {
140 /* This sets the sx to the rightmost pixel */
141 sx += (DestWidth - 1);
142 }
143
145 {
147 {
149 }
150 else
151 {
153 }
154
155 DEC_OR_INC(sx, bLeftToRight, 1);
156 }
157 DEC_OR_INC(sy, bTopToBottom, 1);
158 }
159 break;
160
163 DestWidth);
164
165 if (bLeftToRight || bTopToBottom)
167
168 /* This sets SourceBits_4BPP to the top line */
172
173 if (bTopToBottom)
174 {
175 /* This sets SourceBits_4BPP to the bottom line */
177 }
178
180 {
181 SourceLine_4BPP = SourceBits_4BPP;
183
184 if (bLeftToRight)
185 {
186 /* This sets sx to the rightmost pixel */
187 sx += (DestWidth - 1);
188 }
189
190 f1 = sx & 1;
191
193 {
198 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
199 f1 = 0;
200 } else {
201 f1 = 1;
202 }
203 DEC_OR_INC(sx, bLeftToRight, 1);
204 }
206 }
207 break;
208
211 DestWidth);
212
213 if (bLeftToRight || bTopToBottom)
215
216 /* This sets SourceLine to the top line */
220 DestLine = DestBits;
221
222 if (bTopToBottom)
223 {
224 /* This sets SourceLine to the bottom line */
226 }
227
229 {
230 SourceBits = SourceLine;
231 DestBits = DestLine;
232
233 if (bLeftToRight)
234 {
235 /* This sets the SourceBits to the rightmost pixel */
236 SourceBits += (DestWidth - 1);
237 }
238
240 {
241 xColor = *SourceBits;
243 DEC_OR_INC(SourceBits, bLeftToRight, 1);
244 DestBits += 4;
245 }
248 }
249 break;
250
253 DestWidth);
254
255 if (bLeftToRight || bTopToBottom)
257
258 /* This sets SourceLine to the top line */
262 DestLine = DestBits;
263
264 if (bTopToBottom)
265 {
266 /* This sets SourceLine to the bottom line */
268 }
269
271 {
272 SourceBits = SourceLine;
273 DestBits = DestLine;
274
275 if (bLeftToRight)
276 {
277 /* This sets the SourceBits to the rightmost pixel */
278 SourceBits += (DestWidth - 1) * 2;
279 }
280
282 {
283 xColor = *((PWORD) SourceBits);
285 DEC_OR_INC(SourceBits, bLeftToRight, 2);
286 DestBits += 4;
287 }
288
291 }
292 break;
293
296 DestWidth);
297
298 if (bLeftToRight || bTopToBottom)
300
301 /* This sets SourceLine to the top line */
305
306 if (bTopToBottom)
307 {
308 /* This sets SourceLine to the bottom line */
310 }
311
312 DestLine = DestBits;
313
315 {
316 SourceBits = SourceLine;
317 DestBits = DestLine;
318
319 if (bLeftToRight)
320 {
321 /* This sets the SourceBits to the rightmost pixel */
322 SourceBits += (DestWidth - 1) * 3;
323 }
324
326 {
327 xColor = (*(SourceBits + 2) << 0x10) +
328 (*(SourceBits + 1) << 0x08) +
329 (*(SourceBits));
331 DEC_OR_INC(SourceBits, bLeftToRight, 3);
332 DestBits += 4;
333 }
334
337 }
338 break;
339
341 DPRINT("32BPP Case Selected with SourcePoint (%d,%d) and DestRect Width/height of '%d/%d' DestRect: (%d,%d)-(%d,%d).\n",
343 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
344
345 if (bLeftToRight || bTopToBottom)
347
348 /* This handles the negative lDelta's which represent Top-to-Bottom bitmaps */
349 if (((blDeltaSrcNeg || blDeltaDestNeg) && !(blDeltaSrcNeg && blDeltaDestNeg)) && bTopToBottom)
350 {
353 {
354 /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */
359 {
360 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
363 }
364 }
365 else
366 {
367 /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
371 /* DestBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
376 {
377 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
380 }
381 }
382 blDeltaAdjustDone = TRUE;
383 }
384
385 /* This tests for whether we can use simplified/quicker code below.
386 * It works for increasing source and destination areas only and there is no overlap and no flip.
387 */
390 (!bTopToBottom && !bLeftToRight))
391 {
393
395 {
396 /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */
401 {
402 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
405 }
406 }
407 else
408 {
409 /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
414 /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
419 {
420 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
423 }
424 }
425 }
426 else
427 {
429
430 if (!bTopToBottom && !bLeftToRight)
431 {
433 {
438 {
440 {
441 Dest32 = (DWORD *) DestBits;
442 Source32 = (DWORD *) SourceBits;
444 {
446 }
447 }
448 else
449 {
450 Dest32 = (DWORD *) DestBits + (DestWidth - 1);
451 Source32 = (DWORD *) SourceBits + (DestWidth - 1);
453 {
455 }
456 }
459 }
460 }
461 else
462 {
471 {
473 {
474 Dest32 = (DWORD *) DestBits;
475 Source32 = (DWORD *) SourceBits;
477 {
479 }
480 }
481 else
482 {
483 Dest32 = (DWORD *) DestBits + (DestWidth - 1);
484 Source32 = (DWORD *) SourceBits + (DestWidth - 1);
486 {
488 }
489 }
492 }
493 }
494 }
495 else
496 {
497 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
499
500 /* No need to flip a LeftToRight bitmap only one pixel wide */
501 if ((bLeftToRight) && (DestWidth > 1))
502 {
504
505 /* Allocate enough pixels for a row in DWORD's */
507 (DestWidth + 1) * 4, TAG_DIB);
509 {
512 }
513
514 /* This sets SourceBits to the bottom line */
518
519 /* This sets DestBits to the bottom line */
523
525 {
526
527 /* Set Dest32 to right pixel */
528 Dest32 = (DWORD *) DestBits + (DestWidth - 1);
529 Source32 = (DWORD *) SourceBits;
530
531 Index = 0;
532
533 /* Store pixels from left to right */
535 {
536 store[Index] = *Source32++;
537 Index++;
538 }
539
540 Index = 0;
541
542 /* Copy stored dat to pixels from right to left */
544 {
545 *Dest32-- = store[Index];
546 Index++;
547 }
550 }
552 TopToBottomDone = TRUE;
553 }
554
555 /* Top to Botoom Handling if bitmap more than one pixel high */
556 if ((bTopToBottom) && (DestHeight > 1))
557 {
558 /* Note: It is very important that this code remain optimized for time used.
559 * Otherwise you will have random crashes in ReactOS that are undesirable.
560 * For an example of this just try executing the code here two times.
561 */
562
564
565 /* Allocate enough pixels for a row in DWORD's */
567 (DestWidth + 1) * 4, TAG_DIB);
569 {
572 }
573
574 /* This set DestBitsT to the top line */
578
579 /* This sets DestBitsB to the bottom line */
583
584 /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
585 * and have already completed the bLeftToRight. So we will lose our first flip output
586 * unless we work with its output which is at the destination site. So in this case
587 * our new Source becomes the previous outputs Destination.
588 * Also in we use the same logic when we have corrected for negative lDelta's above
589 * and already completed a flip from Source to Destination for the first step
590 */
591
592 if (TopToBottomDone || blDeltaAdjustDone)
593 {
594 /* This sets SourceBitsB to the bottom line */
595 SourceBitsB = DestBitsB;
596
597 /* This sets SourceBitsT to the top line */
598 SourceBitsT = DestBitsT;
599 }
600 else
601 {
602 /* This sets SourceBitsB to the bottom line */
606
607 /* This sets SourceBitsT to the top line */
610 }
611
612 /* Overlaps and Vertical flips do not mix well. So we test for this and handle it
613 * by using two operations. First we just do a copy of the source to the destination.
614 * Then we do a flip in place at the destination location and we are done.
615 */
617 (abs(BltInfo->SourcePoint.y - BltInfo->DestRect.top) < (DestHeight + 2)) && // they are NOT separated by > DestHeight
618 (BltInfo->SourceSurface->pvScan0 == BltInfo->DestSurface->pvScan0)) // and same surface (probably screen)
619 {
621
623 {
624 /* SourceBits points to top-left pixel for lDelta < 0 and bottom-left for lDelta > 0 */
629 {
630 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
633 }
634 }
635 else
636 {
637 /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
642 /* SourceBits points to bottom-left pixel for lDelta < 0 and top-left for lDelta > 0 */
647 {
648 RtlMoveMemory(DestBits, SourceBits, 4 * DestWidth);
651 }
652 }
653
654 /* This sets SourceBitsB to the bottom line */
655 SourceBitsB = DestBitsB;
656
657 /* This sets SourceBitsT to the top line */
658 SourceBitsT = DestBitsT;
659 }
660
661 /* Vertical Flip code starts here */
663 {
664 /* Store bottom row of Source pixels */
665 RtlMoveMemory(store, SourceBitsB, 4 * DestWidth);
666
667 /* Copy top Source row to bottom Destination row overwriting it */
668 RtlMoveMemory(DestBitsB, SourceBitsT, 4 * DestWidth);
669
670 /* Copy stored bottom row of Source pixels to Destination top row of pixels */
671 RtlMoveMemory(DestBitsT, store, 4 * DestWidth);
672
673 /* Index top rows down and bottom rows up */
676
679 }
680 if (DestHeight % 2)
681 {
682 /* If we had an odd number of lines we handle the center one here */
684 RtlMoveMemory(DestBitsB, SourceBitsT, 4 * DestWidth);
685 }
687 }
688 }
689 }
690 break;
691
692 default:
693 DPRINT1("DIB_32BPP_BitBltSrcCopy: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
695 }
696
698}
VOID DIB_32BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib32bpp.c:21
◆ DIB_32BPP_ColorFill()
Definition at line 31 of file dib32bppc.c.
32{
33 ULONG DestY;
34
35 /* Make WellOrdered by making top < bottom and left < right */
36 RECTL_vMakeWellOrdered(DestRect);
37
39 {
41 }
42
44}
VOID DIB_32BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
Definition: dib32bppc.c:16
◆ DIB_32BPP_GetPixel()
◆ DIB_32BPP_HLine()
◆ DIB_32BPP_PutPixel()
◆ DIB_32BPP_TransparentBlt()
| BOOLEAN DIB_32BPP_TransparentBlt | ( | SURFOBJ * | DestSurf, |
| SURFOBJ * | SourceSurf, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| XLATEOBJ * | ColorTranslation, | ||
| ULONG | iTransColor | ||
| ) |
◆ DIB_32BPP_VLine()
Definition at line 39 of file dib32bpp.c.
◆ DIB_4BPP_BitBlt()
Definition at line 368 of file dib4bpp.c.
369{
370 LONG DestX, DestY;
371 LONG SourceX, SourceY;
372 LONG PatternY = 0;
374 BOOLEAN UsesSource;
375 BOOLEAN UsesPattern;
376 PULONG DestBits;
377 LONG RoundedRight;
379 {
380 0x00000000 /* 0 */,
381 0x11111111 /* 1 */,
382 0x22222222 /* 2 */,
383 0x33333333 /* 3 */,
384 0x44444444 /* 4 */,
385 0x55555555 /* 5 */,
386 0x66666666 /* 6 */,
387 0x77777777 /* 7 */,
388 0x88888888 /* 8 */,
389 0x99999999 /* 9 */,
390 0xAAAAAAAA /* 10 */,
391 0xBBBBBBBB /* 11 */,
392 0xCCCCCCCC /* 12 */,
393 0xDDDDDDDD /* 13 */,
394 0xEEEEEEEE /* 14 */,
395 0xFFFFFFFF /* 15 */,
396 };
397
400
404
405 if (UsesPattern)
406 {
408 {
411 }
412 else
413 {
416 }
417 }
418
420 {
421 DestBits = (PULONG)(
427
428 if (DestX & 0x1)
429 {
431
432 if (UsesSource)
433 {
435 }
436
438 {
441 }
442
443 DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
444
445 DestX++;
446 SourceX++;
448 }
449
450 for (; DestX < RoundedRight; DestX += 8, SourceX += 8, DestBits++)
451 {
452 Dest = *DestBits;
453 if (UsesSource)
454 {
455 Source =
457 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 0, SourceY, BltInfo->XlateSourceToDest) << 4) |
458 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 3, SourceY, BltInfo->XlateSourceToDest) << 8) |
459 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 2, SourceY, BltInfo->XlateSourceToDest) << 12) |
460 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 5, SourceY, BltInfo->XlateSourceToDest) << 16) |
461 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 4, SourceY, BltInfo->XlateSourceToDest) << 20) |
462 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 7, SourceY, BltInfo->XlateSourceToDest) << 24) |
463 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 6, SourceY, BltInfo->XlateSourceToDest) << 28);
464 }
466 {
467 Pattern = DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 1) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY);
468 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 0) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 4;
469 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 3) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 8;
470 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 2) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 12;
471 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 5) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 16;
472 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 4) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 20;
473 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 7) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 24;
474 Pattern |= DIB_GetSourceIndex(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 6) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY) << 28;
475 }
477 }
478
479 /* Process the rest of pixel on the line */
481 {
483 if (UsesSource)
484 {
486 }
488 {
491 }
492 DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
493 }
494
495 SourceY++;
497 {
498 PatternY++;
500 }
501 }
502
504}
VOID DIB_4BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib4bpp.c:19
◆ DIB_4BPP_BitBltSrcCopy()
Definition at line 63 of file dib4bpp.c.
64{
66 PBYTE SourceBits_24BPP, SourceLine_24BPP;
67 PBYTE DestBits, DestLine, SourceBits_8BPP, SourceLine_8BPP;
68 PBYTE SourceBits, SourceLine;
69 BOOLEAN bTopToBottom, bLeftToRight;
70
71 DPRINT("DIB_4BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
74 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
75
76 /* Get back left to right flip here */
78
79 /* Check for top to bottom flip needed. */
81
82 /* Make WellOrdered with top < bottom and left < right */
84
87
91
93 {
97
99
100 /* This sets sy to the top line */
102
103 if (bTopToBottom)
104 {
105 /* This sets sy to the bottom line */
107 }
108
110 {
112
113 if (bLeftToRight)
114 {
115 /* This sets the sx to the rightmost pixel */
117 }
118
120 {
122 {
124 }
125 else
126 {
128 }
129 DEC_OR_INC(sx, bLeftToRight, 1);
130 }
131 DEC_OR_INC(sy, bTopToBottom, 1);
132 }
133 break;
134
138
139 /* This sets sy to the top line */
141
142 if (bTopToBottom)
143 {
144 /* This sets sy to the bottom line */
147 }
148
150 {
152
153 if (bLeftToRight)
154 {
155 /* This sets the sx to the rightmost pixel */
157 }
158
160 {
162 {
166 }
167 else
168 {
171 }
172 DEC_OR_INC(sx, bLeftToRight, 1);
173 }
174 DEC_OR_INC(sy, bTopToBottom, 1);
175 }
176 break;
177
183
186
187 if (bTopToBottom)
188 {
189 /* This sets SourceBits to the bottom line */
193 }
194
196 {
197 SourceLine_8BPP = SourceBits_8BPP;
198 DestLine = DestBits;
199
200 if (bLeftToRight)
201 {
202 /* This sets SourceBits_8BPP to the rightmost pixel */
204 }
205
207
209 {
213 DEC_OR_INC(SourceLine_8BPP, bLeftToRight, 1);
214 }
217 }
218 break;
219
223
228
232
233 if (bTopToBottom)
234 {
235 /* This sets SourceLine to the bottom line */
238 }
239
240 DestLine = DestBits;
241
243 {
244 SourceBits = SourceLine;
245
246 if (bLeftToRight)
247 {
248 /* This sets SourceBits to the rightmost pixel */
250 }
251
252 DestBits = DestLine;
254
256 {
257 xColor = *((PWORD) SourceBits);
261
262 DEC_OR_INC(SourceBits, bLeftToRight, 2);
263 }
264
267 }
268 break;
269
271
276
280
281 if (bTopToBottom)
282 {
283 /* This sets SourceLine to the bottom line */
286 }
287
289 {
290 SourceLine_24BPP = SourceBits_24BPP;
291 DestLine = DestBits;
293
294 if (bLeftToRight)
295 {
296 /* This sets the SourceBits_24BPP to the rightmost pixel */
298 }
299
301 {
302 xColor = (*(SourceLine_24BPP + 2) << 0x10) +
303 (*(SourceLine_24BPP + 1) << 0x08) +
304 (*(SourceLine_24BPP));
308 DEC_OR_INC(SourceLine_24BPP, bLeftToRight, 3);
309 }
312 }
313 break;
314
318
322
323 if (bTopToBottom)
324 {
325 /* This sets SourceLine to the bottom line */
327 }
328
329 DestLine = DestBits;
330
332 {
333 SourceBits = SourceLine;
334 DestBits = DestLine;
335
336 if (bLeftToRight)
337 {
338 /* This sets SourceBits to the rightmost pixel */
340 }
341
343
345 {
346 xColor = *((PDWORD) SourceBits);
350
351 DEC_OR_INC(SourceBits, bLeftToRight, 4);
352 }
353
356 }
357 break;
358
359 default:
363 }
365}
◆ DIB_4BPP_ColorFill()
Definition at line 508 of file dib4bpp.c.
509{
510 LONG DestY;
511
512 /* Make WellOrdered by making top < bottom and left < right */
513 RECTL_vMakeWellOrdered(DestRect);
514
516 {
518 }
520}
VOID DIB_4BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
Definition: dib4bpp.c:33
◆ DIB_4BPP_GetPixel()
Definition at line 26 of file dib4bpp.c.
27{
30}
Referenced by DIB_1BPP_BitBltSrcCopy(), DIB_4BPP_BitBlt(), and DIB_4BPP_BitBltSrcCopy().
◆ DIB_4BPP_HLine()
Definition at line 33 of file dib4bpp.c.
Referenced by DIB_4BPP_ColorFill().
◆ DIB_4BPP_PutPixel()
◆ DIB_4BPP_TransparentBlt()
◆ DIB_4BPP_VLine()
◆ DIB_8BPP_BitBlt()
◆ DIB_8BPP_BitBltSrcCopy()
Definition at line 59 of file dib8bpp.c.
60{
62 PBYTE SourceBits, DestBits, SourceLine, DestLine;
63 PBYTE SourceBits_4BPP, SourceLine_4BPP;
64 BOOLEAN bTopToBottom, bLeftToRight;
65
66 DPRINT("DIB_8BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
69 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
70
71 /* Get back left to right flip here */
73
74 /* Check for top to bottom flip needed. */
76
78
79 /* Make WellOrdered by making top < bottom and left < right */
81
84
85 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
86
88 {
92
94
95 /* This sets sy to the top line */
97
98 if (bTopToBottom)
99 {
100 /* This sets sy to the bottom line */
102 }
103
105 {
107
108 if (bLeftToRight)
109 {
110 /* This sets the sx to the rightmost pixel */
112 }
113
115 {
117 {
119 }
120 else
121 {
123 }
124 DEC_OR_INC(sx, bLeftToRight, 1);
125 }
126 DEC_OR_INC(sy, bTopToBottom, 1);
127 }
128 break;
129
133
134 /* This sets SourceBits_4BPP to the top line */
135 SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1);
136
137 if (bTopToBottom)
138 {
139 /* This sets SourceBits_4BPP to the bottom line */
140 SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;
141 }
142
144 {
145 SourceLine_4BPP = SourceBits_4BPP;
147
148 if (bLeftToRight)
149 {
150 /* This sets sx to the rightmost pixel */
152 }
153
154 f1 = sx & 1;
155
157 {
162 {
163 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
164 f1 = 0;
165 }
166 else
167 {
168 f1 = 1;
169 }
170
171 DEC_OR_INC(sx, bLeftToRight, 1);
172 }
174 }
175 break;
176
182
185 (!bTopToBottom && !bLeftToRight))
186 {
188 {
190 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
192 {
196 }
197 }
198 else
199 {
201 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
202 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
204 {
208 }
209 }
210 }
211 else
212 {
214
215 if (!bTopToBottom && !bLeftToRight)
216 /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */
217 {
219 {
221 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
222 DestLine = DestBits;
224 {
225 SourceBits = SourceLine;
226 DestBits = DestLine;
228 {
230 }
233 }
234 }
235 else
236 {
238 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
239 DestLine = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
241 {
242 SourceBits = SourceLine;
243 DestBits = DestLine;
245 {
247 }
250 }
251 }
252 }
253 else
254 {
255 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
257
258 if (bLeftToRight)
259 {
261
262 /* Allocate enough pixels for a row in BYTE's */
266 {
269 }
271
272 /* This sets SourceLine to the top line */
277
278 /* This set the DestLine to the top line */
282
284 {
285 SourceBits = SourceLine;
286 DestBits = DestLine;
287
288 /* This sets SourceBits to the rightmost pixel */
290
291 Index = 0;
292
294 {
296 BltInfo->XlateSourceToDest,
297 *SourceBits);
298 SourceBits--;
299 Index++;
300 }
301
302 Index = 0;
303
305 {
306 *DestBits = store[Index];
307 DestBits++;
308 Index++;
309 }
310
313 }
315 OneDone = TRUE;
316 }
317
318 if (bTopToBottom)
319 {
321
323
324 /* Allocate enough pixels for a column in BYTE's */
328 {
331 }
332
333 /* The OneDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
334 * and have already completed the bLeftToRight. So we will lose our first flip output
335 * unless we work with its output which is at the destination site. So in this case
336 * our new Source becomes the previous outputs Destination. */
337
338 if (OneDone)
339 {
340 /* This sets SourceLine to the bottom line of our previous destination */
344 }
345 else
346 {
347 /* This sets SourceLine to the bottom line */
352 }
353
354 /* This set the DestLine to the top line */
358
359 /* Read columns */
361 {
362
363 DestBits = DestLine;
364 SourceBits = SourceLine;
365
366 Index = 0;
367
368 /* Read up the column and store the pixels */
370 {
372 /* Go up a line */
374 Index++;
375 }
376
377 Index = 0;
378
379 /* Get the stored pixel and copy then down the column */
381 {
382 *DestBits = store[Index];
383 /* Go down a line */
385 Index++;
386 }
387 /* Index to next column */
388 SourceLine += 1;
389 DestLine += 1;
390 }
392 }
393
394 }
395 }
396 break;
397
401
406
407 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x;
408
409 if (bTopToBottom)
410 {
411 /* This sets SourceLine to the bottom line */
412 SourceLine += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;;
413 }
414 DestLine = DestBits;
415
417 {
418 SourceBits = SourceLine;
419
420 if (bLeftToRight)
421 {
422 /* This sets SourceBits to the rightmost pixel */
424 }
425 DestBits = DestLine;
426
428 {
429 xColor = *((PWORD) SourceBits);
431
432 DEC_OR_INC(SourceBits, bLeftToRight, 2);
433 DestBits += 1;
434 }
437 }
438 break;
439
445
446 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x;
447 DestLine = DestBits;
448
449 if (bTopToBottom)
450 {
451 /* This sets SourceLine to the bottom line */
452 SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
453 }
454
456 {
457 SourceBits = SourceLine;
458 DestBits = DestLine;
459
460 if (bLeftToRight)
461 {
462 /* This sets the SourceBits to the rightmost pixel */
464 }
465
467 {
468 xColor = (*(SourceBits + 2) << 0x10) +
469 (*(SourceBits + 1) << 0x08) +
470 (*(SourceBits));
472 DEC_OR_INC(SourceBits, bLeftToRight, 3);
473 DestBits += 1;
474 }
477 }
478 break;
479
483
484 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x;
485
486 if (bTopToBottom)
487 {
488 /* This sets SourceLine to the bottom line */
490 }
491 DestLine = DestBits;
492
494 {
495 SourceBits = SourceLine;
496 DestBits = DestLine;
497
498 if (bLeftToRight)
499 {
500 /* This sets SourceBits to the rightmost pixel */
502 }
503
505 {
506 xColor = *((PDWORD) SourceBits);
508
509 DEC_OR_INC(SourceBits, bLeftToRight, 4);
510 DestBits += 1;
511 }
514 }
515 break;
516
517 default:
518 DPRINT1("DIB_8BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
520 }
521
523}
VOID DIB_8BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib8bpp.c:21
◆ DIB_8BPP_ColorFill()
Definition at line 527 of file dib8bpp.c.
528{
529 LONG DestY;
530
531 /* Make WellOrdered by making top < bottom and left < right */
532 RECTL_vMakeWellOrdered(DestRect);
533
535 {
537 }
539}
VOID DIB_8BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
Definition: dib8bpp.c:37
◆ DIB_8BPP_GetPixel()
◆ DIB_8BPP_HLine()
◆ DIB_8BPP_PutPixel()
◆ DIB_8BPP_TransparentBlt()
| BOOLEAN DIB_8BPP_TransparentBlt | ( | SURFOBJ * | DestSurf, |
| SURFOBJ * | SourceSurf, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| XLATEOBJ * | ColorTranslation, | ||
| ULONG | iTransColor | ||
| ) |
Definition at line 543 of file dib8bpp.c.
546{
549
550 LONG DstHeight;
551 LONG DstWidth;
552 LONG SrcHeight;
553 LONG SrcWidth;
554
559
563
565 {
570 {
571 Dest = *DestBits;
572
574 if (SourceX >= 0 && SourceY >= 0 &&
576 {
579 {
580 Dest &= 0xFFFFFF00;
582 }
583 }
584
586 if (SourceX >= 0 && SourceY >= 0 &&
588 {
591 {
592 Dest &= 0xFFFF00FF;
594 }
595 }
596
598 if (SourceX >= 0 && SourceY >= 0 &&
600 {
603 {
604 Dest &= 0xFF00FFFF;
606 }
607 }
608
610 if (SourceX >= 0 && SourceY >= 0 &&
612 {
615 {
616 Dest &= 0x00FFFFFF;
618 }
619 }
620
621 *DestBits = Dest;
622 }
623
625 {
627 {
629 if (SourceX >= 0 && SourceY >= 0 &&
631 {
634 {
636 }
637 }
639 }
640 }
641 }
642
644}
◆ DIB_8BPP_VLine()
◆ DIB_DoRop()
Definition at line 92 of file dib.c.
93{
94 ULONG ResultNibble;
98 {
99 0x55555555 /* 0000 */,
100 0x555555AA /* 0001 */,
101 0x5555AA55 /* 0010 */,
102 0x5555AAAA /* 0011 */,
103 0x55AA5555 /* 0100 */,
104 0x55AA55AA /* 0101 */,
105 0x55AAAA55 /* 0110 */,
106 0x55AAAAAA /* 0111 */,
107 0xAA555555 /* 1000 */,
108 0xAA5555AA /* 1001 */,
109 0xAA55AA55 /* 1010 */,
110 0xAA55AAAA /* 1011 */,
111 0xAAAA5555 /* 1100 */,
112 0xAAAA55AA /* 1101 */,
113 0xAAAAAA55 /* 1110 */,
114 0xAAAAAAAA /* 1111 */,
115 };
117 {
118 0x33333333 /* 0000 */,
119 0x333333CC /* 0001 */,
120 0x3333CC33 /* 0010 */,
121 0x3333CCCC /* 0011 */,
122 0x33CC3333 /* 0100 */,
123 0x33CC33CC /* 0101 */,
124 0x33CCCC33 /* 0110 */,
125 0x33CCCCCC /* 0111 */,
126 0xCC333333 /* 1000 */,
127 0xCC3333CC /* 1001 */,
128 0xCC33CC33 /* 1010 */,
129 0xCC33CCCC /* 1011 */,
130 0xCCCC3333 /* 1100 */,
131 0xCCCC33CC /* 1101 */,
132 0xCCCCCC33 /* 1110 */,
133 0xCCCCCCCC /* 1111 */,
134 };
136 {
137 0x0F0F0F0F /* 0000 */,
138 0x0F0F0FF0 /* 0001 */,
139 0x0F0FF00F /* 0010 */,
140 0x0F0FF0F0 /* 0011 */,
141 0x0FF00F0F /* 0100 */,
142 0x0FF00FF0 /* 0101 */,
143 0x0FF0F00F /* 0110 */,
144 0x0FF0F0F0 /* 0111 */,
145 0xF00F0F0F /* 1000 */,
146 0xF00F0FF0 /* 1001 */,
147 0xF00FF00F /* 1010 */,
148 0xF00FF0F0 /* 1011 */,
149 0xF0F00F0F /* 1100 */,
150 0xF0F00FF0 /* 1101 */,
151 0xF0F0F00F /* 1110 */,
152 0xF0F0F0F0 /* 1111 */,
153 };
154
155 Rop &=0xFF;
156 switch(Rop)
157 {
158
159 /* Optimized code for the various named rop codes. */
176 }
177
178 /* Expand the ROP operation to all four bytes */
179 Rop |= (Rop << 24) | (Rop << 16) | (Rop << 8);
180 /* Do the operation on four bits simultaneously. */
181 Result = 0;
183 {
184 ResultNibble = Rop & ExpandDest[Dest & 0xF] & ExpandSource[Source & 0xF] & ExpandPattern[Pattern & 0xF];
185 Result |= (((ResultNibble & 0xFF000000) ? 0x8 : 0x0) | ((ResultNibble & 0x00FF0000) ? 0x4 : 0x0) |
186 ((ResultNibble & 0x0000FF00) ? 0x2 : 0x0) | ((ResultNibble & 0x000000FF) ? 0x1 : 0x0)) << (i * 4);
187 Dest >>= 4;
188 Source >>= 4;
189 Pattern >>= 4;
190 }
192}
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by BltMask(), DIB_1BPP_BitBlt(), DIB_24BPP_BitBlt(), DIB_4BPP_BitBlt(), and DIB_XXBPP_StretchBlt().
◆ DIB_XXBPP_AlphaBlend()
| BOOLEAN DIB_XXBPP_AlphaBlend | ( | SURFOBJ * | Dest, |
| SURFOBJ * | Source, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| CLIPOBJ * | ClipRegion, | ||
| XLATEOBJ * | ColorTranslation, | ||
| BLENDOBJ * | BlendObj | ||
| ) |
Definition at line 33 of file alphablend.c.
36{
37 INT DstX, DstY, SrcX, SrcY;
42 EXLATEOBJ* pexlo;
43 EXLATEOBJ exloSrcRGB, exloDstRGB, exloRGBSrc;
45
49
52 {
55 }
57 {
60 }
62 {
65 }
67 SrcBpp != 32)
68 {
71 }
72
73 if (!ColorTranslation)
74 {
77 }
78
83
84 SrcY = SourceRect->top;
85 DstY = DestRect->top;
87 {
88 SrcX = SourceRect->left;
89 DstX = DestRect->left;
91 {
96
100
103 DstPixel32.col.green = Clamp8((DstPixel32.col.green * (255 - Alpha)) / 255 + SrcPixel32.col.green) ;
104 DstPixel32.col.blue = Clamp8((DstPixel32.col.blue * (255 - Alpha)) / 255 + SrcPixel32.col.blue) ;
107
108 DstX++;
111 }
112 DstY++;
115 }
116
117 EXLATEOBJ_vCleanup(&exloDstRGB);
118 EXLATEOBJ_vCleanup(&exloRGBSrc);
119 EXLATEOBJ_vCleanup(&exloSrcRGB);
120
122}
◆ DIB_XXBPP_FloodFillSolid()
| BOOLEAN DIB_XXBPP_FloodFillSolid | ( | SURFOBJ * | DstSurf, |
| BRUSHOBJ * | Brush, | ||
| RECTL * | DstRect, | ||
| POINTL * | Origin, | ||
| ULONG | ConvColor, | ||
| UINT | FillType | ||
| ) |
Definition at line 86 of file floodfill.c.
92{
94 ULONG BrushColor;
96
97 BrushColor = Brush->iSolidColor;
100
102 {
103 /* Check if the start pixel has the border color */
104 if (DibFunctionsForBitmapFormat[DstSurf->iBitmapFormat].DIB_GetPixel(DstSurf, x, y) == ConvColor)
105 {
107 }
108
110 {
112 }
115 {
118 removeItemFlood(&flood);
119
122 {
124 finalizeFlood(&flood);
126 }
131 }
132 finalizeFlood(&flood);
133 }
135 {
136 /* Check if the start pixel has the surface color */
137 if (DibFunctionsForBitmapFormat[DstSurf->iBitmapFormat].DIB_GetPixel(DstSurf, x, y) != ConvColor)
138 {
140 }
141
143 {
145 }
148 {
151 removeItemFlood(&flood);
152
155 {
157 finalizeFlood(&flood);
159 }
164 }
165 finalizeFlood(&flood);
166 }
167 else
168 {
171 }
173}
Definition: gdiplusbrush.h:23
static __inline VOID addItemFlood(FLOODINFO *info, ULONG x, ULONG y, SURFOBJ *DstSurf, RECTL *DstRect, ULONG Color, BOOL isSurf)
Definition: floodfill.c:54
Definition: floodfill.c:31
Referenced by NtGdiExtFloodFill().
◆ DIB_XXBPP_StretchBlt()
| BOOLEAN DIB_XXBPP_StretchBlt | ( | SURFOBJ * | DestSurf, |
| SURFOBJ * | SourceSurf, | ||
| SURFOBJ * | MaskSurf, | ||
| SURFOBJ * | PatternSurface, | ||
| RECTL * | DestRect, | ||
| RECTL * | SourceRect, | ||
| POINTL * | MaskOrigin, | ||
| BRUSHOBJ * | Brush, | ||
| POINTL * | BrushOrigin, | ||
| XLATEOBJ * | ColorTranslation, | ||
| ROP4 | ROP | ||
| ) |
Definition at line 17 of file stretchblt.c.
23{
24 LONG sx = 0;
25 LONG sy = 0;
26 LONG DesX;
27 LONG DesY;
28
29 LONG DstHeight;
30 LONG DstWidth;
31 LONG SrcHeight;
32 LONG SrcWidth;
33 LONG MaskCy;
34 LONG SourceCy;
35
38 ULONG xxBPPMask;
39 BOOLEAN CanDraw;
40
46
47 LONG PatternX = 0, PatternY = 0;
48
51 BOOLEAN bTopToBottom, bLeftToRight;
52
54
57
59 BitsPerFormat(DestSurf->iBitmapFormat), DestRect->left, DestRect->top, DestRect->right, DestRect->bottom);
60
65
66 /* Here we do the tests and set our conditions */
67 if (((SrcWidth < 0) && (DstWidth < 0)) || ((SrcWidth >= 0) && (DstWidth >= 0)))
68 bLeftToRight = FALSE;
69 else
70 bLeftToRight = TRUE;
71
72 if (((SrcHeight < 0) && (DstHeight < 0)) || ((SrcHeight >= 0) && (DstHeight >= 0)))
73 bTopToBottom = FALSE;
74 else
75 bTopToBottom = TRUE;
76
77 /* Make Well Ordered to start */
78 RECTL_vMakeWellOrdered(DestRect);
79
80 if (UsesSource)
81 {
85 BitsPerFormat(SourceSurf->iBitmapFormat), SourceRect->left, SourceRect->top, SourceRect->right, SourceRect->bottom);
86 }
87
88 if (MaskSurf)
89 {
93 }
94
99
100 /* FIXME: MaskOrigin? */
101
103 {
109 default:
110 xxBPPMask = 0xFFFFFFFF;
111 }
113
114 if (UsesPattern)
115 {
117 if (PatternSurface)
118 {
120 if (PatternY < 0)
121 {
123 }
125 }
126 else
127 {
129 Pattern = Brush->iSolidColor;
130 }
131 }
132
133 if (PatternSurface)
134 {
136 }
137
139
141 {
142 if (PatternSurface)
143 {
145 if (PatternX < 0)
146 {
148 }
149 }
150 if (UsesSource)
151 {
152 if (bTopToBottom)
153 {
154 sy = SourceRect->bottom-(DesY - DestRect->top) * SrcHeight / DstHeight; // flips about the x-axis
155 }
156 else
157 {
159 }
160 }
161
163 {
164 CanDraw = TRUE;
165
166 if (fnMask_GetPixel)
167 {
168 if (bLeftToRight)
169 {
170 sx = SourceRect->right - (DesX - DestRect->left) * SrcWidth / DstWidth; // flips about the y-axis
171 }
172 else
173 {
175 }
176 if (sx < 0 || sy < 0 ||
178 fnMask_GetPixel(MaskSurf, sx, sy) != 0)
179 {
180 CanDraw = FALSE;
181 }
182 }
183
184 if (UsesSource && CanDraw)
185 {
186 if (bLeftToRight)
187 {
189 }
190 else
191 {
193 }
194 if (sx >= 0 && sy >= 0 &&
196 {
198 }
199 else
200 {
201 Source = 0;
202 CanDraw = ((ROP & 0xFF) != R3_OPINDEX_SRCCOPY);
203 }
204 }
205
206 if (CanDraw)
207 {
208 if (UsesPattern && PatternSurface)
209 {
210 Pattern = fnPattern_GetPixel(PatternSurface, PatternX, PatternY);
211 PatternX++;
213 }
214
215 Dest = fnDest_GetPixel(DestSurf, DesX, DesY);
217
218 fnDest_PutPixel(DestSurf, DesX, DesY, Color);
219 }
220 }
221
222 if (PatternSurface)
223 {
224 PatternY++;
226 }
227 }
228
230}
◆ Dummy_AlphaBlend()
◆ Dummy_BitBlt()
◆ Dummy_ColorFill()
◆ Dummy_GetPixel()
◆ Dummy_HLine()
◆ Dummy_PutPixel()
◆ Dummy_StretchBlt()
◆ Dummy_TransparentBlt()
◆ Dummy_VLine()
Variable Documentation
◆ altnotmask
Definition at line 18 of file dib.c.
Referenced by DIB_16BPP_BitBltSrcCopy(), DIB_24BPP_BitBltSrcCopy(), DIB_32BPP_BitBltSrcCopy(), and DIB_8BPP_BitBltSrcCopy().
◆ DibFunctionsForBitmapFormat
|
extern |
Definition at line 20 of file dib.c.
Referenced by addItemFlood(), AlphaBltMask(), BltMask(), BltPatCopy(), CallDibBitBlt(), CallDibStretchBlt(), DIB_XXBPP_AlphaBlend(), DIB_XXBPP_FloodFillSolid(), DIB_XXBPP_StretchBlt(), EngAlphaBlend(), EngCopyBits(), EngLineTo(), EngTransparentBlt(), FillSolid(), IntEngGradientFillRect(), NEtoSW(), NWtoSE(), SEtoNW(), and SWtoNE().
◆ notmask
Definition at line 17 of file dib.c.
Referenced by DIB_4BPP_BitBltSrcCopy(), DIB_4BPP_HLine(), DIB_4BPP_PutPixel(), and DIB_4BPP_VLine().
