ReactOS  0.4.14-dev-342-gdc047f9
palette.c
Go to the documentation of this file.
1 /*
2  * Copyright 2009 Vincent Povirk for CodeWeavers
3  * Copyright 2012,2016 Dmitry Timoshkov
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19 
20 #include <stdarg.h>
21 #include <assert.h>
22 
23 #define COBJMACROS
24 
25 #include "windef.h"
26 #include "objbase.h"
27 #include "wincodec.h"
28 #include "wine/test.h"
29 
31 
32 static void test_custom_palette(void)
33 {
34  IWICPalette *palette, *palette2;
35  HRESULT hr;
36  WICBitmapPaletteType type=0xffffffff;
37  UINT count=1;
38  const WICColor initcolors[4]={0xff000000,0xff0000ff,0xffffff00,0xffffffff};
39  WICColor colors[4];
40  BOOL boolresult;
41 
42  hr = IWICImagingFactory_CreatePalette(factory, &palette);
43  ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
44  if (SUCCEEDED(hr))
45  {
46  hr = IWICPalette_GetType(palette, &type);
47  ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
48  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
49 
50  hr = IWICPalette_GetColorCount(palette, &count);
51  ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
52  ok(count == 0, "expected 0, got %u\n", count);
53 
54  hr = IWICPalette_GetColors(palette, 0, colors, &count);
55  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
56  ok(count == 0, "expected 0, got %u\n", count);
57 
58  hr = IWICPalette_GetColors(palette, 4, colors, &count);
59  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
60  ok(count == 0, "expected 0, got %u\n", count);
61 
62  memcpy(colors, initcolors, sizeof(initcolors));
63  hr = IWICPalette_InitializeCustom(palette, colors, 4);
64  ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
65 
66  hr = IWICPalette_GetType(palette, &type);
67  ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
68  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
69 
70  hr = IWICPalette_GetColorCount(palette, &count);
71  ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
72  ok(count == 4, "expected 4, got %u\n", count);
73 
74  memset(colors, 0, sizeof(colors));
75  count = 0;
76  hr = IWICPalette_GetColors(palette, 4, colors, &count);
77  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
78  ok(count == 4, "expected 4, got %u\n", count);
79  ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
80 
81  memset(colors, 0, sizeof(colors));
82  count = 0;
83  hr = IWICPalette_GetColors(palette, 2, colors, &count);
84  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
85  ok(count == 2, "expected 2, got %u\n", count);
86  ok(!memcmp(colors, initcolors, sizeof(WICColor)*2), "got unexpected palette data\n");
87 
88  count = 0;
89  hr = IWICPalette_GetColors(palette, 6, colors, &count);
90  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
91  ok(count == 4, "expected 4, got %u\n", count);
92 
93  hr = IWICPalette_HasAlpha(palette, &boolresult);
94  ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
95  ok(!boolresult, "expected FALSE, got TRUE\n");
96 
97  hr = IWICPalette_IsBlackWhite(palette, &boolresult);
98  ok(SUCCEEDED(hr), "IsBlackWhite failed, hr=%x\n", hr);
99  ok(!boolresult, "expected FALSE, got TRUE\n");
100 
101  hr = IWICPalette_IsGrayscale(palette, &boolresult);
102  ok(SUCCEEDED(hr), "IsGrayscale failed, hr=%x\n", hr);
103  ok(!boolresult, "expected FALSE, got TRUE\n");
104 
105  hr = IWICImagingFactory_CreatePalette(factory, &palette2);
106  ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
107 
108  hr = IWICPalette_InitializeFromPalette(palette2, palette);
109  ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
110 
111  type = 0xdeadbeef;
112  hr = IWICPalette_GetType(palette2, &type);
113  ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
114  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
115 
116  count = 0xdeadbeef;
117  hr = IWICPalette_GetColorCount(palette2, &count);
118  ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
119  ok(count == 4, "expected 4, got %u\n", count);
120 
121  memset(colors, 0, sizeof(colors));
122  count = 0xdeadbeef;
123  hr = IWICPalette_GetColors(palette2, 4, colors, &count);
124  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
125  ok(count == 4, "expected 4, got %u\n", count);
126  ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
127 
128  /* try a palette with some alpha in it */
129  colors[2] = 0x80ffffff;
130  hr = IWICPalette_InitializeCustom(palette, colors, 4);
131  ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
132 
133  hr = IWICPalette_HasAlpha(palette, &boolresult);
134  ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
135  ok(boolresult, "expected TRUE, got FALSE\n");
136 
137  /* setting to a 0-color palette is acceptable */
138  hr = IWICPalette_InitializeCustom(palette, NULL, 0);
139  ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
140 
141  type = 0xdeadbeef;
142  hr = IWICPalette_GetType(palette, &type);
143  ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
144  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
145 
146  count = 0xdeadbeef;
147  hr = IWICPalette_GetColorCount(palette, &count);
148  ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
149  ok(count == 0, "expected 0, got %u\n", count);
150 
151  count = 0xdeadbeef;
152  hr = IWICPalette_GetColors(palette, 4, colors, &count);
153  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
154  ok(count == 0, "expected 0, got %u\n", count);
155 
156  hr = IWICPalette_InitializeFromPalette(palette2, palette);
157  ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
158 
159  type = 0xdeadbeef;
160  hr = IWICPalette_GetType(palette2, &type);
161  ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
162  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
163 
164  count = 0xdeadbeef;
165  hr = IWICPalette_GetColorCount(palette2, &count);
166  ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
167  ok(count == 0, "expected 0, got %u\n", count);
168 
169  memset(colors, 0, sizeof(colors));
170  count = 0xdeadbeef;
171  hr = IWICPalette_GetColors(palette2, 4, colors, &count);
172  ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
173  ok(count == 0, "expected 0, got %u\n", count);
174 
175  /* IWICPalette is paranoid about NULL pointers */
176  hr = IWICPalette_GetType(palette, NULL);
177  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
178 
179  hr = IWICPalette_GetColorCount(palette, NULL);
180  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
181 
182  hr = IWICPalette_InitializeCustom(palette, NULL, 4);
183  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
184 
185  hr = IWICPalette_GetColors(palette, 4, NULL, &count);
186  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
187 
188  hr = IWICPalette_GetColors(palette, 4, colors, NULL);
189  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
190 
191  hr = IWICPalette_HasAlpha(palette, NULL);
192  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
193 
194  hr = IWICPalette_IsBlackWhite(palette, NULL);
195  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
196 
197  hr = IWICPalette_IsGrayscale(palette, NULL);
198  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
199 
200  hr = IWICPalette_InitializeFromPalette(palette, NULL);
201  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
202 
203  IWICPalette_Release(palette2);
204  IWICPalette_Release(palette);
205  }
206 }
207 
208 static void generate_gray16_palette(DWORD *entries, UINT count)
209 {
210  UINT i;
211 
212  assert(count == 16);
213 
214  for (i = 0; i < 16; i++)
215  {
216  entries[i] = 0xff000000;
217  entries[i] |= (i << 20) | (i << 16) | (i << 12) | (i << 8) | (i << 4) | i;
218  }
219 }
220 
221 static void generate_gray256_palette(DWORD *entries, UINT count)
222 {
223  UINT i;
224 
225  assert(count == 256);
226 
227  for (i = 0; i < 256; i++)
228  {
229  entries[i] = 0xff000000;
230  entries[i] |= (i << 16) | (i << 8) | i;
231  }
232 }
233 
234 static void generate_halftone8_palette(DWORD *entries, UINT count, BOOL add_transparent)
235 {
236  UINT i;
237 
238  if (add_transparent)
239  ok(count == 17, "expected 17, got %u\n", count);
240  else
241  ok(count == 16, "expected 16, got %u\n", count);
242 
243  for (i = 0; i < 8; i++)
244  {
245  entries[i] = 0xff000000;
246  if (i & 1) entries[i] |= 0xff;
247  if (i & 2) entries[i] |= 0xff00;
248  if (i & 4) entries[i] |= 0xff0000;
249  }
250 
251  for (i = 8; i < 16; i++)
252  {
253  static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
254  0x000080, 0x808000, 0x800080, 0x008080 };
255  entries[i] = 0xff000000;
256  entries[i] |= halftone[i-8];
257  }
258 
259  if (add_transparent)
260  entries[i] = 0;
261 }
262 
263 static void generate_halftone27_palette(DWORD *entries, UINT count, BOOL add_transparent)
264 {
265  static const BYTE halftone_values[4] = { 0x00,0x80,0xff };
266  UINT i;
267 
268  if (add_transparent)
269  ok(count == 29, "expected 29, got %u\n", count);
270  else
271  ok(count == 28, "expected 28, got %u\n", count);
272 
273  for (i = 0; i < 27; i++)
274  {
275  entries[i] = 0xff000000;
276  entries[i] |= halftone_values[i%3];
277  entries[i] |= halftone_values[(i/3)%3] << 8;
278  entries[i] |= halftone_values[(i/9)%3] << 16;
279  }
280 
281  entries[i++] = 0xffc0c0c0;
282  if (add_transparent)
283  entries[i] = 0;
284 }
285 
286 static void generate_halftone64_palette(DWORD *entries, UINT count, BOOL add_transparent)
287 {
288  static const BYTE halftone_values[4] = { 0x00,0x55,0xaa,0xff };
289  UINT i;
290 
291  if (add_transparent)
292  ok(count == 73, "expected 73, got %u\n", count);
293  else
294  ok(count == 72, "expected 72, got %u\n", count);
295 
296  for (i = 0; i < 64; i++)
297  {
298  entries[i] = 0xff000000;
299  entries[i] |= halftone_values[i%4];
300  entries[i] |= halftone_values[(i/4)%4] << 8;
301  entries[i] |= halftone_values[(i/16)%4] << 16;
302  }
303 
304  for (i = 64; i < 72; i++)
305  {
306  static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
307  0x000080, 0x808000, 0x800080, 0x008080 };
308  entries[i] = 0xff000000;
309  entries[i] |= halftone[i-64];
310  }
311 
312  if (add_transparent)
313  entries[i] = 0;
314 }
315 
316 static void generate_halftone125_palette(DWORD *entries, UINT count, BOOL add_transparent)
317 {
318  static const BYTE halftone_values[5] = { 0x00, 0x40, 0x80, 0xbf, 0xff };
319  UINT i;
320 
321  if (add_transparent)
322  ok(count == 127, "expected 127, got %u\n", count);
323  else
324  ok(count == 126, "expected 126, got %u\n", count);
325 
326  for (i = 0; i < 125; i++)
327  {
328  entries[i] = 0xff000000;
329  entries[i] |= halftone_values[i%5];
330  entries[i] |= halftone_values[(i/5)%5] << 8;
331  entries[i] |= halftone_values[(i/25)%5] << 16;
332  }
333 
334  entries[i++] = 0xffc0c0c0;
335  if (add_transparent)
336  entries[i] = 0;
337 }
338 
339 static void generate_halftone216_palette(DWORD *entries, UINT count, BOOL add_transparent)
340 {
341  static const BYTE halftone_values[6] = { 0x00,0x33,0x66,0x99,0xcc,0xff };
342  UINT i;
343 
344  if (add_transparent)
345  ok(count == 225, "expected 225, got %u\n", count);
346  else
347  ok(count == 224, "expected 224, got %u\n", count);
348 
349  for (i = 0; i < 216; i++)
350  {
351  entries[i] = 0xff000000;
352  entries[i] |= halftone_values[i%6];
353  entries[i] |= halftone_values[(i/6)%6] << 8;
354  entries[i] |= halftone_values[(i/36)%6] << 16;
355  }
356 
357  for (i = 216; i < 224; i++)
358  {
359  static const DWORD halftone[8] = { 0xc0c0c0, 0x808080, 0x800000, 0x008000,
360  0x000080, 0x808000, 0x800080, 0x008080 };
361  entries[i] = 0xff000000;
362  entries[i] |= halftone[i-216];
363  }
364 
365  if (add_transparent)
366  entries[i] = 0;
367 }
368 
369 static void generate_halftone252_palette(DWORD *entries, UINT count, BOOL add_transparent)
370 {
371  static const BYTE halftone_values_rb[6] = { 0x00,0x33,0x66,0x99,0xcc,0xff };
372  static const BYTE halftone_values_g[7] = { 0x00,0x2b,0x55,0x80,0xaa,0xd5,0xff };
373  UINT i;
374 
375  if (add_transparent)
376  ok(count == 253, "expected 253, got %u\n", count);
377  else
378  ok(count == 252, "expected 252, got %u\n", count);
379 
380  for (i = 0; i < 252; i++)
381  {
382  entries[i] = 0xff000000;
383  entries[i] |= halftone_values_rb[i%6];
384  entries[i] |= halftone_values_g[(i/6)%7] << 8;
385  entries[i] |= halftone_values_rb[(i/42)%6] << 16;
386  }
387 
388  if (add_transparent)
389  entries[i] = 0;
390 }
391 
392 static void generate_halftone256_palette(DWORD *entries, UINT count, BOOL add_transparent)
393 {
394  static const BYTE halftone_values_b[4] = { 0x00,0x55,0xaa,0xff };
395  static const BYTE halftone_values_gr[8] = { 0x00,0x24,0x49,0x6d,0x92,0xb6,0xdb,0xff };
396  UINT i;
397 
398  assert(count == 256);
399 
400  for (i = 0; i < 256; i++)
401  {
402  entries[i] = 0xff000000;
403  entries[i] |= halftone_values_b[i%4];
404  entries[i] |= halftone_values_gr[(i/4)%8] << 8;
405  entries[i] |= halftone_values_gr[(i/32)%8] << 16;
406  }
407 
408  if (add_transparent)
409  entries[255] = 0;
410 }
411 
412 static void test_predefined_palette(void)
413 {
414  static struct test_data
415  {
417  BOOL is_bw, is_gray;
418  UINT count;
419  WICColor color[256];
420  BOOL add_transparent;
421  } td[] =
422  {
423  { WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff } },
424  { WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff }, 1 },
426  { 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff } },
428  { 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff }, 1 },
429  { WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 } },
430  { WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 }, 1 },
431  { WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 } },
432  { WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 }, 1 },
433  { WICBitmapPaletteTypeFixedHalftone8, 0, 0, 16, { 0 } },
434  { WICBitmapPaletteTypeFixedHalftone8, 0, 0, 17, { 0 }, 1 },
435  { WICBitmapPaletteTypeFixedHalftone27, 0, 0, 28, { 0 } },
436  { WICBitmapPaletteTypeFixedHalftone27, 0, 0, 29, { 0 }, 1 },
437  { WICBitmapPaletteTypeFixedHalftone64, 0, 0, 72, { 0 } },
438  { WICBitmapPaletteTypeFixedHalftone64, 0, 0, 73, { 0 }, 1 },
439  { WICBitmapPaletteTypeFixedHalftone125, 0, 0, 126, { 0 } },
440  { WICBitmapPaletteTypeFixedHalftone125, 0, 0, 127, { 0 }, 1 },
441  { WICBitmapPaletteTypeFixedHalftone216, 0, 0, 224, { 0 } },
442  { WICBitmapPaletteTypeFixedHalftone216, 0, 0, 225, { 0 }, 1 },
443  { WICBitmapPaletteTypeFixedHalftone252, 0, 0, 252, { 0 } },
444  { WICBitmapPaletteTypeFixedHalftone252, 0, 0, 253, { 0 }, 1 },
445  { WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 } },
446  { WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 }, 1 }
447  };
449  HRESULT hr;
451  UINT count, i, ret;
452  BOOL bret;
453  WICColor color[256];
454 
455  hr = IWICImagingFactory_CreatePalette(factory, &palette);
456  ok(hr == S_OK, "CreatePalette error %#x\n", hr);
457  hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeCustom, FALSE);
458  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
459  hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeMedianCut, FALSE);
460  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
461  hr = IWICPalette_InitializePredefined(palette, 0x0f, FALSE);
462  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
463  IWICPalette_Release(palette);
464 
465  for (i = 0; i < ARRAY_SIZE(td); i++)
466  {
467  hr = IWICImagingFactory_CreatePalette(factory, &palette);
468  ok(hr == S_OK, "%u: CreatePalette error %#x\n", i, hr);
469 
470  hr = IWICPalette_InitializePredefined(palette, td[i].type, td[i].add_transparent);
471  ok(hr == S_OK, "%u: InitializePredefined error %#x\n", i, hr);
472 
473  bret = -1;
474  hr = IWICPalette_IsBlackWhite(palette, &bret);
475  ok(hr == S_OK, "%u: IsBlackWhite error %#x\n", i, hr);
476  ok(bret == td[i].is_bw ||
477  broken(td[i].type == WICBitmapPaletteTypeFixedBW && bret != td[i].is_bw), /* XP */
478  "%u: expected %d, got %d\n",i, td[i].is_bw, bret);
479 
480  bret = -1;
481  hr = IWICPalette_IsGrayscale(palette, &bret);
482  ok(hr == S_OK, "%u: IsGrayscale error %#x\n", i, hr);
483  ok(bret == td[i].is_gray, "%u: expected %d, got %d\n", i, td[i].is_gray, bret);
484 
485  type = -1;
486  hr = IWICPalette_GetType(palette, &type);
487  ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
488  ok(type == td[i].type, "%u: expected %#x, got %#x\n", i, td[i].type, type);
489 
490  count = 0xdeadbeef;
491  hr = IWICPalette_GetColorCount(palette, &count);
492  ok(hr == S_OK, "%u: GetColorCount error %#x\n", i, hr);
493  ok(count == td[i].count, "%u: expected %u, got %u\n", i, td[i].count, count);
494 
495  hr = IWICPalette_GetColors(palette, count, color, &ret);
496  ok(hr == S_OK, "%u: GetColors error %#x\n", i, hr);
497  ok(ret == count, "%u: expected %u, got %u\n", i, count, ret);
498  if (ret == td[i].count)
499  {
500  UINT j;
501 
504  else if (td[i].type == WICBitmapPaletteTypeFixedGray256)
506  else if (td[i].type == WICBitmapPaletteTypeFixedHalftone8)
507  generate_halftone8_palette(td[i].color, td[i].count, td[i].add_transparent);
509  generate_halftone27_palette(td[i].color, td[i].count, td[i].add_transparent);
511  generate_halftone64_palette(td[i].color, td[i].count, td[i].add_transparent);
513  generate_halftone125_palette(td[i].color, td[i].count, td[i].add_transparent);
515  generate_halftone216_palette(td[i].color, td[i].count, td[i].add_transparent);
517  generate_halftone252_palette(td[i].color, td[i].count, td[i].add_transparent);
519  generate_halftone256_palette(td[i].color, td[i].count, td[i].add_transparent);
520 
521  for (j = 0; j < count; j++)
522  {
523  ok(color[j] == td[i].color[j], "%u:[%u]: expected %#x, got %#x\n",
524  i, j, td[i].color[j], color[j]);
525  }
526  }
527 
528  IWICPalette_Release(palette);
529  }
530 }
531 
533 {
534  BYTE *src;
535  UINT i, j, scale;
536 
537  *width = 256;
538  *height = 256;
539  *stride = (*width * 3 + 3) & ~3;
540  trace("width %d, height %d, stride %d\n", *width, *height, *stride);
541 
543 
544  scale = 256 / *width;
545  if (!scale) scale = 1;
546 
547  for (i = 0; i < *height; i++)
548  {
549  for (j = 0; j < *width; j++)
550  {
551  src[i * *stride + j*3 + 0] = scale * i;
552  src[i * *stride + j*3 + 1] = scale * (255 - (i+j)/2);
553  src[i * *stride + j*3 + 2] = scale * j;
554  }
555  }
556 
557  return src;
558 }
559 
560 static void test_palette_from_bitmap(void)
561 {
562  HRESULT hr;
563  BYTE *data;
568  WICColor color[257];
569 
571 
572  hr = IWICImagingFactory_CreateBitmapFromMemory(factory, width, height, &GUID_WICPixelFormat24bppRGB,
573  stride, stride * height, data, &bitmap);
574  ok(hr == S_OK, "CreateBitmapFromMemory error %#x\n", hr);
575 
576  hr = IWICImagingFactory_CreatePalette(factory, &palette);
577  ok(hr == S_OK, "CreatePalette error %#x\n", hr);
578 
579  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 0, FALSE);
580  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
581 
582  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 1, FALSE);
583  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
584 
585  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 257, FALSE);
586  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
587 
588  hr = IWICPalette_InitializeFromBitmap(palette, NULL, 16, FALSE);
589  ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
590 
591  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 2, FALSE);
592  ok(hr == S_OK, "InitializeFromBitmap error %#x\n", hr);
593  count = 0;
594  hr = IWICPalette_GetColorCount(palette, &count);
595  ok(hr == S_OK, "GetColorCount error %#x\n", hr);
596  ok(count == 2, "expected 2, got %u\n", count);
597 
598  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 2, TRUE);
599  ok(hr == S_OK, "InitializeFromBitmap error %#x\n", hr);
600  count = 0;
601  hr = IWICPalette_GetColorCount(palette, &count);
602  ok(hr == S_OK, "GetColorCount error %#x\n", hr);
603  ok(count == 2, "expected 2, got %u\n", count);
604 
605  /* without trasparent color */
606  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 16, FALSE);
607  ok(hr == S_OK, "InitializeFromBitmap error %#x\n", hr);
608  type = -1;
609  hr = IWICPalette_GetType(palette, &type);
610  ok(hr == S_OK, "GetType error %#x\n", hr);
611  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
612  count = 0;
613  hr = IWICPalette_GetColorCount(palette, &count);
614  ok(hr == S_OK, "GetColorCount error %#x\n", hr);
615  ok(count == 16, "expected 16, got %u\n", count);
616  memset(color, 0, sizeof(color));
617  hr = IWICPalette_GetColors(palette, count, color, &ret);
618  ok(hr == S_OK, "GetColors error %#x\n", hr);
619  ok(ret == count, "expected %u, got %u\n", count, ret);
620  ok(color[count - 1] != 0, "expected !0, got %08x\n", color[count - 1]);
621 
622  /* with trasparent color */
623  hr = IWICPalette_InitializeFromBitmap(palette, (IWICBitmapSource *)bitmap, 16, TRUE);
624  ok(hr == S_OK, "InitializeFromBitmap error %#x\n", hr);
625  type = -1;
626  hr = IWICPalette_GetType(palette, &type);
627  ok(hr == S_OK, "GetType error %#x\n", hr);
628  ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
629  count = 0;
630  hr = IWICPalette_GetColorCount(palette, &count);
631  ok(hr == S_OK, "GetColorCount error %#x\n", hr);
632  ok(count == 16, "expected 16, got %u\n", count);
633  memset(color, 0xff, sizeof(color));
634  hr = IWICPalette_GetColors(palette, count, color, &ret);
635  ok(hr == S_OK, "GetColors error %#x\n", hr);
636  ok(ret == count, "expected %u, got %u\n", count, ret);
637  ok(color[count - 1] == 0, "expected 0, got %08x\n", color[count - 1]);
638 
639  IWICPalette_Release(palette);
640  IWICBitmap_Release(bitmap);
641 
643 }
644 
646 {
647  HRESULT hr;
648 
650 
651  hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
652  &IID_IWICImagingFactory, (void **)&factory);
653  ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
654 
658 
659  IWICImagingFactory_Release(factory);
660 
661  CoUninitialize();
662 }
static void generate_halftone216_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:339
static void test_palette_from_bitmap(void)
Definition: palette.c:560
GLint GLint GLsizei width
Definition: gl.h:1546
#define TRUE
Definition: types.h:120
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
HRESULT hr
Definition: shlfolder.c:183
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:9032
static void generate_gray16_palette(DWORD *entries, UINT count)
Definition: palette.c:208
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
START_TEST(palette)
Definition: palette.c:319
static void generate_halftone256_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:392
static void test_predefined_palette(void)
Definition: palette.c:412
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
static void generate_halftone27_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:263
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: main.c:440
GLuint color
Definition: glext.h:6243
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
static IWICImagingFactory * factory
Definition: palette.c:30
static void test_custom_palette(void)
Definition: palette.c:32
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
Definition: uimain.c:88
GLsizei stride
Definition: glext.h:5848
#define GetProcessHeap()
Definition: compat.h:403
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
WICBitmapPaletteType
Definition: wincodec.idl:90
LONG HRESULT
Definition: typedefs.h:77
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: mem.h:68
static void generate_halftone64_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:286
static void generate_gray256_palette(DWORD *entries, UINT count)
Definition: palette.c:221
GLenum src
Definition: glext.h:6340
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define broken(x)
Definition: _sntprintf.h:21
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
static void generate_halftone125_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:316
#define S_OK
Definition: intsafe.h:59
static void generate_halftone8_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:234
ULONG type
Definition: metadata.c:648
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
#define ARRAY_SIZE(a)
Definition: main.h:24
#define ok(value,...)
Definition: atltest.h:57
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
unsigned int UINT
Definition: ndis.h:50
int count
Definition: metadata.c:649
static HBITMAP bitmap
Definition: clipboard.c:1344
#define memset(x, y, z)
Definition: compat.h:39
UINT32 WICColor
Definition: wincodec.idl:250
#define HeapFree(x, y, z)
Definition: compat.h:402
static void generate_halftone252_palette(DWORD *entries, UINT count, BOOL add_transparent)
Definition: palette.c:369
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static BYTE * init_bitmap(UINT *width, UINT *height, UINT *stride)
Definition: palette.c:532