ReactOS 0.4.15-dev-5865-g640e228
converter.c
Go to the documentation of this file.
1/*
2 * Copyright 2009 Vincent Povirk
3 * Copyright 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 "config.h"
21
22#include <stdarg.h>
23#include <math.h>
24
25#define COBJMACROS
26
27#include "windef.h"
28#include "winbase.h"
29#include "objbase.h"
30
31#include "wincodecs_private.h"
32
33#include "wine/heap.h"
34#include "wine/debug.h"
35
36WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
37
38struct FormatConverter;
39
40enum pixelformat {
41 format_1bppIndexed,
42 format_2bppIndexed,
43 format_4bppIndexed,
44 format_8bppIndexed,
45 format_BlackWhite,
46 format_2bppGray,
47 format_4bppGray,
48 format_8bppGray,
49 format_16bppGray,
50 format_16bppBGR555,
51 format_16bppBGR565,
52 format_16bppBGRA5551,
53 format_24bppBGR,
54 format_24bppRGB,
55 format_32bppGrayFloat,
56 format_32bppBGR,
57 format_32bppRGB,
58 format_32bppBGRA,
59 format_32bppRGBA,
60 format_32bppPBGRA,
61 format_32bppPRGBA,
62 format_48bppRGB,
63 format_64bppRGBA,
64 format_32bppCMYK,
65};
66
67typedef HRESULT (*copyfunc)(struct FormatConverter *This, const WICRect *prc,
68 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format);
69
70struct pixelformatinfo {
71 enum pixelformat format;
72 const WICPixelFormatGUID *guid;
73 copyfunc copy_function;
74};
75
76typedef struct FormatConverter {
77 IWICFormatConverter IWICFormatConverter_iface;
78 LONG ref;
79 IWICBitmapSource *source;
80 const struct pixelformatinfo *dst_format, *src_format;
81 WICBitmapDitherType dither;
82 double alpha_threshold;
83 IWICPalette *palette;
84 CRITICAL_SECTION lock; /* must be held when initialized */
85} FormatConverter;
86
87/* https://www.w3.org/Graphics/Color/srgb */
88static inline float to_sRGB_component(float f)
89{
90 if (f <= 0.0031308f) return 12.92f * f;
91 return 1.055f * powf(f, 1.0f/2.4f) - 0.055f;
92}
93
94#if 0 /* FIXME: enable once needed */
95static inline float from_sRGB_component(float f)
96{
97 if (f <= 0.04045f) return f / 12.92f;
98 return powf((f + 0.055f) / 1.055f, 2.4f);
99}
100
101static void from_sRGB(BYTE *bgr)
102{
103 float r, g, b;
104
105 r = bgr[2] / 255.0f;
106 g = bgr[1] / 255.0f;
107 b = bgr[0] / 255.0f;
108
109 r = from_sRGB_component(r);
110 g = from_sRGB_component(g);
111 b = from_sRGB_component(b);
112
113 bgr[2] = (BYTE)(r * 255.0f);
114 bgr[1] = (BYTE)(g * 255.0f);
115 bgr[0] = (BYTE)(b * 255.0f);
116}
117
118static void to_sRGB(BYTE *bgr)
119{
120 float r, g, b;
121
122 r = bgr[2] / 255.0f;
123 g = bgr[1] / 255.0f;
124 b = bgr[0] / 255.0f;
125
126 r = to_sRGB_component(r);
127 g = to_sRGB_component(g);
128 b = to_sRGB_component(b);
129
130 bgr[2] = (BYTE)(r * 255.0f);
131 bgr[1] = (BYTE)(g * 255.0f);
132 bgr[0] = (BYTE)(b * 255.0f);
133}
134#endif
135
136static inline FormatConverter *impl_from_IWICFormatConverter(IWICFormatConverter *iface)
137{
138 return CONTAINING_RECORD(iface, FormatConverter, IWICFormatConverter_iface);
139}
140
141static HRESULT copypixels_to_32bppBGRA(struct FormatConverter *This, const WICRect *prc,
142 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
143{
144 switch (source_format)
145 {
146 case format_1bppIndexed:
147 case format_BlackWhite:
148 if (prc)
149 {
150 HRESULT res;
151 INT x, y;
152 BYTE *srcdata;
153 UINT srcstride, srcdatasize;
154 const BYTE *srcrow;
155 const BYTE *srcbyte;
156 BYTE *dstrow;
157 DWORD *dstpixel;
158 WICColor colors[2];
159 IWICPalette *palette;
160 UINT actualcolors;
161
162 res = PaletteImpl_Create(&palette);
163 if (FAILED(res)) return res;
164
165 if (source_format == format_1bppIndexed)
166 res = IWICBitmapSource_CopyPalette(This->source, palette);
167 else
168 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedBW, FALSE);
169
170 if (SUCCEEDED(res))
171 res = IWICPalette_GetColors(palette, 2, colors, &actualcolors);
172
173 IWICPalette_Release(palette);
174 if (FAILED(res)) return res;
175
176 srcstride = (prc->Width+7)/8;
177 srcdatasize = srcstride * prc->Height;
178
179 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
180 if (!srcdata) return E_OUTOFMEMORY;
181
182 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
183
184 if (SUCCEEDED(res))
185 {
186 srcrow = srcdata;
187 dstrow = pbBuffer;
188 for (y=0; y<prc->Height; y++) {
189 srcbyte = srcrow;
190 dstpixel=(DWORD*)dstrow;
191 for (x=0; x<prc->Width; x+=8) {
192 BYTE srcval;
193 srcval=*srcbyte++;
194 *dstpixel++ = colors[srcval>>7&1];
195 if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>6&1];
196 if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>5&1];
197 if (x+3 < prc->Width) *dstpixel++ = colors[srcval>>4&1];
198 if (x+4 < prc->Width) *dstpixel++ = colors[srcval>>3&1];
199 if (x+5 < prc->Width) *dstpixel++ = colors[srcval>>2&1];
200 if (x+6 < prc->Width) *dstpixel++ = colors[srcval>>1&1];
201 if (x+7 < prc->Width) *dstpixel++ = colors[srcval&1];
202 }
203 srcrow += srcstride;
204 dstrow += cbStride;
205 }
206 }
207
208 HeapFree(GetProcessHeap(), 0, srcdata);
209
210 return res;
211 }
212 return S_OK;
213 case format_2bppIndexed:
214 case format_2bppGray:
215 if (prc)
216 {
217 HRESULT res;
218 INT x, y;
219 BYTE *srcdata;
220 UINT srcstride, srcdatasize;
221 const BYTE *srcrow;
222 const BYTE *srcbyte;
223 BYTE *dstrow;
224 DWORD *dstpixel;
225 WICColor colors[4];
226 IWICPalette *palette;
227 UINT actualcolors;
228
229 res = PaletteImpl_Create(&palette);
230 if (FAILED(res)) return res;
231
232 if (source_format == format_2bppIndexed)
233 res = IWICBitmapSource_CopyPalette(This->source, palette);
234 else
235 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
236
237 if (SUCCEEDED(res))
238 res = IWICPalette_GetColors(palette, 4, colors, &actualcolors);
239
240 IWICPalette_Release(palette);
241 if (FAILED(res)) return res;
242
243 srcstride = (prc->Width+3)/4;
244 srcdatasize = srcstride * prc->Height;
245
246 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
247 if (!srcdata) return E_OUTOFMEMORY;
248
249 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
250
251 if (SUCCEEDED(res))
252 {
253 srcrow = srcdata;
254 dstrow = pbBuffer;
255 for (y=0; y<prc->Height; y++) {
256 srcbyte = srcrow;
257 dstpixel=(DWORD*)dstrow;
258 for (x=0; x<prc->Width; x+=4) {
259 BYTE srcval;
260 srcval=*srcbyte++;
261 *dstpixel++ = colors[srcval>>6];
262 if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>4&0x3];
263 if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>2&0x3];
264 if (x+3 < prc->Width) *dstpixel++ = colors[srcval&0x3];
265 }
266 srcrow += srcstride;
267 dstrow += cbStride;
268 }
269 }
270
271 HeapFree(GetProcessHeap(), 0, srcdata);
272
273 return res;
274 }
275 return S_OK;
276 case format_4bppIndexed:
277 case format_4bppGray:
278 if (prc)
279 {
280 HRESULT res;
281 INT x, y;
282 BYTE *srcdata;
283 UINT srcstride, srcdatasize;
284 const BYTE *srcrow;
285 const BYTE *srcbyte;
286 BYTE *dstrow;
287 DWORD *dstpixel;
288 WICColor colors[16];
289 IWICPalette *palette;
290 UINT actualcolors;
291
292 res = PaletteImpl_Create(&palette);
293 if (FAILED(res)) return res;
294
295 if (source_format == format_4bppIndexed)
296 res = IWICBitmapSource_CopyPalette(This->source, palette);
297 else
298 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray16, FALSE);
299
300 if (SUCCEEDED(res))
301 res = IWICPalette_GetColors(palette, 16, colors, &actualcolors);
302
303 IWICPalette_Release(palette);
304 if (FAILED(res)) return res;
305
306 srcstride = (prc->Width+1)/2;
307 srcdatasize = srcstride * prc->Height;
308
309 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
310 if (!srcdata) return E_OUTOFMEMORY;
311
312 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
313
314 if (SUCCEEDED(res))
315 {
316 srcrow = srcdata;
317 dstrow = pbBuffer;
318 for (y=0; y<prc->Height; y++) {
319 srcbyte = srcrow;
320 dstpixel=(DWORD*)dstrow;
321 for (x=0; x<prc->Width; x+=2) {
322 BYTE srcval;
323 srcval=*srcbyte++;
324 *dstpixel++ = colors[srcval>>4];
325 if (x+1 < prc->Width) *dstpixel++ = colors[srcval&0xf];
326 }
327 srcrow += srcstride;
328 dstrow += cbStride;
329 }
330 }
331
332 HeapFree(GetProcessHeap(), 0, srcdata);
333
334 return res;
335 }
336 return S_OK;
337 case format_8bppGray:
338 if (prc)
339 {
340 HRESULT res;
341 INT x, y;
342 BYTE *srcdata;
343 UINT srcstride, srcdatasize;
344 const BYTE *srcrow;
345 const BYTE *srcbyte;
346 BYTE *dstrow;
347 DWORD *dstpixel;
348
349 srcstride = prc->Width;
350 srcdatasize = srcstride * prc->Height;
351
352 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
353 if (!srcdata) return E_OUTOFMEMORY;
354
355 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
356
357 if (SUCCEEDED(res))
358 {
359 srcrow = srcdata;
360 dstrow = pbBuffer;
361 for (y=0; y<prc->Height; y++) {
362 srcbyte = srcrow;
363 dstpixel=(DWORD*)dstrow;
364 for (x=0; x<prc->Width; x++)
365 {
366 *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
367 srcbyte++;
368 }
369 srcrow += srcstride;
370 dstrow += cbStride;
371 }
372 }
373
374 HeapFree(GetProcessHeap(), 0, srcdata);
375
376 return res;
377 }
378 return S_OK;
379 case format_8bppIndexed:
380 if (prc)
381 {
382 HRESULT res;
383 INT x, y;
384 BYTE *srcdata;
385 UINT srcstride, srcdatasize;
386 const BYTE *srcrow;
387 const BYTE *srcbyte;
388 BYTE *dstrow;
389 DWORD *dstpixel;
390 WICColor colors[256];
391 IWICPalette *palette;
392 UINT actualcolors;
393
394 res = PaletteImpl_Create(&palette);
395 if (FAILED(res)) return res;
396
397 res = IWICBitmapSource_CopyPalette(This->source, palette);
398 if (SUCCEEDED(res))
399 res = IWICPalette_GetColors(palette, 256, colors, &actualcolors);
400
401 IWICPalette_Release(palette);
402
403 if (FAILED(res)) return res;
404
405 srcstride = prc->Width;
406 srcdatasize = srcstride * prc->Height;
407
408 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
409 if (!srcdata) return E_OUTOFMEMORY;
410
411 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
412
413 if (SUCCEEDED(res))
414 {
415 srcrow = srcdata;
416 dstrow = pbBuffer;
417 for (y=0; y<prc->Height; y++) {
418 srcbyte = srcrow;
419 dstpixel=(DWORD*)dstrow;
420 for (x=0; x<prc->Width; x++)
421 *dstpixel++ = colors[*srcbyte++];
422 srcrow += srcstride;
423 dstrow += cbStride;
424 }
425 }
426
427 HeapFree(GetProcessHeap(), 0, srcdata);
428
429 return res;
430 }
431 return S_OK;
432 case format_16bppGray:
433 if (prc)
434 {
435 HRESULT res;
436 INT x, y;
437 BYTE *srcdata;
438 UINT srcstride, srcdatasize;
439 const BYTE *srcrow;
440 const BYTE *srcbyte;
441 BYTE *dstrow;
442 DWORD *dstpixel;
443
444 srcstride = prc->Width * 2;
445 srcdatasize = srcstride * prc->Height;
446
447 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
448 if (!srcdata) return E_OUTOFMEMORY;
449
450 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
451
452 if (SUCCEEDED(res))
453 {
454 srcrow = srcdata;
455 dstrow = pbBuffer;
456 for (y=0; y<prc->Height; y++) {
457 srcbyte = srcrow;
458 dstpixel=(DWORD*)dstrow;
459 for (x=0; x<prc->Width; x++)
460 {
461 srcbyte++;
462 *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
463 srcbyte++;
464 }
465 srcrow += srcstride;
466 dstrow += cbStride;
467 }
468 }
469
470 HeapFree(GetProcessHeap(), 0, srcdata);
471
472 return res;
473 }
474 return S_OK;
475 case format_16bppBGR555:
476 if (prc)
477 {
478 HRESULT res;
479 INT x, y;
480 BYTE *srcdata;
481 UINT srcstride, srcdatasize;
482 const BYTE *srcrow;
483 const WORD *srcpixel;
484 BYTE *dstrow;
485 DWORD *dstpixel;
486
487 srcstride = 2 * prc->Width;
488 srcdatasize = srcstride * prc->Height;
489
490 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
491 if (!srcdata) return E_OUTOFMEMORY;
492
493 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
494
495 if (SUCCEEDED(res))
496 {
497 srcrow = srcdata;
498 dstrow = pbBuffer;
499 for (y=0; y<prc->Height; y++) {
500 srcpixel=(const WORD*)srcrow;
501 dstpixel=(DWORD*)dstrow;
502 for (x=0; x<prc->Width; x++) {
503 WORD srcval;
504 srcval=*srcpixel++;
505 *dstpixel++=0xff000000 | /* constant 255 alpha */
506 ((srcval << 9) & 0xf80000) | /* r */
507 ((srcval << 4) & 0x070000) | /* r - 3 bits */
508 ((srcval << 6) & 0x00f800) | /* g */
509 ((srcval << 1) & 0x000700) | /* g - 3 bits */
510 ((srcval << 3) & 0x0000f8) | /* b */
511 ((srcval >> 2) & 0x000007); /* b - 3 bits */
512 }
513 srcrow += srcstride;
514 dstrow += cbStride;
515 }
516 }
517
518 HeapFree(GetProcessHeap(), 0, srcdata);
519
520 return res;
521 }
522 return S_OK;
523 case format_16bppBGR565:
524 if (prc)
525 {
526 HRESULT res;
527 INT x, y;
528 BYTE *srcdata;
529 UINT srcstride, srcdatasize;
530 const BYTE *srcrow;
531 const WORD *srcpixel;
532 BYTE *dstrow;
533 DWORD *dstpixel;
534
535 srcstride = 2 * prc->Width;
536 srcdatasize = srcstride * prc->Height;
537
538 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
539 if (!srcdata) return E_OUTOFMEMORY;
540
541 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
542
543 if (SUCCEEDED(res))
544 {
545 srcrow = srcdata;
546 dstrow = pbBuffer;
547 for (y=0; y<prc->Height; y++) {
548 srcpixel=(const WORD*)srcrow;
549 dstpixel=(DWORD*)dstrow;
550 for (x=0; x<prc->Width; x++) {
551 WORD srcval;
552 srcval=*srcpixel++;
553 *dstpixel++=0xff000000 | /* constant 255 alpha */
554 ((srcval << 8) & 0xf80000) | /* r */
555 ((srcval << 3) & 0x070000) | /* r - 3 bits */
556 ((srcval << 5) & 0x00fc00) | /* g */
557 ((srcval >> 1) & 0x000300) | /* g - 2 bits */
558 ((srcval << 3) & 0x0000f8) | /* b */
559 ((srcval >> 2) & 0x000007); /* b - 3 bits */
560 }
561 srcrow += srcstride;
562 dstrow += cbStride;
563 }
564 }
565
566 HeapFree(GetProcessHeap(), 0, srcdata);
567
568 return res;
569 }
570 return S_OK;
571 case format_16bppBGRA5551:
572 if (prc)
573 {
574 HRESULT res;
575 INT x, y;
576 BYTE *srcdata;
577 UINT srcstride, srcdatasize;
578 const BYTE *srcrow;
579 const WORD *srcpixel;
580 BYTE *dstrow;
581 DWORD *dstpixel;
582
583 srcstride = 2 * prc->Width;
584 srcdatasize = srcstride * prc->Height;
585
586 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
587 if (!srcdata) return E_OUTOFMEMORY;
588
589 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
590
591 if (SUCCEEDED(res))
592 {
593 srcrow = srcdata;
594 dstrow = pbBuffer;
595 for (y=0; y<prc->Height; y++) {
596 srcpixel=(const WORD*)srcrow;
597 dstpixel=(DWORD*)dstrow;
598 for (x=0; x<prc->Width; x++) {
599 WORD srcval;
600 srcval=*srcpixel++;
601 *dstpixel++=((srcval & 0x8000) ? 0xff000000 : 0) | /* alpha */
602 ((srcval << 9) & 0xf80000) | /* r */
603 ((srcval << 4) & 0x070000) | /* r - 3 bits */
604 ((srcval << 6) & 0x00f800) | /* g */
605 ((srcval << 1) & 0x000700) | /* g - 3 bits */
606 ((srcval << 3) & 0x0000f8) | /* b */
607 ((srcval >> 2) & 0x000007); /* b - 3 bits */
608 }
609 srcrow += srcstride;
610 dstrow += cbStride;
611 }
612 }
613
614 HeapFree(GetProcessHeap(), 0, srcdata);
615
616 return res;
617 }
618 return S_OK;
619 case format_24bppBGR:
620 if (prc)
621 {
622 HRESULT res;
623 INT x, y;
624 BYTE *srcdata;
625 UINT srcstride, srcdatasize;
626 const BYTE *srcrow;
627 const BYTE *srcpixel;
628 BYTE *dstrow;
629 BYTE *dstpixel;
630
631 srcstride = 3 * prc->Width;
632 srcdatasize = srcstride * prc->Height;
633
634 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
635 if (!srcdata) return E_OUTOFMEMORY;
636
637 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
638
639 if (SUCCEEDED(res))
640 {
641 srcrow = srcdata;
642 dstrow = pbBuffer;
643 for (y=0; y<prc->Height; y++) {
644 srcpixel=srcrow;
645 dstpixel=dstrow;
646 for (x=0; x<prc->Width; x++) {
647 *dstpixel++=*srcpixel++; /* blue */
648 *dstpixel++=*srcpixel++; /* green */
649 *dstpixel++=*srcpixel++; /* red */
650 *dstpixel++=255; /* alpha */
651 }
652 srcrow += srcstride;
653 dstrow += cbStride;
654 }
655 }
656
657 HeapFree(GetProcessHeap(), 0, srcdata);
658
659 return res;
660 }
661 return S_OK;
662 case format_24bppRGB:
663 if (prc)
664 {
665 HRESULT res;
666 INT x, y;
667 BYTE *srcdata;
668 UINT srcstride, srcdatasize;
669 const BYTE *srcrow;
670 const BYTE *srcpixel;
671 BYTE *dstrow;
672 BYTE *dstpixel;
673 BYTE tmppixel[3];
674
675 srcstride = 3 * prc->Width;
676 srcdatasize = srcstride * prc->Height;
677
678 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
679 if (!srcdata) return E_OUTOFMEMORY;
680
681 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
682
683 if (SUCCEEDED(res))
684 {
685 srcrow = srcdata;
686 dstrow = pbBuffer;
687 for (y=0; y<prc->Height; y++) {
688 srcpixel=srcrow;
689 dstpixel=dstrow;
690 for (x=0; x<prc->Width; x++) {
691 tmppixel[0]=*srcpixel++; /* red */
692 tmppixel[1]=*srcpixel++; /* green */
693 tmppixel[2]=*srcpixel++; /* blue */
694
695 *dstpixel++=tmppixel[2]; /* blue */
696 *dstpixel++=tmppixel[1]; /* green */
697 *dstpixel++=tmppixel[0]; /* red */
698 *dstpixel++=255; /* alpha */
699 }
700 srcrow += srcstride;
701 dstrow += cbStride;
702 }
703 }
704
705 HeapFree(GetProcessHeap(), 0, srcdata);
706
707 return res;
708 }
709 return S_OK;
710 case format_32bppBGR:
711 if (prc)
712 {
713 HRESULT res;
714 INT x, y;
715
716 res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
717 if (FAILED(res)) return res;
718
719 /* set all alpha values to 255 */
720 for (y=0; y<prc->Height; y++)
721 for (x=0; x<prc->Width; x++)
722 pbBuffer[cbStride*y+4*x+3] = 0xff;
723 }
724 return S_OK;
725 case format_32bppRGBA:
726 if (prc)
727 {
728 HRESULT res;
729 res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
730 if (FAILED(res)) return res;
731 convert_rgba_to_bgra(4, pbBuffer, prc->Width, prc->Height, cbStride);
732 }
733 return S_OK;
734 case format_32bppBGRA:
735 if (prc)
736 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
737 return S_OK;
738 case format_32bppPBGRA:
739 if (prc)
740 {
741 HRESULT res;
742 INT x, y;
743
744 res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
745 if (FAILED(res)) return res;
746
747 for (y=0; y<prc->Height; y++)
748 for (x=0; x<prc->Width; x++)
749 {
750 BYTE alpha = pbBuffer[cbStride*y+4*x+3];
751 if (alpha != 0 && alpha != 255)
752 {
753 pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * 255 / alpha;
754 pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * 255 / alpha;
755 pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * 255 / alpha;
756 }
757 }
758 }
759 return S_OK;
760 case format_48bppRGB:
761 if (prc)
762 {
763 HRESULT res;
764 INT x, y;
765 BYTE *srcdata;
766 UINT srcstride, srcdatasize;
767 const BYTE *srcrow;
768 const BYTE *srcpixel;
769 BYTE *dstrow;
770 DWORD *dstpixel;
771
772 srcstride = 6 * prc->Width;
773 srcdatasize = srcstride * prc->Height;
774
775 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
776 if (!srcdata) return E_OUTOFMEMORY;
777
778 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
779
780 if (SUCCEEDED(res))
781 {
782 srcrow = srcdata;
783 dstrow = pbBuffer;
784 for (y=0; y<prc->Height; y++) {
785 srcpixel=srcrow;
786 dstpixel=(DWORD*)dstrow;
787 for (x=0; x<prc->Width; x++) {
788 BYTE red, green, blue;
789 srcpixel++; red = *srcpixel++;
790 srcpixel++; green = *srcpixel++;
791 srcpixel++; blue = *srcpixel++;
792 *dstpixel++=0xff000000|red<<16|green<<8|blue;
793 }
794 srcrow += srcstride;
795 dstrow += cbStride;
796 }
797 }
798
799 HeapFree(GetProcessHeap(), 0, srcdata);
800
801 return res;
802 }
803 return S_OK;
804 case format_64bppRGBA:
805 if (prc)
806 {
807 HRESULT res;
808 INT x, y;
809 BYTE *srcdata;
810 UINT srcstride, srcdatasize;
811 const BYTE *srcrow;
812 const BYTE *srcpixel;
813 BYTE *dstrow;
814 DWORD *dstpixel;
815
816 srcstride = 8 * prc->Width;
817 srcdatasize = srcstride * prc->Height;
818
819 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
820 if (!srcdata) return E_OUTOFMEMORY;
821
822 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
823
824 if (SUCCEEDED(res))
825 {
826 srcrow = srcdata;
827 dstrow = pbBuffer;
828 for (y=0; y<prc->Height; y++) {
829 srcpixel=srcrow;
830 dstpixel=(DWORD*)dstrow;
831 for (x=0; x<prc->Width; x++) {
832 BYTE red, green, blue, alpha;
833 srcpixel++; red = *srcpixel++;
834 srcpixel++; green = *srcpixel++;
835 srcpixel++; blue = *srcpixel++;
836 srcpixel++; alpha = *srcpixel++;
837 *dstpixel++=alpha<<24|red<<16|green<<8|blue;
838 }
839 srcrow += srcstride;
840 dstrow += cbStride;
841 }
842 }
843
844 HeapFree(GetProcessHeap(), 0, srcdata);
845
846 return res;
847 }
848 return S_OK;
849 case format_32bppCMYK:
850 if (prc)
851 {
852 HRESULT res;
853 UINT x, y;
854
855 res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
856 if (FAILED(res)) return res;
857
858 for (y=0; y<prc->Height; y++)
859 for (x=0; x<prc->Width; x++)
860 {
861 BYTE *pixel = pbBuffer+cbStride*y+4*x;
862 BYTE c=pixel[0], m=pixel[1], y=pixel[2], k=pixel[3];
863 pixel[0] = (255-y)*(255-k)/255; /* blue */
864 pixel[1] = (255-m)*(255-k)/255; /* green */
865 pixel[2] = (255-c)*(255-k)/255; /* red */
866 pixel[3] = 255; /* alpha */
867 }
868 }
869 return S_OK;
870 default:
871 FIXME("Unimplemented conversion path!\n");
872 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
873 }
874}
875
876static HRESULT copypixels_to_32bppRGBA(struct FormatConverter *This, const WICRect *prc,
877 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
878{
879 HRESULT hr;
880
881 switch (source_format)
882 {
883 case format_32bppRGB:
884 if (prc)
885 {
886 INT x, y;
887
888 hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
889 if (FAILED(hr)) return hr;
890
891 /* set all alpha values to 255 */
892 for (y=0; y<prc->Height; y++)
893 for (x=0; x<prc->Width; x++)
894 pbBuffer[cbStride*y+4*x+3] = 0xff;
895 }
896 return S_OK;
897
898 case format_32bppRGBA:
899 if (prc)
900 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
901 return S_OK;
902
903 case format_32bppPRGBA:
904 if (prc)
905 {
906 INT x, y;
907
908 hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
909 if (FAILED(hr)) return hr;
910
911 for (y=0; y<prc->Height; y++)
912 for (x=0; x<prc->Width; x++)
913 {
914 BYTE alpha = pbBuffer[cbStride*y+4*x+3];
915 if (alpha != 0 && alpha != 255)
916 {
917 pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * 255 / alpha;
918 pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * 255 / alpha;
919 pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * 255 / alpha;
920 }
921 }
922 }
923 return S_OK;
924
925 default:
926 hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
927 if (SUCCEEDED(hr) && prc)
928 reverse_bgr8(4, pbBuffer, prc->Width, prc->Height, cbStride);
929 return hr;
930 }
931}
932
933static HRESULT copypixels_to_32bppBGR(struct FormatConverter *This, const WICRect *prc,
934 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
935{
936 switch (source_format)
937 {
938 case format_32bppBGR:
939 case format_32bppBGRA:
940 case format_32bppPBGRA:
941 if (prc)
942 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
943 return S_OK;
944 default:
945 return copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
946 }
947}
948
949static HRESULT copypixels_to_32bppRGB(struct FormatConverter *This, const WICRect *prc,
950 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
951{
952 switch (source_format)
953 {
954 case format_32bppRGB:
955 case format_32bppRGBA:
956 case format_32bppPRGBA:
957 if (prc)
958 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
959 return S_OK;
960 default:
961 return copypixels_to_32bppRGBA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
962 }
963}
964
965static HRESULT copypixels_to_32bppPBGRA(struct FormatConverter *This, const WICRect *prc,
966 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
967{
968 HRESULT hr;
969
970 switch (source_format)
971 {
972 case format_32bppPBGRA:
973 if (prc)
974 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
975 return S_OK;
976 default:
977 hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
978 if (SUCCEEDED(hr) && prc)
979 {
980 INT x, y;
981
982 for (y=0; y<prc->Height; y++)
983 for (x=0; x<prc->Width; x++)
984 {
985 BYTE alpha = pbBuffer[cbStride*y+4*x+3];
986 if (alpha != 255)
987 {
988 pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
989 pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
990 pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
991 }
992 }
993 }
994 return hr;
995 }
996}
997
998static HRESULT copypixels_to_32bppPRGBA(struct FormatConverter *This, const WICRect *prc,
999 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1000{
1001 HRESULT hr;
1002
1003 switch (source_format)
1004 {
1005 case format_32bppPRGBA:
1006 if (prc)
1007 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1008 return S_OK;
1009 default:
1010 hr = copypixels_to_32bppRGBA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
1011 if (SUCCEEDED(hr) && prc)
1012 {
1013 INT x, y;
1014
1015 for (y=0; y<prc->Height; y++)
1016 for (x=0; x<prc->Width; x++)
1017 {
1018 BYTE alpha = pbBuffer[cbStride*y+4*x+3];
1019 if (alpha != 255)
1020 {
1021 pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
1022 pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
1023 pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
1024 }
1025 }
1026 }
1027 return hr;
1028 }
1029}
1030
1031static HRESULT copypixels_to_24bppBGR(struct FormatConverter *This, const WICRect *prc,
1032 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1033{
1034 HRESULT hr;
1035
1036 switch (source_format)
1037 {
1038 case format_24bppBGR:
1039 case format_24bppRGB:
1040 if (prc)
1041 {
1042 hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1043 if (SUCCEEDED(hr) && source_format == format_24bppRGB)
1044 reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
1045 return hr;
1046 }
1047 return S_OK;
1048 case format_32bppBGR:
1049 case format_32bppBGRA:
1050 case format_32bppPBGRA:
1051 case format_32bppRGBA:
1052 if (prc)
1053 {
1054 HRESULT res;
1055 INT x, y;
1056 BYTE *srcdata;
1057 UINT srcstride, srcdatasize;
1058 const BYTE *srcrow;
1059 const BYTE *srcpixel;
1060 BYTE *dstrow;
1061 BYTE *dstpixel;
1062
1063 srcstride = 4 * prc->Width;
1064 srcdatasize = srcstride * prc->Height;
1065
1066 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1067 if (!srcdata) return E_OUTOFMEMORY;
1068
1069 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1070
1071 if (SUCCEEDED(res))
1072 {
1073 srcrow = srcdata;
1074 dstrow = pbBuffer;
1075
1076 if (source_format == format_32bppRGBA)
1077 {
1078 for (y = 0; y < prc->Height; y++)
1079 {
1080 srcpixel = srcrow;
1081 dstpixel = dstrow;
1082 for (x = 0; x < prc->Width; x++) {
1083 *dstpixel++ = srcpixel[2]; /* blue */
1084 *dstpixel++ = srcpixel[1]; /* green */
1085 *dstpixel++ = srcpixel[0]; /* red */
1086 srcpixel += 4;
1087 }
1088 srcrow += srcstride;
1089 dstrow += cbStride;
1090 }
1091 }
1092 else
1093 {
1094 for (y = 0; y < prc->Height; y++)
1095 {
1096 srcpixel = srcrow;
1097 dstpixel = dstrow;
1098 for (x = 0; x < prc->Width; x++) {
1099 *dstpixel++ = *srcpixel++; /* blue */
1100 *dstpixel++ = *srcpixel++; /* green */
1101 *dstpixel++ = *srcpixel++; /* red */
1102 srcpixel++; /* alpha */
1103 }
1104 srcrow += srcstride;
1105 dstrow += cbStride;
1106 }
1107 }
1108 }
1109
1110 HeapFree(GetProcessHeap(), 0, srcdata);
1111
1112 return res;
1113 }
1114 return S_OK;
1115
1116 case format_32bppGrayFloat:
1117 if (prc)
1118 {
1119 BYTE *srcdata;
1120 UINT srcstride, srcdatasize;
1121
1122 srcstride = 4 * prc->Width;
1123 srcdatasize = srcstride * prc->Height;
1124
1125 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1126 if (!srcdata) return E_OUTOFMEMORY;
1127
1128 hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1129
1130 if (SUCCEEDED(hr))
1131 {
1132 INT x, y;
1133 BYTE *src = srcdata, *dst = pbBuffer;
1134
1135 for (y = 0; y < prc->Height; y++)
1136 {
1137 float *gray_float = (float *)src;
1138 BYTE *bgr = dst;
1139
1140 for (x = 0; x < prc->Width; x++)
1141 {
1142 BYTE gray = (BYTE)floorf(to_sRGB_component(gray_float[x]) * 255.0f + 0.51f);
1143 *bgr++ = gray;
1144 *bgr++ = gray;
1145 *bgr++ = gray;
1146 }
1147 src += srcstride;
1148 dst += cbStride;
1149 }
1150 }
1151
1152 HeapFree(GetProcessHeap(), 0, srcdata);
1153
1154 return hr;
1155 }
1156 return S_OK;
1157
1158 case format_32bppCMYK:
1159 if (prc)
1160 {
1161 BYTE *srcdata;
1162 UINT srcstride, srcdatasize;
1163
1164 srcstride = 4 * prc->Width;
1165 srcdatasize = srcstride * prc->Height;
1166
1167 srcdata = heap_alloc(srcdatasize);
1168 if (!srcdata) return E_OUTOFMEMORY;
1169
1170 hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1171 if (SUCCEEDED(hr))
1172 {
1173 INT x, y;
1174 BYTE *src = srcdata, *dst = pbBuffer;
1175
1176 for (y = 0; y < prc->Height; y++)
1177 {
1178 BYTE *cmyk = src;
1179 BYTE *bgr = dst;
1180
1181 for (x = 0; x < prc->Width; x++)
1182 {
1183 BYTE c = cmyk[0], m = cmyk[1], y = cmyk[2], k = cmyk[3];
1184 bgr[0] = (255 - y) * (255 - k) / 255; /* B */
1185 bgr[1] = (255 - m) * (255 - k) / 255; /* G */
1186 bgr[2] = (255 - c) * (255 - k) / 255; /* R */
1187 cmyk += 4;
1188 bgr += 3;
1189 }
1190 src += srcstride;
1191 dst += cbStride;
1192 }
1193 }
1194
1195 heap_free(srcdata);
1196 return hr;
1197 }
1198 return S_OK;
1199
1200 default:
1201 FIXME("Unimplemented conversion path!\n");
1202 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1203 }
1204}
1205
1206static HRESULT copypixels_to_24bppRGB(struct FormatConverter *This, const WICRect *prc,
1207 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1208{
1209 HRESULT hr;
1210
1211 switch (source_format)
1212 {
1213 case format_24bppBGR:
1214 case format_24bppRGB:
1215 if (prc)
1216 {
1217 hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1218 if (SUCCEEDED(hr) && source_format == format_24bppBGR)
1219 reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
1220 return hr;
1221 }
1222 return S_OK;
1223 case format_32bppBGR:
1224 case format_32bppBGRA:
1225 case format_32bppPBGRA:
1226 if (prc)
1227 {
1228 HRESULT res;
1229 INT x, y;
1230 BYTE *srcdata;
1231 UINT srcstride, srcdatasize;
1232 const BYTE *srcrow;
1233 const BYTE *srcpixel;
1234 BYTE *dstrow;
1235 BYTE *dstpixel;
1236 BYTE tmppixel[3];
1237
1238 srcstride = 4 * prc->Width;
1239 srcdatasize = srcstride * prc->Height;
1240
1241 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1242 if (!srcdata) return E_OUTOFMEMORY;
1243
1244 res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1245
1246 if (SUCCEEDED(res))
1247 {
1248 srcrow = srcdata;
1249 dstrow = pbBuffer;
1250 for (y=0; y<prc->Height; y++) {
1251 srcpixel=srcrow;
1252 dstpixel=dstrow;
1253 for (x=0; x<prc->Width; x++) {
1254 tmppixel[0]=*srcpixel++; /* blue */
1255 tmppixel[1]=*srcpixel++; /* green */
1256 tmppixel[2]=*srcpixel++; /* red */
1257 srcpixel++; /* alpha */
1258
1259 *dstpixel++=tmppixel[2]; /* red */
1260 *dstpixel++=tmppixel[1]; /* green */
1261 *dstpixel++=tmppixel[0]; /* blue */
1262 }
1263 srcrow += srcstride;
1264 dstrow += cbStride;
1265 }
1266 }
1267
1268 HeapFree(GetProcessHeap(), 0, srcdata);
1269
1270 return res;
1271 }
1272 return S_OK;
1273 default:
1274 FIXME("Unimplemented conversion path!\n");
1275 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1276 }
1277}
1278
1279static HRESULT copypixels_to_32bppGrayFloat(struct FormatConverter *This, const WICRect *prc,
1280 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1281{
1282 HRESULT hr;
1283
1284 switch (source_format)
1285 {
1286 case format_32bppBGR:
1287 case format_32bppBGRA:
1288 case format_32bppPBGRA:
1289 case format_32bppGrayFloat:
1290 if (prc)
1291 {
1292 hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1293 break;
1294 }
1295 return S_OK;
1296
1297 default:
1298 hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
1299 break;
1300 }
1301
1302 if (SUCCEEDED(hr) && prc && source_format != format_32bppGrayFloat)
1303 {
1304 INT x, y;
1305 BYTE *p = pbBuffer;
1306
1307 for (y = 0; y < prc->Height; y++)
1308 {
1309 BYTE *bgr = p;
1310 for (x = 0; x < prc->Width; x++)
1311 {
1312 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
1313 *(float *)bgr = gray;
1314 bgr += 4;
1315 }
1316 p += cbStride;
1317 }
1318 }
1319 return hr;
1320}
1321
1322static HRESULT copypixels_to_8bppGray(struct FormatConverter *This, const WICRect *prc,
1323 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1324{
1325 HRESULT hr;
1326 BYTE *srcdata;
1327 UINT srcstride, srcdatasize;
1328
1329 if (source_format == format_8bppGray)
1330 {
1331 if (prc)
1332 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1333
1334 return S_OK;
1335 }
1336
1337 if (source_format == format_32bppGrayFloat)
1338 {
1339 hr = S_OK;
1340
1341 if (prc)
1342 {
1343 srcstride = 4 * prc->Width;
1344 srcdatasize = srcstride * prc->Height;
1345
1346 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1347 if (!srcdata) return E_OUTOFMEMORY;
1348
1349 hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1350 if (SUCCEEDED(hr))
1351 {
1352 INT x, y;
1353 BYTE *src = srcdata, *dst = pbBuffer;
1354
1355 for (y=0; y < prc->Height; y++)
1356 {
1357 float *srcpixel = (float*)src;
1358 BYTE *dstpixel = dst;
1359
1360 for (x=0; x < prc->Width; x++)
1361 *dstpixel++ = (BYTE)floorf(to_sRGB_component(*srcpixel++) * 255.0f + 0.51f);
1362
1363 src += srcstride;
1364 dst += cbStride;
1365 }
1366 }
1367
1368 HeapFree(GetProcessHeap(), 0, srcdata);
1369 }
1370
1371 return hr;
1372 }
1373
1374 if (!prc)
1375 return copypixels_to_24bppBGR(This, NULL, cbStride, cbBufferSize, pbBuffer, source_format);
1376
1377 srcstride = 3 * prc->Width;
1378 srcdatasize = srcstride * prc->Height;
1379
1380 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1381 if (!srcdata) return E_OUTOFMEMORY;
1382
1383 hr = copypixels_to_24bppBGR(This, prc, srcstride, srcdatasize, srcdata, source_format);
1384 if (SUCCEEDED(hr))
1385 {
1386 INT x, y;
1387 BYTE *src = srcdata, *dst = pbBuffer;
1388
1389 for (y = 0; y < prc->Height; y++)
1390 {
1391 BYTE *bgr = src;
1392
1393 for (x = 0; x < prc->Width; x++)
1394 {
1395 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
1396
1397 gray = to_sRGB_component(gray) * 255.0f;
1398 dst[x] = (BYTE)floorf(gray + 0.51f);
1399 bgr += 3;
1400 }
1401 src += srcstride;
1402 dst += cbStride;
1403 }
1404 }
1405
1406 HeapFree(GetProcessHeap(), 0, srcdata);
1407 return hr;
1408}
1409
1410static UINT rgb_to_palette_index(BYTE bgr[3], WICColor *colors, UINT count)
1411{
1412 UINT best_diff, best_index, i;
1413
1414 best_diff = ~0;
1415 best_index = 0;
1416
1417 for (i = 0; i < count; i++)
1418 {
1419 BYTE pal_r, pal_g, pal_b;
1420 UINT diff_r, diff_g, diff_b, diff;
1421
1422 pal_r = colors[i] >> 16;
1423 pal_g = colors[i] >> 8;
1424 pal_b = colors[i];
1425
1426 diff_r = bgr[2] - pal_r;
1427 diff_g = bgr[1] - pal_g;
1428 diff_b = bgr[0] - pal_b;
1429
1430 diff = diff_r * diff_r + diff_g * diff_g + diff_b * diff_b;
1431 if (diff == 0) return i;
1432
1433 if (diff < best_diff)
1434 {
1435 best_diff = diff;
1436 best_index = i;
1437 }
1438 }
1439
1440 return best_index;
1441}
1442
1443static HRESULT copypixels_to_8bppIndexed(struct FormatConverter *This, const WICRect *prc,
1444 UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1445{
1446 HRESULT hr;
1447 BYTE *srcdata;
1448 WICColor colors[256];
1449 UINT srcstride, srcdatasize, count;
1450
1451 if (source_format == format_8bppIndexed)
1452 {
1453 if (prc)
1454 return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1455
1456 return S_OK;
1457 }
1458
1459 if (!prc)
1460 return copypixels_to_24bppBGR(This, NULL, cbStride, cbBufferSize, pbBuffer, source_format);
1461
1462 if (!This->palette) return WINCODEC_ERR_WRONGSTATE;
1463
1464 hr = IWICPalette_GetColors(This->palette, 256, colors, &count);
1465 if (hr != S_OK) return hr;
1466
1467 srcstride = 3 * prc->Width;
1468 srcdatasize = srcstride * prc->Height;
1469
1470 srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1471 if (!srcdata) return E_OUTOFMEMORY;
1472
1473 hr = copypixels_to_24bppBGR(This, prc, srcstride, srcdatasize, srcdata, source_format);
1474 if (SUCCEEDED(hr))
1475 {
1476 INT x, y;
1477 BYTE *src = srcdata, *dst = pbBuffer;
1478
1479 for (y = 0; y < prc->Height; y++)
1480 {
1481 BYTE *bgr = src;
1482
1483 for (x = 0; x < prc->Width; x++)
1484 {
1485 dst[x] = rgb_to_palette_index(bgr, colors, count);
1486 bgr += 3;
1487 }
1488 src += srcstride;
1489 dst += cbStride;
1490 }
1491 }
1492
1493 HeapFree(GetProcessHeap(), 0, srcdata);
1494 return hr;
1495}
1496
1497static const struct pixelformatinfo supported_formats[] = {
1498 {format_1bppIndexed, &GUID_WICPixelFormat1bppIndexed, NULL},
1499 {format_2bppIndexed, &GUID_WICPixelFormat2bppIndexed, NULL},
1500 {format_4bppIndexed, &GUID_WICPixelFormat4bppIndexed, NULL},
1501 {format_8bppIndexed, &GUID_WICPixelFormat8bppIndexed, copypixels_to_8bppIndexed},
1502 {format_BlackWhite, &GUID_WICPixelFormatBlackWhite, NULL},
1503 {format_2bppGray, &GUID_WICPixelFormat2bppGray, NULL},
1504 {format_4bppGray, &GUID_WICPixelFormat4bppGray, NULL},
1505 {format_8bppGray, &GUID_WICPixelFormat8bppGray, copypixels_to_8bppGray},
1506 {format_16bppGray, &GUID_WICPixelFormat16bppGray, NULL},
1507 {format_16bppBGR555, &GUID_WICPixelFormat16bppBGR555, NULL},
1508 {format_16bppBGR565, &GUID_WICPixelFormat16bppBGR565, NULL},
1509 {format_16bppBGRA5551, &GUID_WICPixelFormat16bppBGRA5551, NULL},
1510 {format_24bppBGR, &GUID_WICPixelFormat24bppBGR, copypixels_to_24bppBGR},
1511 {format_24bppRGB, &GUID_WICPixelFormat24bppRGB, copypixels_to_24bppRGB},
1512 {format_32bppGrayFloat, &GUID_WICPixelFormat32bppGrayFloat, copypixels_to_32bppGrayFloat},
1513 {format_32bppBGR, &GUID_WICPixelFormat32bppBGR, copypixels_to_32bppBGR},
1514 {format_32bppRGB, &GUID_WICPixelFormat32bppRGB, copypixels_to_32bppRGB},
1515 {format_32bppBGRA, &GUID_WICPixelFormat32bppBGRA, copypixels_to_32bppBGRA},
1516 {format_32bppRGBA, &GUID_WICPixelFormat32bppRGBA, copypixels_to_32bppRGBA},
1517 {format_32bppPBGRA, &GUID_WICPixelFormat32bppPBGRA, copypixels_to_32bppPBGRA},
1518 {format_32bppPRGBA, &GUID_WICPixelFormat32bppPRGBA, copypixels_to_32bppPRGBA},
1519 {format_48bppRGB, &GUID_WICPixelFormat48bppRGB, NULL},
1520 {format_64bppRGBA, &GUID_WICPixelFormat64bppRGBA, NULL},
1521 {format_32bppCMYK, &GUID_WICPixelFormat32bppCMYK, NULL},
1522 {0}
1523};
1524
1525static const struct pixelformatinfo *get_formatinfo(const WICPixelFormatGUID *format)
1526{
1527 UINT i;
1528
1529 for (i=0; supported_formats[i].guid; i++)
1530 if (IsEqualGUID(supported_formats[i].guid, format)) return &supported_formats[i];
1531
1532 return NULL;
1533}
1534
1535static HRESULT WINAPI FormatConverter_QueryInterface(IWICFormatConverter *iface, REFIID iid,
1536 void **ppv)
1537{
1538 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1539 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1540
1541 if (!ppv) return E_INVALIDARG;
1542
1543 if (IsEqualIID(&IID_IUnknown, iid) ||
1544 IsEqualIID(&IID_IWICBitmapSource, iid) ||
1545 IsEqualIID(&IID_IWICFormatConverter, iid))
1546 {
1547 *ppv = &This->IWICFormatConverter_iface;
1548 }
1549 else
1550 {
1551 *ppv = NULL;
1552 return E_NOINTERFACE;
1553 }
1554
1555 IUnknown_AddRef((IUnknown*)*ppv);
1556 return S_OK;
1557}
1558
1559static ULONG WINAPI FormatConverter_AddRef(IWICFormatConverter *iface)
1560{
1561 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1562 ULONG ref = InterlockedIncrement(&This->ref);
1563
1564 TRACE("(%p) refcount=%u\n", iface, ref);
1565
1566 return ref;
1567}
1568
1569static ULONG WINAPI FormatConverter_Release(IWICFormatConverter *iface)
1570{
1571 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1572 ULONG ref = InterlockedDecrement(&This->ref);
1573
1574 TRACE("(%p) refcount=%u\n", iface, ref);
1575
1576 if (ref == 0)
1577 {
1578 This->lock.DebugInfo->Spare[0] = 0;
1579 DeleteCriticalSection(&This->lock);
1580 if (This->source) IWICBitmapSource_Release(This->source);
1581 if (This->palette) IWICPalette_Release(This->palette);
1582 HeapFree(GetProcessHeap(), 0, This);
1583 }
1584
1585 return ref;
1586}
1587
1588static HRESULT WINAPI FormatConverter_GetSize(IWICFormatConverter *iface,
1589 UINT *puiWidth, UINT *puiHeight)
1590{
1591 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1592
1593 TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
1594
1595 if (This->source)
1596 return IWICBitmapSource_GetSize(This->source, puiWidth, puiHeight);
1597 else
1598 return WINCODEC_ERR_NOTINITIALIZED;
1599}
1600
1601static HRESULT WINAPI FormatConverter_GetPixelFormat(IWICFormatConverter *iface,
1602 WICPixelFormatGUID *pPixelFormat)
1603{
1604 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1605
1606 TRACE("(%p,%p)\n", iface, pPixelFormat);
1607
1608 if (This->source)
1609 memcpy(pPixelFormat, This->dst_format->guid, sizeof(GUID));
1610 else
1611 return WINCODEC_ERR_NOTINITIALIZED;
1612
1613 return S_OK;
1614}
1615
1616static HRESULT WINAPI FormatConverter_GetResolution(IWICFormatConverter *iface,
1617 double *pDpiX, double *pDpiY)
1618{
1619 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1620
1621 TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
1622
1623 if (This->source)
1624 return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
1625 else
1626 return WINCODEC_ERR_NOTINITIALIZED;
1627}
1628
1629static HRESULT WINAPI FormatConverter_CopyPalette(IWICFormatConverter *iface,
1630 IWICPalette *palette)
1631{
1632 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1633
1634 TRACE("(%p,%p)\n", iface, palette);
1635
1636 if (!palette) return E_INVALIDARG;
1637 if (!This->source) return WINCODEC_ERR_WRONGSTATE;
1638
1639 if (!This->palette)
1640 {
1641 HRESULT hr;
1642 UINT bpp;
1643
1644 hr = get_pixelformat_bpp(This->dst_format->guid, &bpp);
1645 if (hr != S_OK) return hr;
1646 if (bpp <= 8) return WINCODEC_ERR_WRONGSTATE;
1647 return IWICBitmapSource_CopyPalette(This->source, palette);
1648 }
1649
1650 return IWICPalette_InitializeFromPalette(palette, This->palette);
1651}
1652
1653static HRESULT WINAPI FormatConverter_CopyPixels(IWICFormatConverter *iface,
1654 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
1655{
1656 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1657 WICRect rc;
1658 HRESULT hr;
1659 TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
1660
1661 if (This->source)
1662 {
1663 if (!prc)
1664 {
1665 UINT width, height;
1666 hr = IWICBitmapSource_GetSize(This->source, &width, &height);
1667 if (FAILED(hr)) return hr;
1668 rc.X = 0;
1669 rc.Y = 0;
1670 rc.Width = width;
1671 rc.Height = height;
1672 prc = &rc;
1673 }
1674
1675 return This->dst_format->copy_function(This, prc, cbStride, cbBufferSize,
1676 pbBuffer, This->src_format->format);
1677 }
1678 else
1679 return WINCODEC_ERR_WRONGSTATE;
1680}
1681
1682static HRESULT WINAPI FormatConverter_Initialize(IWICFormatConverter *iface,
1683 IWICBitmapSource *source, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither,
1684 IWICPalette *palette, double alpha_threshold, WICBitmapPaletteType palette_type)
1685{
1686 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1687 const struct pixelformatinfo *srcinfo, *dstinfo;
1688 GUID srcFormat;
1689 HRESULT res;
1690
1691 TRACE("(%p,%p,%s,%u,%p,%0.3f,%u)\n", iface, source, debugstr_guid(dstFormat),
1692 dither, palette, alpha_threshold, palette_type);
1693
1694 if (!palette)
1695 {
1696 UINT bpp;
1697 res = get_pixelformat_bpp(dstFormat, &bpp);
1698 if (res != S_OK) return res;
1699
1700 res = PaletteImpl_Create(&palette);
1701 if (res != S_OK) return res;
1702
1703 switch (palette_type)
1704 {
1705 case WICBitmapPaletteTypeCustom:
1706 IWICPalette_Release(palette);
1707 palette = NULL;
1708 if (bpp <= 8) return E_INVALIDARG;
1709 break;
1710
1711 case WICBitmapPaletteTypeMedianCut:
1712 {
1713 if (bpp <= 8)
1714 res = IWICPalette_InitializeFromBitmap(palette, source, 1 << bpp, FALSE);
1715 break;
1716 }
1717
1718 default:
1719 if (bpp <= 8)
1720 res = IWICPalette_InitializePredefined(palette, palette_type, FALSE);
1721 break;
1722 }
1723
1724 if (res != S_OK)
1725 {
1726 IWICPalette_Release(palette);
1727 return res;
1728 }
1729 }
1730 else
1731 IWICPalette_AddRef(palette);
1732
1733 EnterCriticalSection(&This->lock);
1734
1735 if (This->source)
1736 {
1737 res = WINCODEC_ERR_WRONGSTATE;
1738 goto end;
1739 }
1740
1741 res = IWICBitmapSource_GetPixelFormat(source, &srcFormat);
1742 if (FAILED(res)) goto end;
1743
1744 srcinfo = get_formatinfo(&srcFormat);
1745 if (!srcinfo)
1746 {
1747 res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1748 FIXME("Unsupported source format %s\n", debugstr_guid(&srcFormat));
1749 goto end;
1750 }
1751
1752 dstinfo = get_formatinfo(dstFormat);
1753 if (!dstinfo)
1754 {
1755 res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1756 FIXME("Unsupported destination format %s\n", debugstr_guid(dstFormat));
1757 goto end;
1758 }
1759
1760 if (dstinfo->copy_function)
1761 {
1762 IWICBitmapSource_AddRef(source);
1763 This->src_format = srcinfo;
1764 This->dst_format = dstinfo;
1765 This->dither = dither;
1766 This->alpha_threshold = alpha_threshold;
1767 This->palette = palette;
1768 This->source = source;
1769 }
1770 else
1771 {
1772 FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
1773 res = WINCODEC_ERR_UNSUPPORTEDOPERATION;
1774 }
1775
1776end:
1777
1778 LeaveCriticalSection(&This->lock);
1779
1780 if (res != S_OK && palette)
1781 IWICPalette_Release(palette);
1782
1783 return res;
1784}
1785
1786static HRESULT WINAPI FormatConverter_CanConvert(IWICFormatConverter *iface,
1787 REFWICPixelFormatGUID srcPixelFormat, REFWICPixelFormatGUID dstPixelFormat,
1788 BOOL *pfCanConvert)
1789{
1790 FormatConverter *This = impl_from_IWICFormatConverter(iface);
1791 const struct pixelformatinfo *srcinfo, *dstinfo;
1792
1793 TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(srcPixelFormat),
1794 debugstr_guid(dstPixelFormat), pfCanConvert);
1795
1796 srcinfo = get_formatinfo(srcPixelFormat);
1797 if (!srcinfo)
1798 {
1799 FIXME("Unsupported source format %s\n", debugstr_guid(srcPixelFormat));
1800 return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1801 }
1802
1803 dstinfo = get_formatinfo(dstPixelFormat);
1804 if (!dstinfo)
1805 {
1806 FIXME("Unsupported destination format %s\n", debugstr_guid(dstPixelFormat));
1807 return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1808 }
1809
1810 if (dstinfo->copy_function &&
1811 SUCCEEDED(dstinfo->copy_function(This, NULL, 0, 0, NULL, dstinfo->format)))
1812 *pfCanConvert = TRUE;
1813 else
1814 {
1815 FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(srcPixelFormat), debugstr_guid(dstPixelFormat));
1816 *pfCanConvert = FALSE;
1817 }
1818
1819 return S_OK;
1820}
1821
1822static const IWICFormatConverterVtbl FormatConverter_Vtbl = {
1823 FormatConverter_QueryInterface,
1824 FormatConverter_AddRef,
1825 FormatConverter_Release,
1826 FormatConverter_GetSize,
1827 FormatConverter_GetPixelFormat,
1828 FormatConverter_GetResolution,
1829 FormatConverter_CopyPalette,
1830 FormatConverter_CopyPixels,
1831 FormatConverter_Initialize,
1832 FormatConverter_CanConvert
1833};
1834
1835HRESULT FormatConverter_CreateInstance(REFIID iid, void** ppv)
1836{
1837 FormatConverter *This;
1838 HRESULT ret;
1839
1840 TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1841
1842 *ppv = NULL;
1843
1844 This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverter));
1845 if (!This) return E_OUTOFMEMORY;
1846
1847 This->IWICFormatConverter_iface.lpVtbl = &FormatConverter_Vtbl;
1848 This->ref = 1;
1849 This->source = NULL;
1850 This->palette = NULL;
1851 InitializeCriticalSection(&This->lock);
1852 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FormatConverter.lock");
1853
1854 ret = IWICFormatConverter_QueryInterface(&This->IWICFormatConverter_iface, iid, ppv);
1855 IWICFormatConverter_Release(&This->IWICFormatConverter_iface);
1856
1857 return ret;
1858}
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
heap_free
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
FIXME
#define FIXME(fmt,...)
Definition: debug.h:111
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
bpp
DWORD bpp
Definition: surface.c:185
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
palette_type
WICBitmapPaletteType palette_type
Definition: image.c:53
FormatConverter_QueryInterface
static HRESULT WINAPI FormatConverter_QueryInterface(IWICFormatConverter *iface, REFIID iid, void **ppv)
Definition: converter.c:1535
rgb_to_palette_index
static UINT rgb_to_palette_index(BYTE bgr[3], WICColor *colors, UINT count)
Definition: converter.c:1410
copypixels_to_32bppRGB
static HRESULT copypixels_to_32bppRGB(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:949
impl_from_IWICFormatConverter
static FormatConverter * impl_from_IWICFormatConverter(IWICFormatConverter *iface)
Definition: converter.c:136
FormatConverter_CanConvert
static HRESULT WINAPI FormatConverter_CanConvert(IWICFormatConverter *iface, REFWICPixelFormatGUID srcPixelFormat, REFWICPixelFormatGUID dstPixelFormat, BOOL *pfCanConvert)
Definition: converter.c:1786
FormatConverter_Vtbl
static const IWICFormatConverterVtbl FormatConverter_Vtbl
Definition: converter.c:1822
FormatConverter_CopyPalette
static HRESULT WINAPI FormatConverter_CopyPalette(IWICFormatConverter *iface, IWICPalette *palette)
Definition: converter.c:1629
copypixels_to_32bppPRGBA
static HRESULT copypixels_to_32bppPRGBA(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:998
FormatConverter_CreateInstance
HRESULT FormatConverter_CreateInstance(REFIID iid, void **ppv)
Definition: converter.c:1835
FormatConverter_GetResolution
static HRESULT WINAPI FormatConverter_GetResolution(IWICFormatConverter *iface, double *pDpiX, double *pDpiY)
Definition: converter.c:1616
copypixels_to_32bppBGR
static HRESULT copypixels_to_32bppBGR(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:933
FormatConverter_Initialize
static HRESULT WINAPI FormatConverter_Initialize(IWICFormatConverter *iface, IWICBitmapSource *source, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither, IWICPalette *palette, double alpha_threshold, WICBitmapPaletteType palette_type)
Definition: converter.c:1682
FormatConverter_Release
static ULONG WINAPI FormatConverter_Release(IWICFormatConverter *iface)
Definition: converter.c:1569
copypixels_to_24bppBGR
static HRESULT copypixels_to_24bppBGR(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:1031
supported_formats
static const struct pixelformatinfo supported_formats[]
Definition: converter.c:1497
get_formatinfo
static const struct pixelformatinfo * get_formatinfo(const WICPixelFormatGUID *format)
Definition: converter.c:1525
copypixels_to_24bppRGB
static HRESULT copypixels_to_24bppRGB(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:1206
copypixels_to_8bppGray
static HRESULT copypixels_to_8bppGray(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:1322
copypixels_to_8bppIndexed
static HRESULT copypixels_to_8bppIndexed(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:1443
FormatConverter_CopyPixels
static HRESULT WINAPI FormatConverter_CopyPixels(IWICFormatConverter *iface, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
Definition: converter.c:1653
to_sRGB_component
static float to_sRGB_component(float f)
Definition: converter.c:88
copypixels_to_32bppRGBA
static HRESULT copypixels_to_32bppRGBA(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:876
FormatConverter_AddRef
static ULONG WINAPI FormatConverter_AddRef(IWICFormatConverter *iface)
Definition: converter.c:1559
copypixels_to_32bppBGRA
static HRESULT copypixels_to_32bppBGRA(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:141
pixelformat
pixelformat
Definition: converter.c:40
format_8bppIndexed
@ format_8bppIndexed
Definition: converter.c:44
format_24bppRGB
@ format_24bppRGB
Definition: converter.c:54
format_4bppIndexed
@ format_4bppIndexed
Definition: converter.c:43
format_4bppGray
@ format_4bppGray
Definition: converter.c:47
format_32bppRGBA
@ format_32bppRGBA
Definition: converter.c:59
format_32bppRGB
@ format_32bppRGB
Definition: converter.c:57
format_2bppGray
@ format_2bppGray
Definition: converter.c:46
format_64bppRGBA
@ format_64bppRGBA
Definition: converter.c:63
format_16bppBGR565
@ format_16bppBGR565
Definition: converter.c:51
format_32bppBGR
@ format_32bppBGR
Definition: converter.c:56
format_32bppPRGBA
@ format_32bppPRGBA
Definition: converter.c:61
format_32bppBGRA
@ format_32bppBGRA
Definition: converter.c:58
format_32bppPBGRA
@ format_32bppPBGRA
Definition: converter.c:60
format_16bppBGR555
@ format_16bppBGR555
Definition: converter.c:50
format_48bppRGB
@ format_48bppRGB
Definition: converter.c:62
format_16bppBGRA5551
@ format_16bppBGRA5551
Definition: converter.c:52
format_BlackWhite
@ format_BlackWhite
Definition: converter.c:45
format_16bppGray
@ format_16bppGray
Definition: converter.c:49
format_8bppGray
@ format_8bppGray
Definition: converter.c:48
format_1bppIndexed
@ format_1bppIndexed
Definition: converter.c:41
format_32bppCMYK
@ format_32bppCMYK
Definition: converter.c:64
format_24bppBGR
@ format_24bppBGR
Definition: converter.c:53
format_2bppIndexed
@ format_2bppIndexed
Definition: converter.c:42
format_32bppGrayFloat
@ format_32bppGrayFloat
Definition: converter.c:55
copypixels_to_32bppPBGRA
static HRESULT copypixels_to_32bppPBGRA(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:965
FormatConverter_GetPixelFormat
static HRESULT WINAPI FormatConverter_GetPixelFormat(IWICFormatConverter *iface, WICPixelFormatGUID *pPixelFormat)
Definition: converter.c:1601
copyfunc
HRESULT(* copyfunc)(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:67
copypixels_to_32bppGrayFloat
static HRESULT copypixels_to_32bppGrayFloat(struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
Definition: converter.c:1279
FormatConverter_GetSize
static HRESULT WINAPI FormatConverter_GetSize(IWICFormatConverter *iface, UINT *puiWidth, UINT *puiHeight)
Definition: converter.c:1588
reverse_bgr8
void reverse_bgr8(UINT bytesperpixel, LPBYTE bits, UINT width, UINT height, INT stride)
Definition: main.c:212
get_pixelformat_bpp
HRESULT get_pixelformat_bpp(const GUID *pixelformat, UINT *bpp)
Definition: main.c:252
convert_rgba_to_bgra
void convert_rgba_to_bgra(UINT bytesperpixel, LPBYTE bits, UINT width, UINT height, INT stride)
Definition: main.c:231
PaletteImpl_Create
HRESULT PaletteImpl_Create(IWICPalette **palette)
Definition: palette.c:899
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
green
GLclampf green
Definition: gl.h:1740
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
alpha
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
end
GLuint GLuint end
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
blue
GLclampf GLclampf blue
Definition: gl.h:1740
width
GLint GLint GLsizei width
Definition: gl.h:1546
res
GLuint res
Definition: glext.h:9613
src
GLenum src
Definition: glext.h:6340
c
const GLubyte * c
Definition: glext.h:8905
f
GLfloat f
Definition: glext.h:7540
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
dst
GLenum GLenum dst
Definition: glext.h:6340
g
GLboolean GLboolean g
Definition: glext.h:6204
p
GLfloat GLfloat p
Definition: glext.h:8902
m
const GLfloat * m
Definition: glext.h:10848
i
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
powf
_Check_return_ float __cdecl powf(_In_ float b, _In_ float e)
Definition: math.h:232
ppv
REFIID LPVOID * ppv
Definition: atlbase.h:39
S_OK
#define S_OK
Definition: intsafe.h:52
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
dstinfo
j_compress_ptr dstinfo
Definition: jpeglib.h:1100
f
#define f
Definition: ke_i.h:83
c
#define c
Definition: ke_i.h:80
b
#define b
Definition: ke_i.h:79
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
red
#define red
Definition: linetest.c:67
guid
const GUID * guid
Definition: metadataquery.c:687
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
palette
static HPALETTE palette
Definition: clipboard.c:1345
k
int k
Definition: mpi.c:3369
floorf
#define floorf(x)
Definition: mymath.h:65
UINT
unsigned int UINT
Definition: ndis.h:50
prc
_Out_ LPRECT prc
Definition: ntgdi.h:1658
LONG
long LONG
Definition: pedump.c:60
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
IsEqualIID
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
REFIID
#define REFIID
Definition: guiddef.h:118
hr
HRESULT hr
Definition: shlfolder.c:183
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
FormatConverter::alpha_threshold
double alpha_threshold
Definition: converter.c:82
FormatConverter::IWICFormatConverter_iface
IWICFormatConverter IWICFormatConverter_iface
Definition: converter.c:77
FormatConverter::palette
IWICPalette * palette
Definition: converter.c:83
FormatConverter::src_format
const struct pixelformatinfo * src_format
Definition: converter.c:80
FormatConverter::source
IWICBitmapSource * source
Definition: converter.c:79
FormatConverter::dst_format
const struct pixelformatinfo * dst_format
Definition: converter.c:80
FormatConverter::dither
WICBitmapDitherType dither
Definition: converter.c:81
FormatConverter::lock
CRITICAL_SECTION lock
Definition: converter.c:84
WICRect::Height
INT Height
Definition: wincodec.idl:301
WICRect::Width
INT Width
Definition: wincodec.idl:300
_CRITICAL_SECTION
Definition: winbase.h:893
_GUID
Definition: scsiwmi.h:51
pixelformatinfo::format
enum pixelformat format
Definition: converter.c:71
pixelformatinfo::copy_function
copyfunc copy_function
Definition: converter.c:73
pixelformatinfo::guid
const WICPixelFormatGUID * guid
Definition: converter.c:72
ref
Definition: send.c:48
InitializeCriticalSection
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
DWORD_PTR
#define DWORD_PTR
Definition: treelist.c:76
INT
int32_t INT
Definition: typedefs.h:58
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
ret
int ret
Definition: wcstombs-tests.c:31
LeaveCriticalSection
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
DeleteCriticalSection
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
WICBitmapDitherType
WICBitmapDitherType
Definition: wincodec.idl:55
WICBitmapPaletteType
WICBitmapPaletteType
Definition: wincodec.idl:90
WICBitmapPaletteTypeCustom
@ WICBitmapPaletteTypeCustom
Definition: wincodec.idl:91
WICBitmapPaletteTypeFixedBW
@ WICBitmapPaletteTypeFixedBW
Definition: wincodec.idl:93
WICBitmapPaletteTypeFixedGray16
@ WICBitmapPaletteTypeFixedGray16
Definition: wincodec.idl:103
WICBitmapPaletteTypeFixedGray4
@ WICBitmapPaletteTypeFixedGray4
Definition: wincodec.idl:102
WICBitmapPaletteTypeMedianCut
@ WICBitmapPaletteTypeMedianCut
Definition: wincodec.idl:92
WICColor
UINT32 WICColor
Definition: wincodec.idl:312
wincodecs_private.h
debug_wic_rect
static const char * debug_wic_rect(const WICRect *rect)
Definition: wincodecs_private.h:249
HRESULT
#define HRESULT
Definition: msvc.h:7
WINAPI
#define WINAPI
Definition: msvc.h:6
WINCODEC_ERR_WRONGSTATE
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3273
WINCODEC_ERR_UNSUPPORTEDOPERATION
#define WINCODEC_ERR_UNSUPPORTEDOPERATION
Definition: winerror.h:3300
WINCODEC_ERR_NOTINITIALIZED
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3277
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:2364
WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT
#define WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT
Definition: winerror.h:3299
BYTE
unsigned char BYTE
Definition: xxhash.c:193