ReactOS 0.4.15-dev-5666-gc548b97
xlate.c
Go to the documentation of this file.
1
2#include <stdio.h>
3#include <windows.h>
4#include <wine/test.h>
5
6enum
7{
17};
18
19ULONG bpp[] = {1, 4, 8, 15, 16, 24, 24, 32, 32};
20
21static BYTE ajBits1[] = {0xAA, 0xAA, 0xAA, 0xAA, 0,0,0,0};
22static BYTE ajBits8[] = {0x00, 0xFF, 0x80, 0xCC, 0,0,0,0};
23static WORD ajBits16[] = {0x0000, 0xFFFF, 0x1000, 0x0C0C, 0,0,0,0};
24static DWORD ajBits24[] = {0x0000, 0xFFFF, 0x1000, 0x0C0C, 0,0,0,0};
25static DWORD ajBits32[] = {0x0000, 0xFFFF, 0x1000, 0x0C0C, 0,0,0,0};
34
37{
39 HDC hdc;
40 struct
41 {
42 BITMAPINFOHEADER bmiHeader;
43 ULONG aulMasks[3];
44 } bmi;
46 ULONG ulColorDepth;
47
48 /* Get the screen DC */
49 hdc = GetDC(NULL);
50
51 /* Create a compatible bitmap */
53
54 /* Fill BITMAPINFOHEADER */
55 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
57
58 /* Call again to fill in the bitfields */
60
61 /* Get the basic color depth */
62 ulColorDepth = bmi.bmiHeader.biBitCount;
63
65
66 switch (ulColorDepth)
67 {
68 case 1:
69 return BMF_1BPP;
70 case 4:
71 return BMF_4BPP;
72 case 8:
73 return BMF_8BPP;
74 case 16:
75 /* Check the red mask */
76 if (bmi.aulMasks[0] == 0x7c00)
77 return BMF_16BPP_555;
78 else
79 return BMF_16BPP_565;
80 case 24:
81 return BMF_4BPP;
82 case 32:
83 if (bmi.bmiHeader.biCompression == BI_BITFIELDS &&
84 bmi.aulMasks[0] == 0xff)
85 return BMF_32BPP_RGB;
86 else
87 return BMF_32BPP_BGR;
88 }
89
90 /* Cleanup and return */
91 return BMF_32BPP_RGB;
92}
93
94static
97{
98 ULONG ulRed, ulGreen, ulBlue;
99
100 ulRed = GetRValue(crColor);
101 ulGreen = GetGValue(crColor);
102 ulBlue = GetBValue(crColor);
103
104 switch (iFormat)
105 {
106 case BMF_1BPP:
107 return crColor ? 0xffffff : 0;
108
109 case BMF_4BPP:
110 case BMF_8BPP:
111 case BMF_16BPP_555:
112 ulRed = (ulRed & 0xF8) >> 3;
113 ulGreen = (ulGreen & 0xF8) >> 3;
114 ulBlue = (ulBlue & 0xF8) >> 3;
115 return ulRed << 10 | ulGreen << 5 | ulBlue;
116
117 case BMF_16BPP_565:
118 ulRed = (ulRed & 0xF8) >> 3;
119 ulGreen = (ulGreen & 0xFC) >> 2;
120 ulBlue = (ulBlue & 0xF8) >> 3;
121 return ulRed << 11 | ulGreen << 5 | ulBlue;
122
123 case BMF_24BPP_RGB:
124 case BMF_32BPP_RGB:
125 return crColor;
126
127 case BMF_24BPP_BGR:
128 case BMF_32BPP_BGR:
129 return RGB(ulBlue, ulGreen, ulRed);
130 }
131 return 0;
132}
133
134static
137{
138 ULONG ulRed, ulGreen, ulBlue;
139
140 switch (iFormat)
141 {
142 case BMF_1BPP:
143 return ulColor ? 0xffffff : 0;
144
145 case BMF_4BPP:
146 case BMF_8BPP:
147 case BMF_16BPP_555:
148 ulRed = (ulColor & 0x7C00) >> 7;
149 ulRed |= ulRed >> 5;
150 ulGreen = (ulColor & 0x3E0) >> 2;
151 ulGreen |= ulGreen >> 5;
152 ulBlue = (ulColor & 0x1F) << 3;
153 ulBlue |= ulBlue >> 5;
154 return RGB(ulRed, ulGreen, ulBlue);
155
156 case BMF_16BPP_565:
157 ulRed = (ulColor & 0xF800) >> 8;
158 ulRed |= ulRed >> 5;
159 ulGreen = (ulColor & 0x7E0) >> 3;
160 ulGreen |= ulGreen >> 6;
161 ulBlue = (ulColor & 0x1F) << 3;
162 ulBlue |= ulBlue >> 5;
163 return RGB(ulRed, ulGreen, ulBlue);
164
165 case BMF_24BPP_RGB:
166 case BMF_32BPP_RGB:
167 return ulColor;
168
169 case BMF_24BPP_BGR:
170 case BMF_32BPP_BGR:
171 ulRed = GetRValue(ulColor);
172 ulGreen = GetGValue(ulColor);
173 ulBlue = GetBValue(ulColor);
174 return RGB(ulBlue, ulGreen, ulRed);
175 }
176 return 0;
177}
178
179static
180ULONG
182{
183 if (iFormat == BMF_1BPP)
184 return crBackColor;
185 return iXlateToRGB(iFormat, iXlateFromRGB(iFormat, crColor));
186}
187
188ULONG
190{
191 switch (iFormat)
192 {
193 case BMF_1BPP:
194 //
195 case BMF_16BPP_555:
196 case BMF_16BPP_565:
197 return *(WORD*)((PCHAR)pvBits + x * sizeof(WORD));
198
199 case BMF_24BPP_RGB:
200 case BMF_24BPP_BGR:
201 return (*(DWORD*)((PCHAR)pvBits + x * 3)) & 0xffffff;
202
203 case BMF_32BPP_RGB:
204 case BMF_32BPP_BGR:
205 return *(DWORD*)((PCHAR)pvBits + x * sizeof(DWORD));
206 }
207 return 0;
208}
209
210static
211void
213{
216
218 ok(hbmpCompat != 0, "CreateCompatibleBitmap failed\n");
219
221 printf("got iDcFormat = %ld\n", iDcFormat);
222
223 hbmp1bpp_a = CreateBitmap(4, 2, 1, 1, ajBits1);
224 ok(hbmp1bpp_a != 0, "CreateBitmap failed\n");
225
226 hbmp1bpp_b = CreateBitmap(4, 2, 1, 1, ajBits1);
227 ok(hbmp1bpp_b != 0, "CreateBitmap failed\n");
228
229 hbmp8bpp_a = CreateBitmap(4, 2, 1, 8, ajBits8);
230 ok(hbmp8bpp_a != 0, "CreateBitmap failed\n");
231
232 hbmp8bpp_b = CreateBitmap(4, 2, 1, 8, ajBits8);
233 ok(hbmp8bpp_b != 0, "CreateBitmap failed\n");
234
235 hbmp16bpp_a = CreateBitmap(4, 2, 1, 16, ajBits16);
236 ok(hbmp16bpp_a != 0, "CreateBitmap failed\n");
237
238 hbmp16bpp_b = CreateBitmap(4, 2, 1, 16, ajBits16);
239 ok(hbmp16bpp_b != 0, "CreateBitmap failed\n");
240
241 hbmp24bpp_a = CreateBitmap(4, 2, 1, 24, ajBits24);
242 ok(hbmp24bpp_a != 0, "CreateBitmap failed\n");
243
244 hbmp24bpp_b = CreateBitmap(4, 2, 1, 24, ajBits24);
245 ok(hbmp24bpp_b != 0, "CreateBitmap failed\n");
246
247 hbmp32bpp_a = CreateBitmap(4, 2, 1, 32, ajBits32);
248 ok(hbmp32bpp_a != 0, "CreateBitmap failed\n");
249
250 hbmp32bpp_b = CreateBitmap(4, 2, 1, 32, ajBits32);
251 ok(hbmp32bpp_b != 0, "CreateBitmap failed\n");
252
253}
254
255void
256Test_SrcMono1(ULONG iBmpFormat, HBITMAP hbmpDst, PVOID pvBits)
257{
259 HBRUSH hbr;
260 RECT rect;
261 struct
262 {
263 BITMAPINFOHEADER bmiHeader;
264 ULONG bmiColors[2];
265 BYTE aj[32];
266 } bmi;
267
269 SelectObject(hdcDst, hbmpDst);
270
271 /* Set default dc fore and back colors */
272 SetTextColor(hdcSrc, 0x000000);
273 SetBkColor(hdcSrc, 0xffffff);
274 SetTextColor(hdcDst, 0x000000);
275 SetBkColor(hdcDst, 0xffffff);
276
277 /* Do a bitblt operation */
278 ok(BitBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 0, 0, SRCCOPY), "(%ld): BitBlt failed", iBmpFormat);
279
280 /* Test background color */
281 c = GetPixel(hdcDst, 0, 0);
282 expected = 0xffffff;
283 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
284
285 /* Test foreground color */
286 c = GetPixel(hdcDst, 1, 0);
287 expected = 0x000000;
288 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
289
290 if (pvBits)
291 {
292 c = GetDIBPixel(iBmpFormat, pvBits, 0);
293 expected = iXlateFromRGB(iBmpFormat, GetBkColor(hdcSrc));
294 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
295
296 c = GetDIBPixel(iBmpFormat, pvBits, 1);
298 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
299 }
300
301 /* Set different dc fore and back colors */
302 SetTextColor(hdcSrc, 0xf00f0f);
303 SetBkColor(hdcSrc, 0xf0ff0f);
304 SetTextColor(hdcDst, 0xefFee5);
305 SetBkColor(hdcDst, 0x100121);
306
307 /* Make sure this alone didn't affect the resulting colors */
308 c = GetPixel(hdcDst, 0, 0);
309 expected = 0xffffff;
310 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
311 c = GetPixel(hdcDst, 1, 0);
312 expected = 0x000000;
313 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
314
315 /* Repeat the bitblt operation */
316 ok(BitBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 0, 0, SRCCOPY), "(%ld): BitBlt failed", iBmpFormat);
317
318 /* Test background color */
319 c = GetPixel(hdcDst, 0, 0);
320 expected = GetClosestColor(iBmpFormat, GetBkColor(hdcDst), 0xffffff);
321 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
322
323 /* Test foreground color */
324 c = GetPixel(hdcDst, 1, 0);
325 expected = GetClosestColor(iBmpFormat, GetTextColor(hdcDst), 0);
326 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
327
328 if (pvBits)
329 {
330 c = GetDIBPixel(iBmpFormat, pvBits, 0);
331 expected = iXlateFromRGB(iBmpFormat, GetBkColor(hdcDst));
332 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
333
334 c = GetDIBPixel(iBmpFormat, pvBits, 1);
336 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
337 }
338
339 /* Set inverted fore and back colors */
341 SetBkColor(hdcSrc, 0xffffff);
342 SetTextColor(hdcDst, 0xffffff);
343 SetBkColor(hdcDst, 0x000000);
344
345 /* Repeat the bitblt operation */
346 ok(BitBlt(hdcDst, 0, 0, 2, 2, hdcSrc, 0, 0, SRCCOPY), "(%ld): BitBlt failed", iBmpFormat);
347
348 /* Test background color */
349 c = GetPixel(hdcDst, 0, 0);
350 expected = GetClosestColor(iBmpFormat, GetBkColor(hdcDst), 0xffffff);
351 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
352
353 /* Test foreground color */
354 c = GetPixel(hdcDst, 1, 0);
355 expected = GetClosestColor(iBmpFormat, GetTextColor(hdcDst), 0);
356 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
357
358 if (pvBits)
359 {
360 c = GetDIBPixel(iBmpFormat, pvBits, 0);
361 expected = iXlateFromRGB(iBmpFormat, GetBkColor(hdcDst));
362 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
363
364 c = GetDIBPixel(iBmpFormat, pvBits, 1);
366 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
367 }
368
369
370/* Hatch brush ****************************************************************/
371
372 /* Set dc fore and back colors */
373 SetTextColor(hdcDst, 0x102030);
374 SetBkColor(hdcDst, 0xeeccdd);
376
377 /* Create a hatch brush */
378 hbr = CreateHatchBrush(HS_DIAGCROSS, 0x123456);
379
380 /* Fill the destination bitmap */
381 rect.left = rect.top = 0;
382 rect.bottom = rect.right = 4;
383 ok(FillRect(hdcDst, &rect, hbr), "FillRect failed\n");
384
385 /* Test the fore color of the hatch brush */
386 c = GetPixel(hdcDst, 0, 0);
387 expected = GetClosestColor(iBmpFormat, 0x123456, 0);
388 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
389
390 /* Test the back color of the hatch brush */
391 c = GetPixel(hdcDst, 1, 0);
392 expected = GetClosestColor(iBmpFormat, GetBkColor(hdcDst), 0xffffff);
393 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
394
395 if (pvBits)
396 {
397 c = GetDIBPixel(iBmpFormat, pvBits, 0);
398 expected = iXlateFromRGB(iBmpFormat, 0x123456);
399 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
400
401 c = GetDIBPixel(iBmpFormat, pvBits, 1);
402 expected = iXlateFromRGB(iBmpFormat, GetBkColor(hdcDst));
403 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
404 }
405
406 DeleteObject(hbr);
407
408/* DIB brush ******************************************************************/
409
410 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
411 bmi.bmiHeader.biWidth = 8;
412 bmi.bmiHeader.biHeight = 8;
413 bmi.bmiHeader.biPlanes = 1;
414 bmi.bmiHeader.biBitCount = 1;
415 bmi.bmiHeader.biCompression = BI_RGB;
416 bmi.bmiHeader.biSizeImage = 0;
417 bmi.bmiHeader.biXPelsPerMeter = 1;
418 bmi.bmiHeader.biYPelsPerMeter = 1;
419 bmi.bmiHeader.biClrUsed = 2;
420 bmi.bmiHeader.biClrImportant = 2;
421 bmi.bmiColors[0] = 0xeeeeee;
422 bmi.bmiColors[1] = 0x111111;
423 memset(bmi.aj, 0xaaaa, sizeof(bmi.aj));
425 ok(hbr != 0, "CreateDIBPatternBrushPt failed\n");
426
427 rect.left = rect.top = 0;
428 rect.bottom = rect.right = 4;
429 ok(FillRect(hdcDst, &rect, hbr),"FillRect failed\n");
430
431 /* Test color 1 of the dib brush */
432 c = GetPixel(hdcDst, 0, 0);
433 expected = GetClosestColor(iBmpFormat, bmi.bmiColors[1], 0);
434 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
435
436 /* Test color 0 of the dib brush */
437 c = GetPixel(hdcDst, 1, 0);
438 expected = GetClosestColor(iBmpFormat, bmi.bmiColors[0], 0xffffff);
439 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
440
441 if (pvBits)
442 {
443 c = GetDIBPixel(iBmpFormat, pvBits, 0);
444 expected = iXlateFromRGB(iBmpFormat, bmi.bmiColors[1]);
445 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
446
447 c = GetDIBPixel(iBmpFormat, pvBits, 1);
448 expected = iXlateFromRGB(iBmpFormat, bmi.bmiColors[0]);
449 ok(c == expected, "(%ld): wrong color, expected %lx, got %lx\n", iBmpFormat, expected, c);
450 }
451
452 DeleteObject(hbr);
453
454
455}
456
457void
459{
461 struct
462 {
463 BITMAPINFOHEADER bmiHeader;
464 ULONG bmiColors[3];
465 } bmi;
466 PVOID pvBits;
468
470
473
474 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
475 bmi.bmiHeader.biWidth = 2;
476 bmi.bmiHeader.biHeight = -2;
477 bmi.bmiHeader.biPlanes = 1;
478 bmi.bmiHeader.biBitCount = 16;
479 bmi.bmiHeader.biCompression = BI_RGB;
480 bmi.bmiHeader.biSizeImage = 0;
481 bmi.bmiHeader.biXPelsPerMeter = 1;
482 bmi.bmiHeader.biYPelsPerMeter = 1;
483 bmi.bmiHeader.biClrUsed = 0;
484 bmi.bmiHeader.biClrImportant = 0;
486 ok(hbmp != 0, "CreateDIBSection failed\n");
487 memset(pvBits, 0x55555555, 8 * 8 * 2);
488
490
491 c = GetPixel(hdcDst, 0, 0);
493 ok(c == expected, "expected %lx, got %lx\n", expected, c);
494
495 expected = 0x123456;
496 SetPixel(hdcDst, 0, 0, expected);
498 c = *(volatile WORD*)pvBits;
499 ok(c == expected, "expected %lx, got %lx\n", expected, c);
500
502
504
505 /* Create a 565 DIB section */
507 bmi.bmiHeader.biClrUsed = 3;
509 bmi.bmiColors[0] = 0xF800;
510 bmi.bmiColors[1] = 0x7E0;
511 bmi.bmiColors[2] = 0x1F;
513 ok(hbmp != 0, "CreateDIBSection failed\n");
515
517
519
520 /* Create a 32 bpp DIB section */
521 bmi.bmiHeader.biBitCount = 32;
523 bmi.bmiHeader.biClrUsed = 0;
526 ok(hbmp != 0, "CreateDIBSection failed\n");
528
530
532
533}
534
535
537{
538 Initialize();
539
540 Test_SrcMono();
541}
542
543// trunk: 41 failures
544
FORCEINLINE VOID SetPixel(_In_ ULONG Left, _In_ ULONG Top, _In_ UCHAR Color)
Definition: arm.h:50
#define ok(value,...)
Definition: atltest.h:57
#define START_TEST(x)
Definition: atltest.h:75
DWORD GetPixel(LPDIRECTDRAWSURFACE7 Surface, UINT x, UINT y)
Definition: blt.cpp:2
HBITMAP hbmp
#define NULL
Definition: types.h:112
static VOID NTAPI BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:49
#define BI_RGB
Definition: precomp.h:47
#define RGB(r, g, b)
Definition: precomp.h:62
#define GetBValue(quad)
Definition: precomp.h:66
#define GetGValue(quad)
Definition: precomp.h:65
#define GetRValue(quad)
Definition: precomp.h:64
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
#define printf
Definition: freeldr.h:94
pKey DeleteObject()
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
signed char * PCHAR
Definition: retypes.h:7
unsigned int ULONG
Definition: retypes.h:1
#define PCHAR
Definition: match.c:90
#define BI_BITFIELDS
Definition: mmreg.h:507
HDC hdc
Definition: main.c:9
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
BOOL expected
Definition: store.c:2063
#define DWORD
Definition: nt_native.h:44
_In_ HBITMAP _In_ UINT _In_ UINT _Inout_ LPBITMAPINFO pbmi
Definition: ntgdi.h:2780
#define memset(x, y, z)
Definition: compat.h:39
& rect
Definition: startmenu.cpp:1413
ULONG biClrImportant
Definition: precomp.h:43
USHORT biBitCount
Definition: precomp.h:37
ULONG biCompression
Definition: precomp.h:38
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1476
RGBQUAD bmiColors[1]
Definition: wingdi.h:1477
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:199
_In_ SIZEL _In_ ULONG iFormat
Definition: winddi.h:3468
DWORD COLORREF
Definition: windef.h:300
#define DIB_RGB_COLORS
Definition: wingdi.h:367
HBITMAP WINAPI CreateBitmap(_In_ INT cx, _In_ INT cy, _In_ UINT cPlanes, _In_ UINT cBitsPerPel, _In_opt_ const VOID *pvBits)
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
Definition: dc.c:999
int WINAPI GetDIBits(_In_ HDC hdc, _In_ HBITMAP hbm, _In_ UINT start, _In_ UINT cLines, _Out_opt_ LPVOID lpvBits, _At_((LPBITMAPINFOHEADER) lpbmi, _Inout_) LPBITMAPINFO lpbmi, _In_ UINT usage)
COLORREF WINAPI GetTextColor(_In_ HDC)
Definition: text.c:861
#define HS_DIAGCROSS
Definition: wingdi.h:578
HBRUSH WINAPI CreateHatchBrush(_In_ int, _In_ COLORREF)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define SRCCOPY
Definition: wingdi.h:333
COLORREF WINAPI GetBkColor(_In_ HDC)
Definition: dc.c:978
#define OPAQUE
Definition: wingdi.h:949
HBITMAP WINAPI CreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
struct tagBITMAPINFO * PBITMAPINFO
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1056
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:918
HBRUSH WINAPI CreateDIBPatternBrushPt(_In_ const VOID *pvPackedDIB, _In_ UINT uUsage)
HDC WINAPI GetDC(_In_opt_ HWND)
static ULONG iDcFormat
Definition: xlate.c:33
@ BMF_16BPP_565
Definition: xlate.c:12
@ BMF_24BPP_BGR
Definition: xlate.c:14
@ BMF_32BPP_RGB
Definition: xlate.c:15
@ BMF_4BPP
Definition: xlate.c:9
@ BMF_1BPP
Definition: xlate.c:8
@ BMF_24BPP_RGB
Definition: xlate.c:13
@ BMF_32BPP_BGR
Definition: xlate.c:16
@ BMF_8BPP
Definition: xlate.c:10
@ BMF_16BPP_555
Definition: xlate.c:11
static HBITMAP hbmp32bpp_a
Definition: xlate.c:30
static HBITMAP hbmp8bpp_b
Definition: xlate.c:27
static HDC hdcSrc
Definition: xlate.c:32
void Test_SrcMono()
Definition: xlate.c:458
static void Initialize()
Definition: xlate.c:212
static HBITMAP hbmp32bpp_b
Definition: xlate.c:30
static HBITMAP hbmp16bpp_a
Definition: xlate.c:28
static BYTE ajBits1[]
Definition: xlate.c:21
ULONG GetRealColorDepth()
Definition: xlate.c:36
static HBITMAP hbmp1bpp_a
Definition: xlate.c:26
static BYTE ajBits8[]
Definition: xlate.c:22
static ULONG GetClosestColor(ULONG iFormat, COLORREF crColor, COLORREF crBackColor)
Definition: xlate.c:181
static HBITMAP hbmp16bpp_b
Definition: xlate.c:28
static ULONG iXlateFromRGB(ULONG iFormat, COLORREF crColor)
Definition: xlate.c:96
static HBITMAP hbmpCompat
Definition: xlate.c:31
static HBITMAP hbmp24bpp_b
Definition: xlate.c:29
static DWORD ajBits24[]
Definition: xlate.c:24
static HBITMAP hbmp1bpp_b
Definition: xlate.c:26
ULONG GetDIBPixel(ULONG iFormat, PVOID pvBits, ULONG x)
Definition: xlate.c:189
void Test_SrcMono1(ULONG iBmpFormat, HBITMAP hbmpDst, PVOID pvBits)
Definition: xlate.c:256
static HBITMAP hbmp24bpp_a
Definition: xlate.c:29
static HDC hdcDst
Definition: xlate.c:32
static COLORREF iXlateToRGB(ULONG iFormat, ULONG ulColor)
Definition: xlate.c:136
static HBITMAP hbmp8bpp_a
Definition: xlate.c:27
static DWORD ajBits32[]
Definition: xlate.c:25
static WORD ajBits16[]
Definition: xlate.c:23
ULONG bpp[]
Definition: xlate.c:19
unsigned char BYTE
Definition: xxhash.c:193