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 857 of file dib16bpp.c.
860{
861 INT DstX, DstY, SrcX, SrcY;
863 NICEPIXEL32 SrcPixel32;
864 UCHAR Alpha;
865 EXLATEOBJ* pexlo;
866 EXLATEOBJ exloSrcRGB;
867
871
874 {
877 }
879 {
882 }
884 {
887 }
890 {
893 }
894
895 if (!ColorTranslation)
896 {
899 }
900
903
905 {
906 NICEPIXEL16_555 DstPixel16;
907
908 SrcY = SourceRect->top;
909 DstY = DestRect->top;
911 {
912 SrcX = SourceRect->left;
913 DstX = DestRect->left;
915 {
920
924
925 Alpha >>= 3;
926
928 /* Perform bit loss */
929 SrcPixel32.col.red >>= 3;
930 SrcPixel32.col.green >>= 3;
931 SrcPixel32.col.blue >>= 3;
932
933 /* Do the blend in the right bit depth */
935 DstPixel16.col.green = Clamp5((DstPixel16.col.green * (31 - Alpha)) / 31 + SrcPixel32.col.green);
937
939
940 DstX++;
943 }
944 DstY++;
947 }
948 }
949 else
950 {
951 NICEPIXEL16_565 DstPixel16;
952 UCHAR Alpha6, Alpha5;
953
954 SrcY = SourceRect->top;
955 DstY = DestRect->top;
957 {
958 SrcX = SourceRect->left;
959 DstX = DestRect->left;
961 {
966
970
971 Alpha6 = Alpha >> 2;
972 Alpha5 = Alpha >> 3;
973
975 /* Perform bit loss */
976 SrcPixel32.col.red >>= 3;
977 SrcPixel32.col.green >>= 2;
978 SrcPixel32.col.blue >>= 3;
979
980 /* Do the blend in the right bit depth */
982 DstPixel16.col.green = Clamp6((DstPixel16.col.green * (63 - Alpha6)) / 63 + SrcPixel32.col.green);
984
986
987 DstX++;
990 }
991 DstY++;
994 }
995 }
996
997 EXLATEOBJ_vCleanup(&exloSrcRGB);
998
1000}
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:833
struct NICEPIXEL16_555::@5409 col
Definition: dib16bpp.c:822
struct NICEPIXEL16_565::@5408 col
Definition: alphablend.c:15
struct NICEPIXEL32::@5406 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 150 of file dib16bpp.c.
151{
153 PBYTE SourceBits, DestBits, SourceLine, DestLine;
154 PBYTE SourceBits_4BPP, SourceLine_4BPP;
155 PWORD Source32, Dest32;
157 BOOLEAN bTopToBottom, bLeftToRight;
158
159 DPRINT("DIB_16BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
162 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
163
164 /* Get back left to right flip here */
166
167 /* Check for top to bottom flip needed. */
169
172
173 /* Make WellOrdered with top < bottom and left < right */
175
178
179 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + 2 * BltInfo->DestRect.left;
180
182 {
187
188 /* This sets sy to the top line */
190
191 if (bTopToBottom)
192 {
193 /* This sets sy to the bottom line */
195 }
196
198 {
200
201 if (bLeftToRight)
202 {
203 /* This sets the sx to the rightmost pixel */
207 }
208 else
209 {
212 }
213
215 {
217 {
220 }
221 else
222 {
225 }
226 DEC_OR_INC(sx, bLeftToRight, 1);
227 }
228 DEC_OR_INC(sy, bTopToBottom, 1);
229 }
230 break;
231
235
236 /* This sets SourceBits_4BPP to the top line */
240
241 if (bTopToBottom)
242 {
243 /* This sets SourceBits_4BPP to the bottom line */
244 SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;
245 }
246
248 {
249 SourceLine_4BPP = SourceBits_4BPP;
251 if (bLeftToRight)
252 {
253 /* This sets sx to the rightmost pixel */
255 }
256
257 f1 = sx & 1;
258
260 {
265 {
266 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
267 f1 = 0;
268 }
269 else
270 {
271 f1 = 1;
272 }
273 DEC_OR_INC(sx, bLeftToRight, 1);
274 }
276 }
277 break;
278
282
283 /* This sets SourceLine to the top line */
287 DestLine = DestBits;
288
289 if (bTopToBottom)
290 {
291 /* This sets SourceLine to the bottom line */
294 }
295
297 {
298 SourceBits = SourceLine;
299 DestBits = DestLine;
300
301 if (bLeftToRight)
302 {
303 /* This sets SourceBits to the rightmost pixel */
305 }
306
308 {
310 BltInfo->XlateSourceToDest, *SourceBits);
311 DEC_OR_INC(SourceBits, bLeftToRight, 1);
312 DestBits += 2;
313 }
316 }
317 break;
318
322
327
330 (!bTopToBottom && !bLeftToRight))
331 {
334 {
335 /* This sets SourceBits to the top line */
340
342 {
343 RtlMoveMemory(DestBits, SourceBits,
346
349 }
350 }
351 else
352 {
353 /* This sets SourceBits to the bottom line */
359
364
367 {
368 RtlMoveMemory(DestBits, SourceBits, 2 *
371
374 }
375 }
376 }
377 else
378 {
380 if (!bTopToBottom && !bLeftToRight)
381 /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */
382 {
385 {
390
391 DestLine = DestBits;
393 {
394 SourceBits = SourceLine;
395 DestBits = DestLine;
398 {
400 BltInfo->XlateSourceToDest,
401 *((WORD *)SourceBits));
402 SourceBits += 2;
403 DestBits += 2;
404 }
407 }
408 }
409 else
410 {
417
422
425 {
426 SourceBits = SourceLine;
427 DestBits = DestLine;
430 {
432 BltInfo->XlateSourceToDest,
433 *((WORD *)SourceBits));
434 SourceBits += 2;
435 DestBits += 2;
436 }
439 }
440 }
441 }
442 else
443 {
444 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
446
447 if (bLeftToRight)
448 {
450
451 /* Allocate enough pixels for a row in WORD's */
455 {
458 }
460
461 /* This sets SourceBits to the bottom line */
465
466 /* Sets DestBits to the bottom line */
470
472 {
473 /* Set Dest32 to right pixel */
475 Source32 = (WORD *) SourceBits;
476
477 Index = 0;
478
479 /* Store pixels from left to right */
481 {
483 Index++;
484 }
485
486 Index = 0;
487
488 /* Copy stored data to pixels from right to left */
490 {
492 Index++;
493 }
494
497 }
499 TopToBottomDone = TRUE;
500 }
501
502 if (bTopToBottom)
503 {
505
506 /* Allocate enough pixels for a column in WORD's */
510 {
513 }
514
515 /* This set SourceBits to the top line */
519
520 /* This sets DestBits to the top line */
524
526 {
528 }
529
530 if (bLeftToRight)
531 {
533 DestBits += 2;
534 }
535
536 /* The TopToBottomDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
537 * and have already completed the bLeftToRight. So we will lose our first flip output
538 * unless we work with its output which is at the destination site. So in this case
539 * our new Source becomes the previous outputs Destination. */
540
541 if (TopToBottomDone)
542 {
543 /* This sets SourceBits to the top line */
544 SourceBits = DestBits;
545 }
546
548 {
549 /* Set Dest32 to bottom pixel */
552 Source32 = (WORD *) SourceBits;
553
554 Index = 0;
555
556 /* Store pixels from top to bottom */
558 {
561 Index++;
562 }
563
564 Index = 0;
565
566 /* Copy stored data to pixels from bottom to top */
568 {
569 *Dest32 = store[Index];
571 Index++;
572 }
573 SourceBits += 2;
574 DestBits += 2;
575 }
577 }
578
579 }
580 }
581 break;
582
584
589
590 /* This sets SourceLine to the top line */
594
595 if (bTopToBottom)
596 {
597 /* This sets SourceLine to the bottom line */
598 SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
599 }
600 DestLine = DestBits;
601
603 {
604 SourceBits = SourceLine;
605 DestBits = DestLine;
606
607 if (bLeftToRight)
608 {
609 /* This sets the SourceBits to the rightmost pixel */
611 }
613 {
614 xColor = (*(SourceBits + 2) << 0x10) +
615 (*(SourceBits + 1) << 0x08) + (*(SourceBits));
616
618 BltInfo->XlateSourceToDest, xColor);
619
620 DEC_OR_INC(SourceBits, bLeftToRight, 3);
621 DestBits += 2;
622 }
625 }
626 break;
627
631
635
636 if (bTopToBottom)
637 {
638 /* This sets SourceLine to the bottom line */
640 }
641 DestLine = DestBits;
642
644 {
645 SourceBits = SourceLine;
646 DestBits = DestLine;
647
648 if (bLeftToRight)
649 {
650 /* This sets SourceBits to the rightmost pixel */
652 }
653
655 {
657 BltInfo->XlateSourceToDest,
658 *((PDWORD) SourceBits));
659 DEC_OR_INC(SourceBits, bLeftToRight, 4);
660 DestBits += 2;
661 }
662
665 }
666 break;
667
668 default:
672 }
673
675}
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 679 of file dib16bpp.c.
680{
681 LONG DestY;
682
683 /* Make WellOrdered with top < bottom and left < right */
684 RECTL_vMakeWellOrdered(DestRect);
685
686#if defined(_M_IX86) && !defined(_MSC_VER)
687 /* This is about 10% faster than the generic C code below */
690 PULONG pos = (PULONG) ((PBYTE)DestSurface->pvScan0 + DestRect->top * delta + (DestRect->left<<1));
693
695 {
696 __asm__ __volatile__ (
697 "cld\n\t"
698 "mov %1,%%ebx\n\t"
699 "mov %2,%%edi\n\t"
700 "test $0x03, %%edi\n\t" /* Align to fullword boundary */
701 "jz 1f\n\t"
702 "stosw\n\t"
703 "dec %%ebx\n\t"
704 "jz 2f\n"
705 "1:\n\t"
706 "mov %%ebx,%%ecx\n\t" /* Setup count of fullwords to fill */
707 "shr $1,%%ecx\n\t"
708 "rep stosl\n\t" /* The actual fill */
709 "test $0x01, %%ebx\n\t" /* One left to do at the right side? */
710 "jz 2f\n\t"
711 "stosw\n"
712 "2:"
713 :
715 : "%ecx", "%ebx", "%edi");
717 }
718#else /* _M_IX86 */
719
721 {
723 }
724#endif
726}
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
47 return;
48
49 __asm__ __volatile__ (
50 " cld\n"
51 " mov %0, %%eax\n"
52 " shl $16, %%eax\n"
53 " andl $0xffff, %0\n" /* If the pixel value is "abcd", put "abcdabcd" in %eax */
54 " or %0, %%eax\n"
55 " mov %2, %%edi\n"
56 " test $0x03, %%edi\n" /* Align to fullword boundary */
57 " jz 0f\n"
58 " stosw\n"
59 " dec %1\n"
60 " jz 1f\n"
61 "0:\n"
62 " mov %1,%%ecx\n" /* Setup count of fullwords to fill */
63 " shr $1,%%ecx\n"
64 " rep stosl\n" /* The actual fill */
65 " test $0x01, %1\n" /* One left to do at the right side? */
66 " jz 1f\n"
67 " stosw\n"
68 "1:\n"
69 : /* no output */
71 : "%eax", "%ecx", "%edi");
72#else /* _M_IX86 */
75
77 return;
78
80 {
82 cx++;
84 }
87 {
89 cx += 2;
90 }
92 {
94 }
95#endif /* _M_IX86 */
96}
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 729 of file dib16bpp.c.
732{
735
736 LONG DstHeight;
737 LONG DstWidth;
738 LONG SrcHeight;
739 LONG SrcWidth;
740
745
748 (DestRect->left << 1) +
751
753 {
756 {
757 Dest = *DestBits;
758
760 if (SourceX >= 0 && SourceY >= 0 &&
762 {
765 {
766 Dest &= 0xFFFF0000;
768 }
769 }
770
772 if (SourceX >= 0 && SourceY >= 0 &&
774 {
777 {
778 Dest &= 0xFFFF;
780 }
781 }
782
783 *DestBits = Dest;
784 }
785
787 {
789 if (SourceX >= 0 && SourceY >= 0 &&
791 {
794 {
796 Source);
797 }
798 }
799
801 }
802
804 }
805
807}
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 100 of file dib16bpp.c.
101{
102#if defined(_M_IX86) && !defined(_MSC_VER)
103 asm volatile(
104 " testl %2, %2" "\n\t"
105 " jle 2f" "\n\t"
106 " movl %2, %%ecx" "\n\t"
107 " shrl $2, %2" "\n\t"
108 " andl $3, %%ecx" "\n\t"
109 " jz 1f" "\n\t"
110 "0:" "\n\t"
111 " movw %%ax, (%0)" "\n\t"
112 " addl %1, %0" "\n\t"
113 " decl %%ecx" "\n\t"
114 " jnz 0b" "\n\t"
115 " testl %2, %2" "\n\t"
116 " jz 2f" "\n\t"
117 "1:" "\n\t"
118 " movw %%ax, (%0)" "\n\t"
119 " addl %1, %0" "\n\t"
120 " movw %%ax, (%0)" "\n\t"
121 " addl %1, %0" "\n\t"
122 " movw %%ax, (%0)" "\n\t"
123 " addl %1, %0" "\n\t"
124 " movw %%ax, (%0)" "\n\t"
125 " addl %1, %0" "\n\t"
126 " decl %2" "\n\t"
127 " jnz 1b" "\n\t"
128 "2:" "\n\t"
129 : /* no output */
132 : "cc", "memory", "%ecx");
133#else
137
140 {
142
143 byteaddr += lDelta;
145 }
146#endif
147}
◆ 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 return;
23
25 {
26 /* For small fills, don't bother doing anything fancy */
28 {
30 addr += 2;
32 addr += 1;
33 }
34 }
35 else
36 {
38 ULONG MultiCount;
39
40 /* Align to 4-byte address */
42 {
44 addr += 2;
46 addr += 1;
47 Count--;
48 }
49 /* If the color we need to fill with is 0ABC, then the final mem pattern
50 * (note little-endianness) would be:
51 *
52 * |C.B.A|C.B.A|C.B.A|C.B.A| <- pixel borders
53 * |C.B.A.C|B.A.C.B|A.C.B.A| <- ULONG borders
54 *
55 * So, taking endianness into account again, we need to fill with these
56 * ULONGs: CABC BCAB ABCA */
57
62 MultiCount = Count / 4;
63 do
64 {
66 addr += 4;
68 addr += 4;
70 addr += 4;
71 }
72 while (0 != --MultiCount);
73
76 {
78 addr += 2;
80 addr += 1;
81 }
82 }
83}
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 62 of file dib8bpp.c.
63{
65 PBYTE SourceBits, DestBits, SourceLine, DestLine;
66 PBYTE SourceBits_4BPP, SourceLine_4BPP;
67 BOOLEAN bTopToBottom, bLeftToRight;
68
69 DPRINT("DIB_8BPP_BitBltSrcCopy: SrcSurf cx/cy (%d/%d), DestSuft cx/cy (%d/%d) dstRect: (%d,%d)-(%d,%d)\n",
72 BltInfo->DestRect.left, BltInfo->DestRect.top, BltInfo->DestRect.right, BltInfo->DestRect.bottom);
73
74 /* Get back left to right flip here */
76
77 /* Check for top to bottom flip needed. */
79
81
82 /* Make WellOrdered by making top < bottom and left < right */
84
87
88 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + (BltInfo->DestRect.top * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
89
91 {
95
97
98 /* This sets sy to the top line */
100
101 if (bTopToBottom)
102 {
103 /* This sets sy to the bottom line */
105 }
106
108 {
110
111 if (bLeftToRight)
112 {
113 /* This sets the sx to the rightmost pixel */
115 }
116
118 {
120 {
122 }
123 else
124 {
126 }
127 DEC_OR_INC(sx, bLeftToRight, 1);
128 }
129 DEC_OR_INC(sy, bTopToBottom, 1);
130 }
131 break;
132
136
137 /* This sets SourceBits_4BPP to the top line */
138 SourceBits_4BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + (BltInfo->SourcePoint.x >> 1);
139
140 if (bTopToBottom)
141 {
142 /* This sets SourceBits_4BPP to the bottom line */
143 SourceBits_4BPP += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;
144 }
145
147 {
148 SourceLine_4BPP = SourceBits_4BPP;
150
151 if (bLeftToRight)
152 {
153 /* This sets sx to the rightmost pixel */
155 }
156
157 f1 = sx & 1;
158
160 {
165 {
166 DEC_OR_INC(SourceLine_4BPP, bLeftToRight, 1);
167 f1 = 0;
168 }
169 else
170 {
171 f1 = 1;
172 }
173
174 DEC_OR_INC(sx, bLeftToRight, 1);
175 }
177 }
178 break;
179
185
188 (!bTopToBottom && !bLeftToRight))
189 {
191 {
193 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
195 {
199 }
200 }
201 else
202 {
204 SourceBits = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
205 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
207 {
211 }
212 }
213 }
214 else
215 {
217
218 if (!bTopToBottom && !bLeftToRight)
219 /* **Note: Indent is purposefully less than desired to keep reviewable differences to a minimum for PR** */
220 {
222 {
224 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
225 DestLine = DestBits;
227 {
228 SourceBits = SourceLine;
229 DestBits = DestLine;
231 {
233 }
236 }
237 }
238 else
239 {
241 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + ((BltInfo->SourcePoint.y + BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
242 DestLine = (PBYTE)BltInfo->DestSurface->pvScan0 + ((BltInfo->DestRect.bottom - 1) * BltInfo->DestSurface->lDelta) + BltInfo->DestRect.left;
244 {
245 SourceBits = SourceLine;
246 DestBits = DestLine;
248 {
250 }
253 }
254 }
255 }
256 else
257 {
258 /* Buffering for source and destination flip overlaps. Fixes KHMZ MirrorTest CORE-16642 */
260
261 if (bLeftToRight)
262 {
264
265 /* Allocate enough pixels for a row in BYTE's */
269 {
272 }
274
275 /* This sets SourceLine to the top line */
280
281 /* This set the DestLine to the top line */
285
287 {
288 SourceBits = SourceLine;
289 DestBits = DestLine;
290
291 /* This sets SourceBits to the rightmost pixel */
293
294 Index = 0;
295
297 {
299 BltInfo->XlateSourceToDest,
300 *SourceBits);
301 SourceBits--;
302 Index++;
303 }
304
305 Index = 0;
306
308 {
309 *DestBits = store[Index];
310 DestBits++;
311 Index++;
312 }
313
316 }
318 OneDone = TRUE;
319 }
320
321 if (bTopToBottom)
322 {
324
326
327 /* Allocate enough pixels for a column in BYTE's */
331 {
334 }
335
336 /* The OneDone flag indicates that we are flipping for bTopToBottom and bLeftToRight
337 * and have already completed the bLeftToRight. So we will lose our first flip output
338 * unless we work with its output which is at the destination site. So in this case
339 * our new Source becomes the previous outputs Destination. */
340
341 if (OneDone)
342 {
343 /* This sets SourceLine to the bottom line of our previous destination */
347 }
348 else
349 {
350 /* This sets SourceLine to the bottom line */
355 }
356
357 /* This set the DestLine to the top line */
361
362 /* Read columns */
364 {
365
366 DestBits = DestLine;
367 SourceBits = SourceLine;
368
369 Index = 0;
370
371 /* Read up the column and store the pixels */
373 {
375 /* Go up a line */
377 Index++;
378 }
379
380 Index = 0;
381
382 /* Get the stored pixel and copy then down the column */
384 {
385 *DestBits = store[Index];
386 /* Go down a line */
388 Index++;
389 }
390 /* Index to next column */
391 SourceLine += 1;
392 DestLine += 1;
393 }
395 }
396
397 }
398 }
399 break;
400
404
409
410 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x;
411
412 if (bTopToBottom)
413 {
414 /* This sets SourceLine to the bottom line */
415 SourceLine += (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1) * BltInfo->SourceSurface->lDelta;;
416 }
417 DestLine = DestBits;
418
420 {
421 SourceBits = SourceLine;
422
423 if (bLeftToRight)
424 {
425 /* This sets SourceBits to the rightmost pixel */
427 }
428 DestBits = DestLine;
429
431 {
432 xColor = *((PWORD) SourceBits);
434
435 DEC_OR_INC(SourceBits, bLeftToRight, 2);
436 DestBits += 1;
437 }
440 }
441 break;
442
448
449 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 3 * BltInfo->SourcePoint.x;
450 DestLine = DestBits;
451
452 if (bTopToBottom)
453 {
454 /* This sets SourceLine to the bottom line */
455 SourceLine += BltInfo->SourceSurface->lDelta * (BltInfo->DestRect.bottom - BltInfo->DestRect.top - 1);
456 }
457
459 {
460 SourceBits = SourceLine;
461 DestBits = DestLine;
462
463 if (bLeftToRight)
464 {
465 /* This sets the SourceBits to the rightmost pixel */
467 }
468
470 {
471 xColor = (*(SourceBits + 2) << 0x10) +
472 (*(SourceBits + 1) << 0x08) +
473 (*(SourceBits));
475 DEC_OR_INC(SourceBits, bLeftToRight, 3);
476 DestBits += 1;
477 }
480 }
481 break;
482
486
487 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x;
488
489 if (bTopToBottom)
490 {
491 /* This sets SourceLine to the bottom line */
493 }
494 DestLine = DestBits;
495
497 {
498 SourceBits = SourceLine;
499 DestBits = DestLine;
500
501 if (bLeftToRight)
502 {
503 /* This sets SourceBits to the rightmost pixel */
505 }
506
508 {
509 xColor = *((PDWORD) SourceBits);
511
512 DEC_OR_INC(SourceBits, bLeftToRight, 4);
513 DestBits += 1;
514 }
517 }
518 break;
519
520 default:
521 DPRINT1("DIB_8BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
523 }
524
526}
VOID DIB_8BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
Definition: dib8bpp.c:21
◆ DIB_8BPP_ColorFill()
Definition at line 530 of file dib8bpp.c.
531{
532 LONG DestY;
533
534 /* Make WellOrdered by making top < bottom and left < right */
535 RECTL_vMakeWellOrdered(DestRect);
536
538 {
540 }
542}
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 546 of file dib8bpp.c.
549{
552
553 LONG DstHeight;
554 LONG DstWidth;
555 LONG SrcHeight;
556 LONG SrcWidth;
557
562
566
568 {
573 {
574 Dest = *DestBits;
575
577 if (SourceX >= 0 && SourceY >= 0 &&
579 {
582 {
583 Dest &= 0xFFFFFF00;
585 }
586 }
587
589 if (SourceX >= 0 && SourceY >= 0 &&
591 {
594 {
595 Dest &= 0xFFFF00FF;
597 }
598 }
599
601 if (SourceX >= 0 && SourceY >= 0 &&
603 {
606 {
607 Dest &= 0xFF00FFFF;
609 }
610 }
611
613 if (SourceX >= 0 && SourceY >= 0 &&
615 {
618 {
619 Dest &= 0x00FFFFFF;
621 }
622 }
623
624 *DestBits = Dest;
625 }
626
628 {
630 {
632 if (SourceX >= 0 && SourceY >= 0 &&
634 {
637 {
639 }
640 }
642 }
643 }
644 }
645
647}
◆ 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().
