e8694bbf01b38a7306441c507f7d58fc2ab23622
[reactos.git] / rostests / winetests / gdi32 / dib.c
1 /*
2 * DIB driver tests.
3 *
4 * Copyright 2011 Huw Davies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <math.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "wincrypt.h"
30
31 #include "wine/test.h"
32
33 #ifndef M_PI
34 #define M_PI 3.14159265358979323846
35 #endif
36
37 static HCRYPTPROV crypt_prov;
38 static DWORD (WINAPI *pSetLayout)(HDC hdc, DWORD layout);
39
40 static const DWORD rop3[256] =
41 {
42 0x000042, 0x010289, 0x020C89, 0x0300AA, 0x040C88, 0x0500A9, 0x060865, 0x0702C5,
43 0x080F08, 0x090245, 0x0A0329, 0x0B0B2A, 0x0C0324, 0x0D0B25, 0x0E08A5, 0x0F0001,
44 0x100C85, 0x1100A6, 0x120868, 0x1302C8, 0x140869, 0x1502C9, 0x165CCA, 0x171D54,
45 0x180D59, 0x191CC8, 0x1A06C5, 0x1B0768, 0x1C06CA, 0x1D0766, 0x1E01A5, 0x1F0385,
46 0x200F09, 0x210248, 0x220326, 0x230B24, 0x240D55, 0x251CC5, 0x2606C8, 0x271868,
47 0x280369, 0x2916CA, 0x2A0CC9, 0x2B1D58, 0x2C0784, 0x2D060A, 0x2E064A, 0x2F0E2A,
48 0x30032A, 0x310B28, 0x320688, 0x330008, 0x3406C4, 0x351864, 0x3601A8, 0x370388,
49 0x38078A, 0x390604, 0x3A0644, 0x3B0E24, 0x3C004A, 0x3D18A4, 0x3E1B24, 0x3F00EA,
50 0x400F0A, 0x410249, 0x420D5D, 0x431CC4, 0x440328, 0x450B29, 0x4606C6, 0x47076A,
51 0x480368, 0x4916C5, 0x4A0789, 0x4B0605, 0x4C0CC8, 0x4D1954, 0x4E0645, 0x4F0E25,
52 0x500325, 0x510B26, 0x5206C9, 0x530764, 0x5408A9, 0x550009, 0x5601A9, 0x570389,
53 0x580785, 0x590609, 0x5A0049, 0x5B18A9, 0x5C0649, 0x5D0E29, 0x5E1B29, 0x5F00E9,
54 0x600365, 0x6116C6, 0x620786, 0x630608, 0x640788, 0x650606, 0x660046, 0x6718A8,
55 0x6858A6, 0x690145, 0x6A01E9, 0x6B178A, 0x6C01E8, 0x6D1785, 0x6E1E28, 0x6F0C65,
56 0x700CC5, 0x711D5C, 0x720648, 0x730E28, 0x740646, 0x750E26, 0x761B28, 0x7700E6,
57 0x7801E5, 0x791786, 0x7A1E29, 0x7B0C68, 0x7C1E24, 0x7D0C69, 0x7E0955, 0x7F03C9,
58 0x8003E9, 0x810975, 0x820C49, 0x831E04, 0x840C48, 0x851E05, 0x8617A6, 0x8701C5,
59 0x8800C6, 0x891B08, 0x8A0E06, 0x8B0666, 0x8C0E08, 0x8D0668, 0x8E1D7C, 0x8F0CE5,
60 0x900C45, 0x911E08, 0x9217A9, 0x9301C4, 0x9417AA, 0x9501C9, 0x960169, 0x97588A,
61 0x981888, 0x990066, 0x9A0709, 0x9B07A8, 0x9C0704, 0x9D07A6, 0x9E16E6, 0x9F0345,
62 0xA000C9, 0xA11B05, 0xA20E09, 0xA30669, 0xA41885, 0xA50065, 0xA60706, 0xA707A5,
63 0xA803A9, 0xA90189, 0xAA0029, 0xAB0889, 0xAC0744, 0xAD06E9, 0xAE0B06, 0xAF0229,
64 0xB00E05, 0xB10665, 0xB21974, 0xB30CE8, 0xB4070A, 0xB507A9, 0xB616E9, 0xB70348,
65 0xB8074A, 0xB906E6, 0xBA0B09, 0xBB0226, 0xBC1CE4, 0xBD0D7D, 0xBE0269, 0xBF08C9,
66 0xC000CA, 0xC11B04, 0xC21884, 0xC3006A, 0xC40E04, 0xC50664, 0xC60708, 0xC707AA,
67 0xC803A8, 0xC90184, 0xCA0749, 0xCB06E4, 0xCC0020, 0xCD0888, 0xCE0B08, 0xCF0224,
68 0xD00E0A, 0xD1066A, 0xD20705, 0xD307A4, 0xD41D78, 0xD50CE9, 0xD616EA, 0xD70349,
69 0xD80745, 0xD906E8, 0xDA1CE9, 0xDB0D75, 0xDC0B04, 0xDD0228, 0xDE0268, 0xDF08C8,
70 0xE003A5, 0xE10185, 0xE20746, 0xE306EA, 0xE40748, 0xE506E5, 0xE61CE8, 0xE70D79,
71 0xE81D74, 0xE95CE6, 0xEA02E9, 0xEB0849, 0xEC02E8, 0xED0848, 0xEE0086, 0xEF0A08,
72 0xF00021, 0xF10885, 0xF20B05, 0xF3022A, 0xF40B0A, 0xF50225, 0xF60265, 0xF708C5,
73 0xF802E5, 0xF90845, 0xFA0089, 0xFB0A09, 0xFC008A, 0xFD0A0A, 0xFE02A9, 0xFF0062
74 };
75
76 static inline BOOL rop_uses_src(DWORD rop)
77 {
78 return (((rop & 0xcc0000) >> 2) != (rop & 0x330000));
79 }
80
81 static const char *sha1_graphics_a8r8g8b8[] =
82 {
83 "a3cadd34d95d3d5cc23344f69aab1c2e55935fcf",
84 "2426172d9e8fec27d9228088f382ef3c93717da9",
85 "9e8f27ca952cdba01dbf25d07c34e86a7820c012",
86 "664fac17803859a4015c6ae29e5538e314d5c827",
87 "17b2c177bdce5e94433574a928bda5c94a8cdfa5",
88 "fe6cc678fb13a3ead67839481bf22348adc69f52",
89 "d51bd330cec510cdccf5394328bd8e5411901e9e",
90 "df4aebf98d91f11be560dd232123b3ae327303d7",
91 "f2af53dd073a09b1031d0032d28da35c82adc566",
92 "eb5a963a6f7b25533ddfb8915e70865d037bd156",
93 "c387917268455017aa0b28bed73aa6554044bbb3",
94 "dcae44fee010dbf7a107797a503923fd8b1abe2e",
95 "6c530622a025d872a642e8f950867884d7b136cb",
96 "7c07d91b8f68fb31821701b3dcb96de018bf0c66",
97 "b2261353decda2712b83538ab434a49ce21f3172",
98 "35f731c0f6356b8f30651bb3cbe0d922c49deba5",
99 "9b9874c1c1d92afa554137e191d34ea33acc322f",
100 "c311dd74325e8cebfc8529a6d24a6fa4ecb7137e",
101 "d7398de15b2837a58a62a701ca1b3384625afec4",
102 "a78b28472bb7ff480ddedd06b9cf2daa775fa7ae",
103 "5246ef357e7317b9d141a3294d300c195da76cb7",
104 "87f6b6a19f021ca5912d285e14ce2ff9474d79f3",
105 "e2a8eef4aeda3a0f6c950075acba38f1f9e0814d",
106 "8b66f14d51ecdeea12bc993302bb9b7d3ec085a1",
107 "7da9dd3d40d44d92deb9883fb7110443c2d5769a",
108 "e358efb1c11172e40855de620bdb8a8e545cd790",
109 "9e0c2596c6ecb4f1bc97b18ec3ca493d37626608",
110 "58806549380c964e7a53ad54821d2eb86fa5b9ce",
111 "7fc30d3058c235ce39088de0a598b8c7fe7ca61f",
112 "52a6c769c227f2bb1949097c4c87fed5ee0cbcb1",
113 "8a010d4c5af51fcc34d51be3197878782bdf63e7",
114 "c84c2c33e22eb7e5c4a2faad3b3b99a359d77528",
115 "41bcc1f57c60bdec3c4d1e749084a12867f91224",
116 "94645300d6eb51020a7ef8261dee2941cd51b5df",
117 "c56f5bdc9cac4f0bc81c33295d9aed8eaf4cb1f2",
118 "21cdfde38ac7edbb241ec83d82f31286e90c4629",
119 NULL
120 };
121
122 static const char *sha1_graphics_a8b8g8r8[] =
123 {
124 "a3cadd34d95d3d5cc23344f69aab1c2e55935fcf",
125 "e0bc877697093ed440e125154e247ca9d65e933c",
126 "c6d7faf5a502299f99d59eef3f7650bd63dbe108",
127 "9d8c05c3ebd786e7d052418e905a80a64bf7853d",
128 "3da12af0a810fd993fa3dbe23328a4fcd2b6c92a",
129 "b91c8f21cc4d7994abc551feff5b6927d267a9db",
130 "d49dd2c6a37e975b6dc3d201ccc217a788b30284",
131 "ca6753f9eb44529cf8c67cd6abcd4ed1ef758904",
132 "18c3ae944e0afb6c43c21cde093ddb22a27611e4",
133 "b753ebb39d90210cc717f57b53dd439f7de6b077",
134 "38c017dd1fff26b492a57e09f3ce2c4370faf225",
135 "94368cea5033b435454daa56d55546310675131e",
136 "bf57a6a37fb107d29ed3d45695919887abcb7902",
137 "3db0f8bcca3d94920aa57be6321202b8c3c08822",
138 "1f1fc165a4dae7ba118ddccb58a279bfe3876b0a",
139 "8e09abb108e137c99527ab4c9bd07d95b9254bbb",
140 "b0178632775d29bec2b16de7b9b8287115c40d0f",
141 "ca7e859647b9498b53fdd92543ad8aea98ff46f3",
142 "3369889a67d6c79a24ee15f7d14374f9995215e4",
143 "473a1fd07df800c87a5d3286b642ace10c61c6af",
144 "10cd25a0ed5cd8f978d7d68236f81d949b938e84",
145 "b8951d2b20518fd129e5113a5f429626893913bf",
146 "4851c5b7d5bc18590e787c0c218a592ef504e738",
147 "9aa506e3df33e0d5298755aa4144e10eb4b5adcf",
148 "abdf003699364fe45fab7dc61e67c606d0063b40",
149 "89abaadff4e68c738cf9251c51e3609564843381",
150 "f6aa3f907f620b9f3493f03cb3b4b292df3a9545",
151 "77d0ad32938147aa4038c1eced232b7b5a5f88f3",
152 "43d36e57b702ce56eb250bf53f1ecc4680990cfe",
153 "fd6e0ebb52710ebcdd8dd69931165c83c4930b41",
154 "71b9756fdfeedce1e6db201176d21a981b881662",
155 "5319528d9af750c172ae62ee85ddb2eaef73b193",
156 "b7ce8aa3c328eedaed7306234ed9bae67708e627",
157 "19b32a0daa91201725b5e13820c343d0a84ff698",
158 "abca6a80a99b05722d2d87ce2a8b94ef1ae549e1",
159 "2ba70994d0b4ce87fdf6fbc33ada11252178061e",
160 NULL
161 };
162
163 static const char *sha1_graphics_24[] =
164 {
165 "e993b15c9bd14fb45a15310450b7083c44e42665",
166 "edbd7bab3d957fbc85e89612197cf918f5f5af20",
167 "6a7efb3b6e0b49336df1bd2937ca09a11d976531",
168 "236eb5ca9da70ec7cc719cd2fd291bab14000257",
169 "f98023c7cd8c068f2d7a77ce3600004b90ea12d6",
170 "5c4cb9cea2226fc671bb4a11f8253343ee94bb4b",
171 "fd4be592483623dbc800fe28210a1f0daa71999b",
172 "788b8de98c47974fa9f232a6042ae4ca546ddb7d",
173 "a8772e6c44ba633fb384a7c4b50b435f1406107e",
174 "883bc8f305c602edca785e21cd00f488583fb13f",
175 "3bac4e80993f49dc3926e30524115fca9d7a8026",
176 "91369e35be29059a0665782541db4c8b324c6bb2",
177 "0fa8cf332a56bb6d7e14e85861fdd60f51d70501",
178 "593d694cdcc8349b3bfc8257041dbcb27e61da45",
179 "1036b91d93e31cd1d4740d0c8642e115e5a38188",
180 "1898073cdb35ca4d2b21bba933ac16a0b4297317",
181 "5068bff794553cf5a3145ae407c9a2984357844c",
182 "413a7989969c229dee4ab1798362f32f96cf0a10",
183 "0bb222e540b82720d4971e4a2fc626899af03e03",
184 "adc20832d8c43f1cf372d8392535492013cd2306",
185 "45649794dcbcabda487f66f7a80fc1bec79047a1",
186 "367c2dc1e91ff9ea0e984d6fb3000cfb4e0ae7e9",
187 "b4df692ac70a5f9f303270df4641ab014c6cbf46",
188 "8bc3128ba47891366fd7b02fde7ca19100e64b9f",
189 "e649e00efe7fea1eb8b17f7867fe089e5270c44b",
190 "a0bffbbfb0adf6f188479c88da04e25d76ab4822",
191 "92a1ab214dd8027c407814420449119466c92840",
192 "b58f19c1800344a2b8e017eb784705bdb2bd8450",
193 "5747a6d5c6ce79731c55e8cf33f7da3025cd35fd",
194 "955390669afed2369b15b32fa519f2f921cdf1a0",
195 "201906f7d763b930a98c97f8eeab417f2b65e723",
196 "5313357d50c40c05a3b3a83d0d2013a138c955a1",
197 "701c5af1d0c28294ce7d804b5697643c430d22a0",
198 "b0a959745b2db1d9f449e68e4479a4f36301879c",
199 "63f764b9bd2f4876ab1ee0f3c0eb55b5a7de5212",
200 "e171f6ec77bca91d6b8559911bce296c0bac469e",
201 NULL
202 };
203
204 static const char *sha1_graphics_r5g5b5[] =
205 {
206 "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae",
207 "847005cf7371f511bcc837251cde07b1796f6113",
208 "a8f75743a930843ec14d516cd048b6e0468e5d89",
209 "d094f51ce9b9daa9c1d9594ea88be2a2db651459",
210 "cf3928e240c9149788e1635b115a4e5baea0dd8f",
211 "a9034a905daa91757b4f63345c0e40638cd53ca8",
212 "15ee915d989e49bb9bab5b834d8f355bd067cd8f",
213 "99474fecf11df7b7035c35be6b8b697be9889418",
214 "cbc2898717f97ebb07c0c7cc04abde936dc5b584",
215 "29c896b591fdf4ddd23e5c0da1818c37e4686d94",
216 "4b5b275d33c1ebfe5bdc61df2ad125e865b800fa",
217 "92df731fa1f89550d9d4f7ea36c13f2e57c4b02a",
218 "420e39ff3bdd04c4b6cc2c98e99cb7993c7a0de5",
219 "1fabf0fdd046857b1974e31c1c1764fa9d1a762f",
220 "449092689226a1172b6086ba1181d6b6d6499f26",
221 "1a92a60f190d33ef06d9decb56fd3fdd33f3af03",
222 "e61f5978c2e28c0c6d8f5eefe0f840c975586efc",
223 "897d16f4d6a6ddad685d23ed7828d4f676539b75",
224 "9d21bcfdeaf1ca5d47eb823bdefc24d7a95f4f56",
225 "6daaf945a955928c5c124c880522ca4634fb2343",
226 "12a288390d16e1efa99d4185301de48a4d433b14",
227 "ea92af2538b76f41a3a03eaa11ac395c9b6197c4",
228 "3a50ce21b3563a604b4fc9f247a30f5a981f1ba6",
229 "d7d97e28ed316f6596c737eb83baa5948d86b673",
230 "ecc2991277d7314f55b00e0f284ae3703aeef81e",
231 "656bf3b7121bcd620a0a3ad488f0d66604824577",
232 "d7d8493b5fa7a3a8323d6ac84245093a79f052c1",
233 "df5dafe96e528c2cc7fd11e4934e298f53cec34b",
234 "a49530722328ae88fd765792ac0c657efbcce75d",
235 "aa46aa2226e3121eaefa9d0836418e0b69262d69",
236 "333f3f2cf3ff15736d59f92a33c45323d3987d6d",
237 "a6fd83542c3826132e88d3f5e304d604c0056fad",
238 "a8d6a5285a927ba3a3be34b06a06c70a20d4c1b3",
239 "e428d213ad02651287894f093413949dcb369208",
240 "7df915bedcc5951a1b6f828490f7dbb93212e835",
241 NULL
242 };
243
244 static const char *sha1_graphics_r4g4b4[] =
245 {
246 "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae",
247 "cfa0ab83ee93283ad914c3748f0532da1697af1d",
248 "8bd18697d1ef27492805667a0bc956343ac08667",
249 "e8501c830321584474654f90e40eaf27dc21e6a8",
250 "d95ab10fcfb8447b41742e89f1ae8cd297a32fc4",
251 "821177710961d2cb5f7e7dfc0e06e767b6042753",
252 "667124365ffadeea1d8791bedda77a0c7b898de8",
253 "c9f23e684b600dea17575b4b17175fbd9106c3a9",
254 "7678876e50eae35d1eaa096aae25afaa0b864bf3",
255 "fb52b0c373a5f2a60b981604b120962942d2447a",
256 "5ab8dd07436681d762fa04ad7c6d71291c488924",
257 "0167981d9e1490a2ebd396ff7582f0943aa8e1b8",
258 "115a6bd382410a4a1d3c1fa71d8bf02536863e38",
259 "65c6d1228e3b6d63d42647f14217bc1658b70d9a",
260 "25fcb75aa687aac35b8f72640889fe92413e00c5",
261 "3bddf9d53e89560b083302b146cd33791b13d941",
262 "a81504498c7a7bb46340ce74476a42f70f2730b1",
263 "e61a4f2657a444d8c49f84fb944f9f847667bf2b",
264 "32b6e0aa79b7e96cd0ab2da167f6463c011023a8",
265 "1d283aa4d2b2114f7809fe59357d590c7c779aa7",
266 "29640e2ddd2d3016da14507c3ce9b2ce32f39bb4",
267 "57ebf8becac1524543da120e88e9cc57ecfdec49",
268 "d591232bbc2592462c819a9486750f64180518fd",
269 "0e183a4c30b3da345129cffe33fe0fc593d8666b",
270 "f14d9a4bd8a365b7c8f068a0dad481b6eb2b178b",
271 "8933450132bf949ba4bc28626968425b5ed2867d",
272 "9928a8f28a66c00069a124f7171b248817005763",
273 "e4a9dcc3e565cd3a6b7087dd1433f3898bb9cdb2",
274 "eca4f9b16b3bddfd0735fdd792e0ccaadfb9ba49",
275 "233e588cf660e2c9b552cf02065cf63fa6655864",
276 "0740ff74dcd259d9a644ba51ad77ff0d40348951",
277 "a3345acaf272f2e288626906e3056cd0ced70499",
278 "957a86fbe8a96dd068db65e4e624a52bcc84af46",
279 "13b0f240054dc57ba0e2dfde74048496304a2c7f",
280 "51ef267eb9c15487c9430f505e8a6c929eb2170c",
281 NULL
282 };
283
284 static const char *sha1_graphics_8[] =
285 {
286 "41728d7ff2bb425b5fc06521adeabf6cc73136f3",
287 "512246d4886ab889a090b167ba194577cb95272e",
288 "921e852d4564cb9e5ac15ff68b5207bebea871d1",
289 "9636b0ebefc443ea11949ccd28f6ca454277dd41",
290 "aa9050da55e6b6957c60b7d603fce539cb5c0048",
291 "e2b93aca15fb1233ac09a713dced1f4cd950b1e4",
292 "3e3a603fc26cc305aa27f88da7d2a3b0073877d8",
293 "390b2bf70daba36310683f46af9cd50b9a061396",
294 "82d21737e9a7247397a6c983a9b6d9a0452dd74d",
295 "2a8460af91675e01cbe9384eb6cd3eb2cb420960",
296 "1af53b1218ee9844fcda891b836d42f6b2f66bd5",
297 "da1cc34a9d9b779fc7849e03e214096026506464",
298 "5ba8f99ca034666effa556748c49a0f5a015125f",
299 "b67ba2f55659c75ac72c1112494461bb3086e1a4",
300 "73e2859ce849f756f954718ce3c90f02e31712b6",
301 "b1dff0f5dd233b44ee568878c5d3f8ae1d80c6d9",
302 "1f27dc1a1316fb7a4a78fe40fcd4bdae3aaad218",
303 "6e375e1485a1e45ac6ab10af49645d5fb2e76dff",
304 "cfc67c325c7cdf96d90af9b3cceb8d0504cbb3b0",
305 "7262364067e03c7fa498af1d59d228d6c63b460e",
306 "5241241a355a667ef0834049adf4218e8b3f16b8",
307 "db22d666690948eb966f75b796c72c7150a5c4b9",
308 "1f13ea0034db4b0ffa4ddcff9664fd892058f9cd",
309 "3caf512cfddfd463d0750cfe3cadb58548eb2ae8",
310 "4e5e7d5fd64818b2b3d3e793c88f603b699d2f0f",
311 "c4efce8f7ed2d380ea5dc6fe1ef8448a27827532",
312 "bdc0a354635b879871077c5b712570e469863c99",
313 "d599bf210423fe3adbb4f1de87d9360de97827d0",
314 "bae7c8b789e4e9b336c03c4daee3bce63fe039d9",
315 "cc01f17928f7780cefd423ea653b072eea723a1b",
316 "c005662a47f14c2f1b7c7fb3b0ef0fc390c6ea6a",
317 "675cde16a6ad2bcd8d7e72780b07a0ccd8d0393a",
318 "ea39ac62ca2f815a1d029340c6465994b6f03cb0",
319 "9a603513cd81acf70cf8b27b0d544e7f672e9d40",
320 "f4a334e69535de74ee5ed54be93a75120a66e54a",
321 NULL
322 };
323
324 static const char *sha1_graphics_4[] =
325 {
326 "fa867e2976a549ecd3b1fa67df54963232fcef8c",
327 "256d742b4da96b373b4fa5663d0ad3b5faab5c8e",
328 "d96d8f4232b930bccd53b903b5efaf8c0bdb16f4",
329 "9401799e6116c35e5f0e5bdca07ea25316757a72",
330 "482ae2b0ef1d64752b5ef11cc7f35a33eb55d07c",
331 "dcfb3e01100b41c0f75a1c5f84b6de6b90138281",
332 "2505598845fa026ea7187582461efbf06cb6904f",
333 "3981a19363beca8f28d32a5928ac296fd22a5296",
334 "01404024ebb2c266d17d734059524d874491650f",
335 "c87bbff3f83b8ec11bb03cfa9bc9ee5166c4c7ef",
336 "f35c5d62853be78c5d39fb2f45200dc262aa8e18",
337 "46e94a55f5f58a6b915078d8ffdc725f53aab516",
338 "665bbbc749a5ffeedc0d62aef0661a5ce845b017",
339 "1f26a01730f67d40ea711a50d9d801bac15a642e",
340 "3b53d24178cfacba53103a44dfd5d072b15a6781",
341 "c52cfd57f26037723d37192722fc3a217f280c9e",
342 "e34da6500cf2e424d980714d92737cf6c31a7bda",
343 "d17f4358ae529f920960ed89e535902ee13b0033",
344 "0f44e12ecd1ea7e39433890443626d4fc35204a4",
345 "eb38683e812fd13dca971ba8f4cfd2b6820d3524",
346 "73bbc83f88f1aaa6df0158b63e70bb3165163163",
347 "0dc2690a5c58a2907a8ab06693ebfab6698172eb",
348 "39c16648cf6c261be71a33cec41867f28e119b94",
349 "26ad5116562e7b58c76a26eaf521e2e40899e944",
350 "1bcc54eaf8e3c2b7c59ecccb23c240181d7ba8b8",
351 "4f827ca6927f15191588456f985bf29d2a3b3c24",
352 "e7de769c3d12ea9dd223bef4881c578823bec67e",
353 "6fb102d020e5554116feefc8482104f3ae2036d2",
354 "ae546ffd30b837afc7dfcb5c9ce4f01d15b35ddc",
355 "20c9eb3276c08fdce35755e349bec94b04929812",
356 "628d837163a25c6520f19c0602383176dbad528e",
357 "b5a12cff7100290ad43f5ed17a321b42de048893",
358 "b672afbeeafb44194a821f0def81a8892872937e",
359 "db0124045882b598feea192186cf7eb7a0387866",
360 "602d91471378fe24a2d0248bd8a92b624f099fea",
361 NULL
362 };
363
364 static const char *sha1_graphics_1[] =
365 {
366 "23366004515f3bc46796ea505d748f8d0f97fbe1",
367 "ad674a4104c6a1eacaee8f20effdfe31775b4409",
368 "a7cc69f957d7b533a0a330859a143d701daac73c",
369 "a955bf088c5edb129289ce65caace48ec95632e4",
370 "5316d3c558c254479883133cf58cd07ab521d3f0",
371 "fcbfdb5d60716ea05f2d1896fae7a6e7a8249d35",
372 "2c140b39cc8d21358fded8959cd655f03d7f0f89",
373 "121423a38b4ac4743bd516e0a7e88a3863796313",
374 "7c17635c6c7f62dbf8fd4773d0c503358553d2c7",
375 "21d5d9e47bb07de2cf7bc99b7725390d03a6cde6",
376 "f69ee65ea25676429a28eea79b5b9cb9206b8d01",
377 "39ff81f77ef4ee772367ed1a63785987c060126e",
378 "4c686508a994ca4c7a0a73b8c0fe52423c180d9c",
379 "b0cc1f5e244ae0c0835a9866a46abdfcd56d1cb1",
380 "7ddf19df5bbdf4475b6ec1bc042425e382502864",
381 "144c9a846e5e37ac6efd5ed3a97ec231479e8fca",
382 "c5ffc59048bf786b5646ad6226cd8633965de9ef",
383 "40fadc2d24c713b04ff96f7dc26e70e85f26c55e",
384 "400a21caa01e015096ee1afcf1b54e7f8ec515bd",
385 "0ff4b49797e30e3555aab45219adf449a9a560ff",
386 "280327328ca940c212ce24fe72e0b00014072767",
387 "144c9a846e5e37ac6efd5ed3a97ec231479e8fca",
388 "b85463875f755b85f1464b1b6275912bcbad6c9f",
389 "816f200969feecc788b61dfeecf05b1790984401",
390 "a4964d8bbf80fe785f906bc0f7c5b113242a58fc",
391 "a5d204cc7342d40b765ca042f8668e22601c4ff9",
392 "adb2818f6d3845dd140bc0f9abdbaa89d2a8c3de",
393 "0a76e0121facb103857130bc6e12185ad77fc3fa",
394 "02aede714773d654d0fc2f640afaa133ec718ad5",
395 "13cc63972aee4f6ae27091a8af18de01f1d3a5da",
396 "3bb745ccb08402ce6fac6ee26fb8d7aad2dba27e",
397 "b26699f62661e16a1dc452d24c88ce363a1f2998",
398 "4d95c3d1e170f004c80aa8c52feafb8e0e90760e",
399 "c14832e69ec3585c15987b3d69d5007236fa9814",
400 "e44ea620b0c47125a34193537ab9d219a52ad028",
401 "d1e6091caa4482d3142df3b958606c41ebf4698e",
402 "07c1116d8286fb665a1005de220eadc3d5999aaf",
403 "4afb0649488f6e6f7d3a2b8bf438d82f2c88f4d1",
404 "f2fe295317e795a88edd0b2c52618b8cb0e7f2ce",
405 "ffc78c075d4be66806f6c59180772d5eed963dc0",
406 "c86eeaeed09871dee4b43722ba512d2d3af7f4d0",
407 "24b1a6241c81dbb950cfbe5da6798fd59eb36266",
408 "1007d3b531b4bc3553d4547bc88443fc1f497cf6",
409 "b71ca46be287598f716bb04fac0a52ad139c70db",
410 "6589e48498e30ab036fbfe94d73427b2b1238a69",
411 "4dce919117d2e41df9f5d4d0de14f97ae650046d",
412 "22c2e078f69d73b7a5cb3f7dcbb8fbaa007ef3ac",
413 "be36cda370650e6d5fb0570aeb8ced491d0c2b1c",
414 "4c34cb8e47f9ff4b4348aa2d40cce7cb54d65cb0",
415 "18f4497e43903e8df5b27da4ceebf62b15550a87",
416 NULL
417 };
418
419 static inline DWORD get_stride(BITMAPINFO *bmi)
420 {
421 return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3;
422 }
423
424 static inline DWORD get_dib_size(BITMAPINFO *bmi)
425 {
426 return get_stride(bmi) * abs(bmi->bmiHeader.biHeight);
427 }
428
429 static char *hash_dib(BITMAPINFO *bmi, void *bits)
430 {
431 DWORD dib_size = get_dib_size(bmi);
432 HCRYPTHASH hash;
433 char *buf;
434 BYTE hash_buf[20];
435 DWORD hash_size = sizeof(hash_buf);
436 int i;
437 static const char *hex = "0123456789abcdef";
438
439 if(!crypt_prov) return NULL;
440
441 if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL;
442
443 CryptHashData(hash, bits, dib_size, 0);
444
445 CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0);
446 if(hash_size != sizeof(hash_buf)) return NULL;
447
448 CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0);
449 CryptDestroyHash(hash);
450
451 buf = HeapAlloc(GetProcessHeap(), 0, hash_size * 2 + 1);
452
453 for(i = 0; i < hash_size; i++)
454 {
455 buf[i * 2] = hex[hash_buf[i] >> 4];
456 buf[i * 2 + 1] = hex[hash_buf[i] & 0xf];
457 }
458 buf[i * 2] = '\0';
459
460 return buf;
461 }
462
463 static void compare_hash_broken_todo(BITMAPINFO *bmi, BYTE *bits, const char ***sha1, const char *info, int num_broken, BOOL todo)
464 {
465 char *hash = hash_dib(bmi, bits);
466 BOOL ok_cond;
467 int i;
468
469 if(!hash)
470 {
471 skip("SHA1 hashing unavailable on this platform\n");
472 return;
473 }
474
475 for(i = 0; i <= num_broken; i++)
476 {
477 if((*sha1)[i] == NULL)
478 {
479 ok((*sha1)[i] != NULL, "missing hash, got \"%s\",\n", hash);
480 return;
481 }
482 }
483
484 ok_cond = !strcmp(hash, **sha1);
485
486 for(i = 1; i <= num_broken; i++)
487 ok_cond = ok_cond || broken( !strcmp(hash, (*sha1)[i]) );
488
489 if(todo)
490 todo_wine ok( ok_cond, "%d: %s: expected hash %s got %s\n",
491 bmi->bmiHeader.biBitCount, info, **sha1, hash );
492 else
493 ok( ok_cond, "%d: %s: expected hash %s got %s\n",
494 bmi->bmiHeader.biBitCount, info, **sha1, hash );
495
496 *sha1 += num_broken + 1;
497
498 HeapFree(GetProcessHeap(), 0, hash);
499 }
500
501 static void compare_hash(BITMAPINFO *bmi, BYTE *bits, const char ***sha1, const char *info)
502 {
503 compare_hash_broken_todo(bmi, bits, sha1, info, 0, FALSE);
504 }
505
506 static const RECT bias_check[] =
507 {
508 {100, 100, 200, 150},
509 {100, 100, 150, 200},
510 {100, 100, 50, 200},
511 {100, 100, 0, 150},
512 {100, 100, 0, 50},
513 {100, 100, 50, 0},
514 {100, 100, 150, 0},
515 {100, 100, 200, 50}
516 };
517
518 static const RECT hline_clips[] =
519 {
520 {120, 120, 140, 120}, /* unclipped */
521 {100, 122, 140, 122}, /* l edgecase */
522 { 99, 124, 140, 124}, /* l edgecase clipped */
523 {120, 126, 200, 126}, /* r edgecase */
524 {120, 128, 201, 128}, /* r edgecase clipped */
525 { 99, 130, 201, 130}, /* l and r clipped */
526 {120, 100, 140, 100}, /* t edgecase */
527 {120, 99, 140, 99}, /* t edgecase clipped */
528 {120, 199, 140, 199}, /* b edgecase */
529 {120, 200, 140, 200}, /* b edgecase clipped */
530 {120, 132, 310, 132}, /* inside two clip rects */
531 { 10, 134, 101, 134}, /* r end on l edgecase */
532 { 10, 136, 100, 136}, /* r end on l edgecase clipped */
533 {199, 138, 220, 138}, /* l end on r edgecase */
534 {200, 140, 220, 140} /* l end on r edgecase clipped */
535 };
536
537 static const RECT vline_clips[] =
538 {
539 {120, 120, 120, 140}, /* unclipped */
540 {100, 120, 100, 140}, /* l edgecase */
541 { 99, 120, 99, 140}, /* l edgecase clipped */
542 {199, 120, 199, 140}, /* r edgecase */
543 {200, 120, 200, 140}, /* r edgecase clipped */
544 {122, 99, 122, 201}, /* t and b clipped */
545 {124, 100, 124, 140}, /* t edgecase */
546 {126, 99, 126, 140}, /* t edgecase clipped */
547 {128, 120, 128, 200}, /* b edgecase */
548 {130, 120, 130, 201}, /* b edgecase clipped */
549 {132, 12, 132, 140}, /* inside two clip rects */
550 {134, 90, 134, 101}, /* b end on t edgecase */
551 {136, 90, 136, 100}, /* b end on t edgecase clipped */
552 {138, 199, 138, 220}, /* t end on b edgecase */
553 {140, 200, 140, 220} /* t end on b edgecase clipped */
554 };
555
556 static const RECT line_clips[] =
557 {
558 { 90, 110, 310, 120},
559 { 90, 120, 295, 130},
560 { 90, 190, 110, 240}, /* totally clipped, moving outcodes */
561 { 90, 130, 100, 135}, /* totally clipped, end pt on l edge */
562 { 90, 132, 101, 137}, /* end pt just inside l edge */
563 {200, 140, 210, 141}, /* totally clipped, start pt on r edge */
564 {199, 142, 210, 143} /* start pt just inside r edge */
565 };
566
567 static const RECT patblt_clips[] =
568 {
569 {120, 120, 140, 126}, /* unclipped */
570 {100, 130, 140, 136}, /* l edgecase */
571 { 99, 140, 140, 146}, /* l edgecase clipped */
572 {180, 130, 200, 136}, /* r edgecase */
573 {180, 140, 201, 146}, /* r edgecase clipped */
574 {120, 100, 130, 110}, /* t edgecase */
575 {140, 99, 150, 110}, /* t edgecase clipped */
576 {120, 180, 130, 200}, /* b edgecase */
577 {140, 180, 150, 201}, /* b edgecase */
578 {199, 150, 210, 156}, /* l edge on r edgecase */
579 {200, 160, 210, 166}, /* l edge on r edgecase clipped */
580 { 90, 150, 101, 156}, /* r edge on l edgecase */
581 { 90, 160, 100, 166}, /* r edge on l edgecase clipped */
582 {160, 90, 166, 101}, /* b edge on t edgecase */
583 {170, 90, 176, 101}, /* b edge on t edgecase clipped */
584 {160, 199, 166, 210}, /* t edge on b edgecase */
585 {170, 200, 176, 210}, /* t edge on b edgecase clipped */
586 };
587
588 static const RECT rectangles[] =
589 {
590 {10, 11, 100, 101},
591 {250, 100, 350, 10},
592 {120, 10, 120, 20}, /* zero width */
593 {120, 10, 130, 10}, /* zero height */
594 {120, 40, 121, 41}, /* 1 x 1 */
595 {130, 50, 132, 52}, /* 2 x 2 */
596 {140, 60, 143, 63}, /* 3 x 3 */
597 {150, 70, 154, 74}, /* 4 x 4 */
598 {120, 20, 121, 30}, /* width == 1 */
599 {130, 20, 132, 30}, /* width == 2 */
600 {140, 20, 143, 30}, /* width == 3 */
601 {200, 20, 210, 21}, /* height == 1 */
602 {200, 30, 210, 32}, /* height == 2 */
603 {200, 40, 210, 43} /* height == 3 */
604 };
605
606 static const BITMAPINFOHEADER dib_brush_header_8888 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0};
607 static const BITMAPINFOHEADER dib_brush_header_24 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 24, BI_RGB, 0, 0, 0, 0, 0};
608 static const BITMAPINFOHEADER dib_brush_header_555 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 16, BI_RGB, 0, 0, 0, 0, 0};
609 static const BITMAPINFOHEADER dib_brush_header_8 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 8, BI_RGB, 0, 0, 0, 0, 0};
610 static const BITMAPINFOHEADER dib_brush_header_4 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 4, BI_RGB, 0, 0, 0, 0, 0};
611 static const BITMAPINFOHEADER dib_brush_header_1 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 1, BI_RGB, 0, 0, 0, 0, 0};
612
613 static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sha1)
614 {
615 DWORD dib_size = get_dib_size(bmi);
616 HPEN solid_pen, dashed_pen, orig_pen;
617 HBRUSH solid_brush, dib_brush, hatch_brush, orig_brush;
618 INT i, y, hatch_style;
619 HRGN hrgn, hrgn2;
620 BYTE dib_brush_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD) + 16 * 16 * sizeof(DWORD)]; /* Enough for 16 x 16 at 32 bpp */
621 BITMAPINFO *brush_bi = (BITMAPINFO*)dib_brush_buf;
622 BYTE *brush_bits;
623 BOOL dib_is_1bpp = (bmi->bmiHeader.biBitCount == 1);
624
625 memset(bits, 0xcc, dib_size);
626 compare_hash(bmi, bits, sha1, "empty");
627
628 solid_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0xff));
629 orig_pen = SelectObject(hdc, solid_pen);
630 SetBrushOrgEx(hdc, 0, 0, NULL);
631
632 /* horizontal and vertical lines */
633 for(i = 1; i <= 16; i++)
634 {
635 SetROP2(hdc, i);
636 MoveToEx(hdc, 10, i * 3, NULL);
637 LineTo(hdc, 100, i * 3); /* l -> r */
638 MoveToEx(hdc, 100, 50 + i * 3, NULL);
639 LineTo(hdc, 10, 50 + i * 3); /* r -> l */
640 MoveToEx(hdc, 120 + i * 3, 10, NULL);
641 LineTo(hdc, 120 + i * 3, 100); /* t -> b */
642 MoveToEx(hdc, 170 + i * 3, 100, NULL);
643 LineTo(hdc, 170 + i * 3, 10); /* b -> t */
644 }
645 compare_hash(bmi, bits, sha1, "h and v solid lines");
646 memset(bits, 0xcc, dib_size);
647
648 /* diagonal lines */
649 SetROP2(hdc, R2_COPYPEN);
650 for(i = 0; i < 16; i++)
651 {
652 double s = sin(M_PI * i / 8.0);
653 double c = cos(M_PI * i / 8.0);
654
655 MoveToEx(hdc, 200.5 + 10 * c, 200.5 + 10 * s, NULL);
656 LineTo(hdc, 200.5 + 100 * c, 200.5 + 100 * s);
657 }
658 compare_hash(bmi, bits, sha1, "diagonal solid lines");
659 memset(bits, 0xcc, dib_size);
660
661 for(i = 0; i < sizeof(bias_check) / sizeof(bias_check[0]); i++)
662 {
663 MoveToEx(hdc, bias_check[i].left, bias_check[i].top, NULL);
664 LineTo(hdc, bias_check[i].right, bias_check[i].bottom);
665 }
666 compare_hash(bmi, bits, sha1, "more diagonal solid lines");
667 memset(bits, 0xcc, dib_size);
668
669 /* solid brush PatBlt */
670 solid_brush = CreateSolidBrush(RGB(0x33, 0xaa, 0xff));
671 orig_brush = SelectObject(hdc, solid_brush);
672
673 for(i = 0, y = 10; i < 256; i++)
674 {
675 BOOL ret;
676
677 ret = PatBlt(hdc, 10, y, 100, 10, rop3[i]);
678
679 if(rop_uses_src(rop3[i]))
680 ok(ret == FALSE, "got TRUE for %x\n", rop3[i]);
681 else
682 {
683 ok(ret, "got FALSE for %x\n", rop3[i]);
684 y += 20;
685 }
686
687 }
688 compare_hash(bmi, bits, sha1, "solid patblt");
689 memset(bits, 0xcc, dib_size);
690
691 /* clipped lines */
692 hrgn = CreateRectRgn(10, 10, 200, 20);
693 hrgn2 = CreateRectRgn(100, 100, 200, 200);
694 CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
695 SetRectRgn(hrgn2, 290, 100, 300, 200);
696 CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
697 ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
698 DeleteObject(hrgn2);
699
700 for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
701 {
702 MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
703 LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
704 }
705 compare_hash(bmi, bits, sha1, "clipped solid hlines");
706 memset(bits, 0xcc, dib_size);
707
708 for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
709 {
710 MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
711 LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
712 }
713 compare_hash(bmi, bits, sha1, "clipped solid vlines");
714 memset(bits, 0xcc, dib_size);
715
716 for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
717 {
718 MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
719 LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
720 }
721 compare_hash(bmi, bits, sha1, "clipped solid diagonal lines");
722 memset(bits, 0xcc, dib_size);
723
724 /* clipped PatBlt */
725 for(i = 0; i < sizeof(patblt_clips) / sizeof(patblt_clips[0]); i++)
726 {
727 PatBlt(hdc, patblt_clips[i].left, patblt_clips[i].top,
728 patblt_clips[i].right - patblt_clips[i].left,
729 patblt_clips[i].bottom - patblt_clips[i].top, PATCOPY);
730 }
731 compare_hash(bmi, bits, sha1, "clipped patblt");
732 memset(bits, 0xcc, dib_size);
733
734 /* clipped dashed lines */
735 dashed_pen = CreatePen(PS_DASH, 1, RGB(0xff, 0, 0));
736 SelectObject(hdc, dashed_pen);
737 SetBkMode(hdc, TRANSPARENT);
738 SetBkColor(hdc, RGB(0, 0xff, 0));
739
740 for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
741 {
742 MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
743 LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
744 }
745 compare_hash(bmi, bits, sha1, "clipped dashed hlines");
746 memset(bits, 0xcc, dib_size);
747
748 for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
749 {
750 MoveToEx(hdc, hline_clips[i].right - 1, hline_clips[i].bottom, NULL);
751 LineTo(hdc, hline_clips[i].left - 1, hline_clips[i].top);
752 }
753 compare_hash(bmi, bits, sha1, "clipped dashed hlines r -> l");
754 memset(bits, 0xcc, dib_size);
755
756 for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
757 {
758 MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
759 LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
760 }
761 compare_hash(bmi, bits, sha1, "clipped dashed vlines");
762 memset(bits, 0xcc, dib_size);
763
764 for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
765 {
766 MoveToEx(hdc, vline_clips[i].right, vline_clips[i].bottom - 1, NULL);
767 LineTo(hdc, vline_clips[i].left, vline_clips[i].top - 1);
768 }
769 compare_hash(bmi, bits, sha1, "clipped dashed vlines b -> t");
770 memset(bits, 0xcc, dib_size);
771
772 for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
773 {
774 MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
775 LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
776 }
777 compare_hash(bmi, bits, sha1, "clipped dashed diagonal lines");
778 memset(bits, 0xcc, dib_size);
779
780 SetBkMode(hdc, OPAQUE);
781
782 for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
783 {
784 MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
785 LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
786 }
787 compare_hash(bmi, bits, sha1, "clipped opaque dashed diagonal lines");
788 memset(bits, 0xcc, dib_size);
789
790 ExtSelectClipRgn(hdc, NULL, RGN_COPY);
791
792 /* 8888 DIB pattern brush */
793
794 brush_bi->bmiHeader = dib_brush_header_8888;
795 brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
796 memset(brush_bits, 0, 16 * 16 * sizeof(DWORD));
797 brush_bits[2] = 0xff;
798 brush_bits[6] = 0xff;
799 brush_bits[14] = 0xff;
800 brush_bits[65] = 0xff;
801 brush_bits[69] = 0xff;
802 brush_bits[72] = 0xff;
803
804 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
805
806 SelectObject(hdc, dib_brush);
807 SetBrushOrgEx(hdc, 1, 1, NULL);
808
809 for(i = 0, y = 10; i < 256; i++)
810 {
811 BOOL ret;
812
813 if(!rop_uses_src(rop3[i]))
814 {
815 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
816 ok(ret, "got FALSE for %x\n", rop3[i]);
817 y += 25;
818 }
819 }
820 compare_hash_broken_todo(bmi, bits, sha1, "top-down 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
821 memset(bits, 0xcc, dib_size);
822
823 SelectObject(hdc, orig_brush);
824 DeleteObject(dib_brush);
825
826 /* 8888 bottom-up DIB pattern brush */
827
828 brush_bi->bmiHeader.biHeight = -brush_bi->bmiHeader.biHeight;
829
830 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
831
832 SelectObject(hdc, dib_brush);
833
834 /* This used to set the x origin to 100 as well, but
835 there's a Windows bug for 24 bpp where the brush's x offset
836 is incorrectly calculated for rops that involve both D and P */
837 SetBrushOrgEx(hdc, 4, 100, NULL);
838
839 for(i = 0, y = 10; i < 256; i++)
840 {
841 BOOL ret;
842
843 if(!rop_uses_src(rop3[i]))
844 {
845 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
846 ok(ret, "got FALSE for %x\n", rop3[i]);
847 y += 25;
848 }
849 }
850 compare_hash_broken_todo(bmi, bits, sha1, "bottom-up 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
851 memset(bits, 0xcc, dib_size);
852
853 SelectObject(hdc, orig_brush);
854 DeleteObject(dib_brush);
855
856 /* 24 bpp dib pattern brush */
857
858 brush_bi->bmiHeader = dib_brush_header_24;
859 brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
860 memset(brush_bits, 0, 16 * 16 * 3);
861 brush_bits[0] = brush_bits[3] = brush_bits[6] = brush_bits[8] = 0xff;
862 brush_bits[49] = brush_bits[52] = 0xff;
863
864 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
865
866 SelectObject(hdc, dib_brush);
867 SetBrushOrgEx(hdc, 1, 1, NULL);
868
869 for(i = 0, y = 10; i < 256; i++)
870 {
871 BOOL ret;
872
873 if(!rop_uses_src(rop3[i]))
874 {
875 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
876 ok(ret, "got FALSE for %x\n", rop3[i]);
877 y += 25;
878 }
879 }
880 compare_hash_broken_todo(bmi, bits, sha1, "top-down 24 bpp brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
881 memset(bits, 0xcc, dib_size);
882
883 SelectObject(hdc, orig_brush);
884 DeleteObject(dib_brush);
885
886 /* 555 dib pattern brush */
887
888 brush_bi->bmiHeader = dib_brush_header_555;
889 brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
890 memset(brush_bits, 0, 16 * 16 * sizeof(WORD));
891 brush_bits[0] = brush_bits[1] = 0xff;
892 brush_bits[32] = brush_bits[34] = 0x7c;
893
894 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
895
896 SelectObject(hdc, dib_brush);
897 SetBrushOrgEx(hdc, 1, 1, NULL);
898
899 for(i = 0, y = 10; i < 256; i++)
900 {
901 BOOL ret;
902
903 if(!rop_uses_src(rop3[i]))
904 {
905 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
906 ok(ret, "got FALSE for %x\n", rop3[i]);
907 y += 25;
908 }
909 }
910 compare_hash_broken_todo(bmi, bits, sha1, "top-down 555 dib brush patblt", dib_is_1bpp ? 1 : 0, dib_is_1bpp);
911 memset(bits, 0xcc, dib_size);
912
913 SelectObject(hdc, orig_brush);
914 DeleteObject(dib_brush);
915
916 SetBrushOrgEx(hdc, 0, 0, NULL);
917
918 /* 8 bpp dib pattern brush */
919
920 brush_bi->bmiHeader = dib_brush_header_8;
921 brush_bi->bmiHeader.biClrUsed = 3;
922 memset(brush_bi->bmiColors, 0, brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD));
923 brush_bi->bmiColors[0].rgbRed = 0xff;
924 brush_bi->bmiColors[1].rgbRed = 0xff;
925 brush_bi->bmiColors[1].rgbGreen = 0xff;
926 brush_bi->bmiColors[1].rgbBlue = 0xff;
927
928 brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER) + brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD);
929 memset(brush_bits, 0, 16 * 16 * sizeof(BYTE));
930 brush_bits[0] = brush_bits[1] = 1;
931 brush_bits[16] = brush_bits[17] = 2;
932 brush_bits[32] = brush_bits[33] = 6;
933
934 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
935
936 SelectObject(hdc, dib_brush);
937 SetBrushOrgEx(hdc, 1, 1, NULL);
938
939 for(i = 0, y = 10; i < 256; i++)
940 {
941 BOOL ret;
942
943 if(!rop_uses_src(rop3[i]))
944 {
945 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
946 ok(ret, "got FALSE for %x\n", rop3[i]);
947 y += 25;
948 }
949 }
950 compare_hash_broken_todo(bmi, bits, sha1, "top-down 8 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
951 memset(bits, 0xcc, dib_size);
952
953 SelectObject(hdc, orig_brush);
954 DeleteObject(dib_brush);
955
956 /* 4 bpp dib pattern brush */
957
958 brush_bi->bmiHeader = dib_brush_header_4;
959 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
960
961 SelectObject(hdc, dib_brush);
962 SetBrushOrgEx(hdc, 1, 1, NULL);
963
964 for(i = 0, y = 10; i < 256; i++)
965 {
966 BOOL ret;
967
968 if(!rop_uses_src(rop3[i]))
969 {
970 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
971 ok(ret, "got FALSE for %x\n", rop3[i]);
972 y += 25;
973 }
974 }
975 compare_hash_broken_todo(bmi, bits, sha1, "top-down 4 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
976 memset(bits, 0xcc, dib_size);
977
978 SelectObject(hdc, orig_brush);
979 DeleteObject(dib_brush);
980
981 /* 1 bpp dib pattern brush */
982
983 brush_bi->bmiHeader = dib_brush_header_1;
984 brush_bi->bmiHeader.biClrUsed = 2;
985 memset(brush_bits, 0, 16 * 4);
986 brush_bits[0] = 0xf0;
987 brush_bits[4] = 0xf0;
988 brush_bits[8] = 0xf0;
989
990 dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
991 SelectObject(hdc, dib_brush);
992 for(i = 0, y = 10; i < 256; i++)
993 {
994 BOOL ret;
995
996 if(!rop_uses_src(rop3[i]))
997 {
998 ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
999 ok(ret, "got FALSE for %x\n", rop3[i]);
1000 y += 25;
1001 }
1002 }
1003
1004 compare_hash_broken_todo(bmi, bits, sha1, "top-down 1 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
1005 memset(bits, 0xcc, dib_size);
1006
1007 SelectObject(hdc, orig_brush);
1008 SetBrushOrgEx(hdc, 0, 0, NULL);
1009
1010 /* Rectangle */
1011
1012 SelectObject(hdc, solid_pen);
1013 SelectObject(hdc, solid_brush);
1014
1015 for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
1016 {
1017 Rectangle(hdc, rectangles[i].left, rectangles[i].top, rectangles[i].right, rectangles[i].bottom);
1018 }
1019
1020 SelectObject(hdc, dashed_pen);
1021 for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
1022 {
1023 Rectangle(hdc, rectangles[i].left, rectangles[i].top + 150, rectangles[i].right, rectangles[i].bottom + 150);
1024 }
1025
1026 compare_hash(bmi, bits, sha1, "rectangles");
1027 memset(bits, 0xcc, dib_size);
1028 SelectObject(hdc, solid_pen);
1029
1030 /* PaintRgn */
1031
1032 PaintRgn(hdc, hrgn);
1033 compare_hash(bmi, bits, sha1, "PaintRgn");
1034 memset(bits, 0xcc, dib_size);
1035
1036 /* RTL rectangles */
1037
1038 if( !pSetLayout )
1039 {
1040 win_skip("Don't have SetLayout\n");
1041 (*sha1)++;
1042 }
1043 else
1044 {
1045 pSetLayout(hdc, LAYOUT_RTL);
1046 PaintRgn(hdc, hrgn);
1047 PatBlt(hdc, 10, 250, 10, 10, PATCOPY);
1048 Rectangle(hdc, 100, 250, 110, 260);
1049 compare_hash(bmi, bits, sha1, "rtl");
1050 memset(bits, 0xcc, dib_size);
1051
1052 pSetLayout(hdc, LAYOUT_LTR);
1053 }
1054
1055 for(i = 0, y = 10; i < 256; i++)
1056 {
1057 BOOL ret;
1058
1059 if(!rop_uses_src(rop3[i]))
1060 {
1061 for(hatch_style = HS_HORIZONTAL; hatch_style <= HS_DIAGCROSS; hatch_style++)
1062 {
1063 hatch_brush = CreateHatchBrush(hatch_style, RGB(0xff, 0, 0));
1064 SelectObject(hdc, hatch_brush);
1065 ret = PatBlt(hdc, 10 + i + 30 * hatch_style, y, 20, 20, rop3[i]);
1066 ok(ret, "got FALSE for %x\n", rop3[i]);
1067 SelectObject(hdc, orig_brush);
1068 DeleteObject(hatch_brush);
1069 }
1070 y += 25;
1071 }
1072 }
1073
1074 compare_hash_broken_todo(bmi, bits, sha1, "hatch brushes", 1, FALSE); /* nt4 is different */
1075 memset(bits, 0xcc, dib_size);
1076
1077 /* overlapping blits */
1078
1079 orig_brush = SelectObject(hdc, solid_brush);
1080
1081 Rectangle(hdc, 10, 10, 100, 100);
1082 Rectangle(hdc, 20, 15, 30, 40);
1083 Rectangle(hdc, 15, 15, 20, 20);
1084 Rectangle(hdc, 15, 20, 50, 45);
1085 BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, SRCCOPY );
1086 compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY +x, +y");
1087 memset(bits, 0xcc, dib_size);
1088
1089 Rectangle(hdc, 10, 10, 100, 100);
1090 Rectangle(hdc, 20, 15, 30, 40);
1091 Rectangle(hdc, 15, 15, 20, 20);
1092 Rectangle(hdc, 15, 20, 50, 45);
1093 BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, SRCCOPY );
1094 if (bmi->bmiHeader.biBitCount == 1) /* Windows gets this one wrong */
1095 compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, -y",1, FALSE);
1096 else
1097 compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, -y");
1098 memset(bits, 0xcc, dib_size);
1099
1100 Rectangle(hdc, 10, 10, 100, 100);
1101 Rectangle(hdc, 20, 15, 30, 40);
1102 Rectangle(hdc, 15, 15, 20, 20);
1103 Rectangle(hdc, 15, 20, 50, 45);
1104 BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, SRCCOPY );
1105 compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY +x, -y");
1106 memset(bits, 0xcc, dib_size);
1107
1108 Rectangle(hdc, 10, 10, 100, 100);
1109 Rectangle(hdc, 20, 15, 30, 40);
1110 Rectangle(hdc, 15, 15, 20, 20);
1111 Rectangle(hdc, 15, 20, 50, 45);
1112 BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, SRCCOPY );
1113 if (bmi->bmiHeader.biBitCount == 1) /* Windows gets this one wrong */
1114 compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, +y", 1, FALSE );
1115 else
1116 compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, +y" );
1117 memset(bits, 0xcc, dib_size);
1118
1119 Rectangle(hdc, 10, 10, 100, 100);
1120 Rectangle(hdc, 20, 15, 30, 40);
1121 Rectangle(hdc, 15, 15, 20, 20);
1122 Rectangle(hdc, 15, 20, 50, 45);
1123 BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, PATPAINT );
1124 compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, +y");
1125 memset(bits, 0xcc, dib_size);
1126
1127 Rectangle(hdc, 10, 10, 100, 100);
1128 Rectangle(hdc, 20, 15, 30, 40);
1129 Rectangle(hdc, 15, 15, 20, 20);
1130 Rectangle(hdc, 15, 20, 50, 45);
1131 BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, PATPAINT );
1132 compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT -x, -y");
1133 memset(bits, 0xcc, dib_size);
1134
1135 Rectangle(hdc, 10, 10, 100, 100);
1136 Rectangle(hdc, 20, 15, 30, 40);
1137 Rectangle(hdc, 15, 15, 20, 20);
1138 Rectangle(hdc, 15, 20, 50, 45);
1139 BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, PATPAINT );
1140 if (bmi->bmiHeader.biBitCount >= 24) /* Windows gets this one wrong */
1141 compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, -y", 1, FALSE);
1142 else
1143 compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, -y");
1144 memset(bits, 0xcc, dib_size);
1145
1146 Rectangle(hdc, 10, 10, 100, 100);
1147 Rectangle(hdc, 20, 15, 30, 40);
1148 Rectangle(hdc, 15, 15, 20, 20);
1149 Rectangle(hdc, 15, 20, 50, 45);
1150 BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, PATPAINT );
1151 compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT -x, +y" );
1152 memset(bits, 0xcc, dib_size);
1153
1154 SelectObject(hdc, orig_brush);
1155 SelectObject(hdc, orig_pen);
1156 DeleteObject(hrgn);
1157 DeleteObject(dib_brush);
1158 DeleteObject(dashed_pen);
1159 DeleteObject(solid_brush);
1160 DeleteObject(solid_pen);
1161 }
1162
1163 static void test_simple_graphics(void)
1164 {
1165 char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
1166 BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
1167 DWORD *bit_fields = (DWORD*)(bmibuf + sizeof(BITMAPINFOHEADER));
1168 HDC mem_dc;
1169 BYTE *bits;
1170 HBITMAP dib, orig_bm;
1171 const char **sha1;
1172 DIBSECTION ds;
1173
1174 mem_dc = CreateCompatibleDC(NULL);
1175
1176 /* a8r8g8b8 */
1177 trace("8888\n");
1178 memset(bmi, 0, sizeof(bmibuf));
1179 bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
1180 bmi->bmiHeader.biHeight = 512;
1181 bmi->bmiHeader.biWidth = 512;
1182 bmi->bmiHeader.biBitCount = 32;
1183 bmi->bmiHeader.biPlanes = 1;
1184 bmi->bmiHeader.biCompression = BI_RGB;
1185
1186 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1187 ok(dib != NULL, "ret NULL\n");
1188 ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1189 ok(ds.dsBitfields[0] == 0, "got %08x\n", ds.dsBitfields[0]);
1190 ok(ds.dsBitfields[1] == 0, "got %08x\n", ds.dsBitfields[1]);
1191 ok(ds.dsBitfields[2] == 0, "got %08x\n", ds.dsBitfields[2]);
1192 ok(ds.dsBmih.biCompression == BI_RGB ||
1193 broken(ds.dsBmih.biCompression == BI_BITFIELDS), /* nt4 sp1 and 2 */
1194 "got %x\n", ds.dsBmih.biCompression);
1195
1196 orig_bm = SelectObject(mem_dc, dib);
1197
1198 sha1 = sha1_graphics_a8r8g8b8;
1199 draw_graphics(mem_dc, bmi, bits, &sha1);
1200
1201 SelectObject(mem_dc, orig_bm);
1202 DeleteObject(dib);
1203
1204 /* a8r8g8b8 - bitfields. Should be the same as the regular 32 bit case.*/
1205 trace("8888 - bitfields\n");
1206 bmi->bmiHeader.biBitCount = 32;
1207 bmi->bmiHeader.biCompression = BI_BITFIELDS;
1208 bit_fields[0] = 0xff0000;
1209 bit_fields[1] = 0x00ff00;
1210 bit_fields[2] = 0x0000ff;
1211
1212 dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1213 ok(dib != NULL, "ret NULL\n");
1214 ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1215 ok(ds.dsBitfields[0] == 0xff0000, "got %08x\n", ds.dsBitfields[0]);
1216 ok(ds.dsBitfields[1] == 0x00ff00, "got %08x\n", ds.dsBitfields[1]);
1217 ok(ds.dsBitfields[2] == 0x0000ff, "got %08x\n", ds.dsBitfields[2]);
1218 ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1219
1220 orig_bm = SelectObject(mem_dc, dib);
1221
1222 sha1 = sha1_graphics_a8r8g8b8;
1223 draw_graphics(mem_dc, bmi, bits, &sha1);
1224
1225 SelectObject(mem_dc, orig_bm);
1226 DeleteObject(dib);
1227
1228 /* a8b8g8r8 - bitfields. */
1229 trace("a8b8g8r8 - bitfields\n");
1230 bmi->bmiHeader.biBitCount = 32;
1231 bmi->bmiHeader.biCompression = BI_BITFIELDS;
1232 bit_fields[0] = 0x0000ff;
1233 bit_fields[1] = 0x00ff00;
1234 bit_fields[2] = 0xff0000;
1235
1236 dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1237 ok(dib != NULL, "ret NULL\n");
1238 ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1239 ok(ds.dsBitfields[0] == 0x0000ff, "got %08x\n", ds.dsBitfields[0]);
1240 ok(ds.dsBitfields[1] == 0x00ff00, "got %08x\n", ds.dsBitfields[1]);
1241 ok(ds.dsBitfields[2] == 0xff0000, "got %08x\n", ds.dsBitfields[2]);
1242 ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1243
1244 orig_bm = SelectObject(mem_dc, dib);
1245
1246 sha1 = sha1_graphics_a8b8g8r8;
1247 draw_graphics(mem_dc, bmi, bits, &sha1);
1248
1249 SelectObject(mem_dc, orig_bm);
1250 DeleteObject(dib);
1251
1252 /* 24 */
1253 trace("24\n");
1254 bmi->bmiHeader.biBitCount = 24;
1255 bmi->bmiHeader.biCompression = BI_RGB;
1256
1257 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1258 ok(dib != NULL, "ret NULL\n");
1259 orig_bm = SelectObject(mem_dc, dib);
1260
1261 sha1 = sha1_graphics_24;
1262 draw_graphics(mem_dc, bmi, bits, &sha1);
1263
1264 SelectObject(mem_dc, orig_bm);
1265 DeleteObject(dib);
1266
1267 /* r5g5b5 */
1268 trace("555\n");
1269 bmi->bmiHeader.biBitCount = 16;
1270 bmi->bmiHeader.biCompression = BI_RGB;
1271
1272 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1273 ok(dib != NULL, "ret NULL\n");
1274 ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1275 ok(ds.dsBitfields[0] == 0x7c00, "got %08x\n", ds.dsBitfields[0]);
1276 ok(ds.dsBitfields[1] == 0x03e0, "got %08x\n", ds.dsBitfields[1]);
1277 ok(ds.dsBitfields[2] == 0x001f, "got %08x\n", ds.dsBitfields[2]);
1278 ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1279
1280 orig_bm = SelectObject(mem_dc, dib);
1281
1282 sha1 = sha1_graphics_r5g5b5;
1283 draw_graphics(mem_dc, bmi, bits, &sha1);
1284
1285 SelectObject(mem_dc, orig_bm);
1286 DeleteObject(dib);
1287
1288 /* r4g4b4 */
1289 trace("444\n");
1290 bmi->bmiHeader.biBitCount = 16;
1291 bmi->bmiHeader.biCompression = BI_BITFIELDS;
1292 bit_fields[0] = 0x0f00;
1293 bit_fields[1] = 0x00f0;
1294 bit_fields[2] = 0x000f;
1295 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1296 ok(dib != NULL, "ret NULL\n");
1297 ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1298 ok(ds.dsBitfields[0] == 0x0f00, "got %08x\n", ds.dsBitfields[0]);
1299 ok(ds.dsBitfields[1] == 0x00f0, "got %08x\n", ds.dsBitfields[1]);
1300 ok(ds.dsBitfields[2] == 0x000f, "got %08x\n", ds.dsBitfields[2]);
1301 ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1302
1303 orig_bm = SelectObject(mem_dc, dib);
1304
1305 sha1 = sha1_graphics_r4g4b4;
1306 draw_graphics(mem_dc, bmi, bits, &sha1);
1307
1308 SelectObject(mem_dc, orig_bm);
1309 DeleteObject(dib);
1310
1311 /* 8 */
1312 trace("8\n");
1313 bmi->bmiHeader.biBitCount = 8;
1314 bmi->bmiHeader.biCompression = BI_RGB;
1315 bmi->bmiHeader.biClrUsed = 5;
1316 bmi->bmiColors[0].rgbRed = 0xff;
1317 bmi->bmiColors[0].rgbGreen = 0xff;
1318 bmi->bmiColors[0].rgbBlue = 0xff;
1319 bmi->bmiColors[1].rgbRed = 0;
1320 bmi->bmiColors[1].rgbGreen = 0;
1321 bmi->bmiColors[1].rgbBlue = 0;
1322 bmi->bmiColors[2].rgbRed = 0xff;
1323 bmi->bmiColors[2].rgbGreen = 0;
1324 bmi->bmiColors[2].rgbBlue = 0;
1325 bmi->bmiColors[3].rgbRed = 0;
1326 bmi->bmiColors[3].rgbGreen = 0xff;
1327 bmi->bmiColors[3].rgbBlue = 0;
1328 bmi->bmiColors[4].rgbRed = 0;
1329 bmi->bmiColors[4].rgbGreen = 0;
1330 bmi->bmiColors[4].rgbBlue = 0xff;
1331
1332 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1333 ok(dib != NULL, "ret NULL\n");
1334
1335 orig_bm = SelectObject(mem_dc, dib);
1336
1337 sha1 = sha1_graphics_8;
1338 draw_graphics(mem_dc, bmi, bits, &sha1);
1339
1340 SelectObject(mem_dc, orig_bm);
1341 DeleteObject(dib);
1342
1343 /* 4 */
1344 trace("4\n");
1345 bmi->bmiHeader.biBitCount = 4;
1346
1347 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1348 ok(dib != NULL, "ret NULL\n");
1349
1350 orig_bm = SelectObject(mem_dc, dib);
1351
1352 sha1 = sha1_graphics_4;
1353 draw_graphics(mem_dc, bmi, bits, &sha1);
1354
1355 SelectObject(mem_dc, orig_bm);
1356 DeleteObject(dib);
1357
1358 /* 1 */
1359 trace("1\n");
1360 bmi->bmiHeader.biBitCount = 1;
1361 bmi->bmiHeader.biClrUsed = 2;
1362
1363 bmi->bmiColors[0].rgbRed = 0x00;
1364 bmi->bmiColors[0].rgbGreen = 0x01;
1365 bmi->bmiColors[0].rgbBlue = 0xff;
1366 bmi->bmiColors[1].rgbRed = 0xff;
1367 bmi->bmiColors[1].rgbGreen = 0x00;
1368 bmi->bmiColors[1].rgbBlue = 0x00;
1369
1370 dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1371 ok(dib != NULL, "ret NULL\n");
1372
1373 orig_bm = SelectObject(mem_dc, dib);
1374
1375 sha1 = sha1_graphics_1;
1376 draw_graphics(mem_dc, bmi, bits, &sha1);
1377
1378 SelectObject(mem_dc, orig_bm);
1379 DeleteObject(dib);
1380
1381 DeleteDC(mem_dc);
1382 }
1383
1384 START_TEST(dib)
1385 {
1386 HMODULE mod = GetModuleHandleA("gdi32.dll");
1387 pSetLayout = (void *)GetProcAddress( mod, "SetLayout" );
1388
1389 CryptAcquireContextW(&crypt_prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
1390
1391 test_simple_graphics();
1392
1393 CryptReleaseContext(crypt_prov, 0);
1394 }