d3dcompiler: Add a stub parser.
[wine] / dlls / windowscodecs / converter.c
1 /*
2  * Copyright 2009 Vincent Povirk
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "objbase.h"
28 #include "wincodec.h"
29
30 #include "wincodecs_private.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
35
36 struct FormatConverter;
37
38 enum pixelformat {
39     format_1bppIndexed,
40     format_2bppIndexed,
41     format_4bppIndexed,
42     format_8bppIndexed,
43     format_BlackWhite,
44     format_2bppGray,
45     format_4bppGray,
46     format_8bppGray,
47     format_16bppGray,
48     format_16bppBGR555,
49     format_16bppBGR565,
50     format_16bppBGRA5551,
51     format_24bppBGR,
52     format_32bppBGR,
53     format_32bppBGRA,
54     format_32bppPBGRA,
55     format_48bppRGB,
56     format_64bppRGBA,
57     format_32bppCMYK,
58 };
59
60 typedef HRESULT (*copyfunc)(struct FormatConverter *This, const WICRect *prc,
61     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format);
62
63 struct pixelformatinfo {
64     enum pixelformat format;
65     const WICPixelFormatGUID *guid;
66     copyfunc copy_function;
67 };
68
69 typedef struct FormatConverter {
70     IWICFormatConverter IWICFormatConverter_iface;
71     LONG ref;
72     IWICBitmapSource *source;
73     const struct pixelformatinfo *dst_format, *src_format;
74     WICBitmapDitherType dither;
75     double alpha_threshold;
76     WICBitmapPaletteType palette_type;
77     CRITICAL_SECTION lock; /* must be held when initialized */
78 } FormatConverter;
79
80 static inline FormatConverter *impl_from_IWICFormatConverter(IWICFormatConverter *iface)
81 {
82     return CONTAINING_RECORD(iface, FormatConverter, IWICFormatConverter_iface);
83 }
84
85 static void make_grayscale_palette(WICColor *colors, UINT num_colors)
86 {
87     int i, v;
88     for (i=0; i<num_colors; i++)
89     {
90         v = i * 255 / (num_colors-1);
91         colors[i] = 0xff000000 | v<<16 | v<<8 | v;
92     }
93 }
94
95 static HRESULT copypixels_to_32bppBGRA(struct FormatConverter *This, const WICRect *prc,
96     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
97 {
98     switch (source_format)
99     {
100     case format_1bppIndexed:
101     case format_BlackWhite:
102         if (prc)
103         {
104             HRESULT res;
105             UINT x, y;
106             BYTE *srcdata;
107             UINT srcstride, srcdatasize;
108             const BYTE *srcrow;
109             const BYTE *srcbyte;
110             BYTE *dstrow;
111             DWORD *dstpixel;
112             WICColor colors[2];
113             IWICPalette *palette;
114             UINT actualcolors;
115
116             if (source_format == format_1bppIndexed)
117             {
118                 res = PaletteImpl_Create(&palette);
119                 if (FAILED(res)) return res;
120
121                 res = IWICBitmapSource_CopyPalette(This->source, palette);
122                 if (SUCCEEDED(res))
123                     res = IWICPalette_GetColors(palette, 2, colors, &actualcolors);
124
125                 IWICPalette_Release(palette);
126
127                 if (FAILED(res)) return res;
128             }
129             else
130             {
131                 colors[0] = 0xff000000;
132                 colors[1] = 0xffffffff;
133             }
134
135             srcstride = (prc->Width+7)/8;
136             srcdatasize = srcstride * prc->Height;
137
138             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
139             if (!srcdata) return E_OUTOFMEMORY;
140
141             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
142
143             if (SUCCEEDED(res))
144             {
145                 srcrow = srcdata;
146                 dstrow = pbBuffer;
147                 for (y=0; y<prc->Height; y++) {
148                     srcbyte = srcrow;
149                     dstpixel=(DWORD*)dstrow;
150                     for (x=0; x<prc->Width; x+=8) {
151                         BYTE srcval;
152                         srcval=*srcbyte++;
153                         *dstpixel++ = colors[srcval>>7&1];
154                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>6&1];
155                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>5&1];
156                         if (x+3 < prc->Width) *dstpixel++ = colors[srcval>>4&1];
157                         if (x+4 < prc->Width) *dstpixel++ = colors[srcval>>3&1];
158                         if (x+5 < prc->Width) *dstpixel++ = colors[srcval>>2&1];
159                         if (x+6 < prc->Width) *dstpixel++ = colors[srcval>>1&1];
160                         if (x+7 < prc->Width) *dstpixel++ = colors[srcval&1];
161                     }
162                     srcrow += srcstride;
163                     dstrow += cbStride;
164                 }
165             }
166
167             HeapFree(GetProcessHeap(), 0, srcdata);
168
169             return res;
170         }
171         return S_OK;
172     case format_2bppIndexed:
173     case format_2bppGray:
174         if (prc)
175         {
176             HRESULT res;
177             UINT x, y;
178             BYTE *srcdata;
179             UINT srcstride, srcdatasize;
180             const BYTE *srcrow;
181             const BYTE *srcbyte;
182             BYTE *dstrow;
183             DWORD *dstpixel;
184             WICColor colors[4];
185             IWICPalette *palette;
186             UINT actualcolors;
187
188             if (source_format == format_2bppIndexed)
189             {
190                 res = PaletteImpl_Create(&palette);
191                 if (FAILED(res)) return res;
192
193                 res = IWICBitmapSource_CopyPalette(This->source, palette);
194                 if (SUCCEEDED(res))
195                     res = IWICPalette_GetColors(palette, 4, colors, &actualcolors);
196
197                 IWICPalette_Release(palette);
198
199                 if (FAILED(res)) return res;
200             }
201             else
202                 make_grayscale_palette(colors, 4);
203
204             srcstride = (prc->Width+3)/4;
205             srcdatasize = srcstride * prc->Height;
206
207             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
208             if (!srcdata) return E_OUTOFMEMORY;
209
210             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
211
212             if (SUCCEEDED(res))
213             {
214                 srcrow = srcdata;
215                 dstrow = pbBuffer;
216                 for (y=0; y<prc->Height; y++) {
217                     srcbyte = srcrow;
218                     dstpixel=(DWORD*)dstrow;
219                     for (x=0; x<prc->Width; x+=4) {
220                         BYTE srcval;
221                         srcval=*srcbyte++;
222                         *dstpixel++ = colors[srcval>>6];
223                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>4&0x3];
224                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>2&0x3];
225                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval&0x3];
226                     }
227                     srcrow += srcstride;
228                     dstrow += cbStride;
229                 }
230             }
231
232             HeapFree(GetProcessHeap(), 0, srcdata);
233
234             return res;
235         }
236         return S_OK;
237     case format_4bppIndexed:
238     case format_4bppGray:
239         if (prc)
240         {
241             HRESULT res;
242             UINT x, y;
243             BYTE *srcdata;
244             UINT srcstride, srcdatasize;
245             const BYTE *srcrow;
246             const BYTE *srcbyte;
247             BYTE *dstrow;
248             DWORD *dstpixel;
249             WICColor colors[16];
250             IWICPalette *palette;
251             UINT actualcolors;
252
253             if (source_format == format_4bppIndexed)
254             {
255                 res = PaletteImpl_Create(&palette);
256                 if (FAILED(res)) return res;
257
258                 res = IWICBitmapSource_CopyPalette(This->source, palette);
259                 if (SUCCEEDED(res))
260                     res = IWICPalette_GetColors(palette, 16, colors, &actualcolors);
261
262                 IWICPalette_Release(palette);
263
264                 if (FAILED(res)) return res;
265             }
266             else
267                 make_grayscale_palette(colors, 16);
268
269             srcstride = (prc->Width+1)/2;
270             srcdatasize = srcstride * prc->Height;
271
272             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
273             if (!srcdata) return E_OUTOFMEMORY;
274
275             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
276
277             if (SUCCEEDED(res))
278             {
279                 srcrow = srcdata;
280                 dstrow = pbBuffer;
281                 for (y=0; y<prc->Height; y++) {
282                     srcbyte = srcrow;
283                     dstpixel=(DWORD*)dstrow;
284                     for (x=0; x<prc->Width; x+=2) {
285                         BYTE srcval;
286                         srcval=*srcbyte++;
287                         *dstpixel++ = colors[srcval>>4];
288                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval&0xf];
289                     }
290                     srcrow += srcstride;
291                     dstrow += cbStride;
292                 }
293             }
294
295             HeapFree(GetProcessHeap(), 0, srcdata);
296
297             return res;
298         }
299         return S_OK;
300     case format_8bppGray:
301         if (prc)
302         {
303             HRESULT res;
304             UINT x, y;
305             BYTE *srcdata;
306             UINT srcstride, srcdatasize;
307             const BYTE *srcrow;
308             const BYTE *srcbyte;
309             BYTE *dstrow;
310             DWORD *dstpixel;
311
312             srcstride = prc->Width;
313             srcdatasize = srcstride * prc->Height;
314
315             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
316             if (!srcdata) return E_OUTOFMEMORY;
317
318             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
319
320             if (SUCCEEDED(res))
321             {
322                 srcrow = srcdata;
323                 dstrow = pbBuffer;
324                 for (y=0; y<prc->Height; y++) {
325                     srcbyte = srcrow;
326                     dstpixel=(DWORD*)dstrow;
327                     for (x=0; x<prc->Width; x++)
328                     {
329                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
330                         srcbyte++;
331                     }
332                     srcrow += srcstride;
333                     dstrow += cbStride;
334                 }
335             }
336
337             HeapFree(GetProcessHeap(), 0, srcdata);
338
339             return res;
340         }
341         return S_OK;
342     case format_8bppIndexed:
343         if (prc)
344         {
345             HRESULT res;
346             UINT x, y;
347             BYTE *srcdata;
348             UINT srcstride, srcdatasize;
349             const BYTE *srcrow;
350             const BYTE *srcbyte;
351             BYTE *dstrow;
352             DWORD *dstpixel;
353             WICColor colors[256];
354             IWICPalette *palette;
355             UINT actualcolors;
356
357             res = PaletteImpl_Create(&palette);
358             if (FAILED(res)) return res;
359
360             res = IWICBitmapSource_CopyPalette(This->source, palette);
361             if (SUCCEEDED(res))
362                 res = IWICPalette_GetColors(palette, 256, colors, &actualcolors);
363
364             IWICPalette_Release(palette);
365
366             if (FAILED(res)) return res;
367
368             srcstride = prc->Width;
369             srcdatasize = srcstride * prc->Height;
370
371             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
372             if (!srcdata) return E_OUTOFMEMORY;
373
374             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
375
376             if (SUCCEEDED(res))
377             {
378                 srcrow = srcdata;
379                 dstrow = pbBuffer;
380                 for (y=0; y<prc->Height; y++) {
381                     srcbyte = srcrow;
382                     dstpixel=(DWORD*)dstrow;
383                     for (x=0; x<prc->Width; x++)
384                         *dstpixel++ = colors[*srcbyte++];
385                     srcrow += srcstride;
386                     dstrow += cbStride;
387                 }
388             }
389
390             HeapFree(GetProcessHeap(), 0, srcdata);
391
392             return res;
393         }
394         return S_OK;
395     case format_16bppGray:
396         if (prc)
397         {
398             HRESULT res;
399             UINT x, y;
400             BYTE *srcdata;
401             UINT srcstride, srcdatasize;
402             const BYTE *srcrow;
403             const BYTE *srcbyte;
404             BYTE *dstrow;
405             DWORD *dstpixel;
406
407             srcstride = prc->Width * 2;
408             srcdatasize = srcstride * prc->Height;
409
410             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
411             if (!srcdata) return E_OUTOFMEMORY;
412
413             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
414
415             if (SUCCEEDED(res))
416             {
417                 srcrow = srcdata;
418                 dstrow = pbBuffer;
419                 for (y=0; y<prc->Height; y++) {
420                     srcbyte = srcrow;
421                     dstpixel=(DWORD*)dstrow;
422                     for (x=0; x<prc->Width; x++)
423                     {
424                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
425                         srcbyte+=2;
426                     }
427                     srcrow += srcstride;
428                     dstrow += cbStride;
429                 }
430             }
431
432             HeapFree(GetProcessHeap(), 0, srcdata);
433
434             return res;
435         }
436         return S_OK;
437     case format_16bppBGR555:
438         if (prc)
439         {
440             HRESULT res;
441             UINT x, y;
442             BYTE *srcdata;
443             UINT srcstride, srcdatasize;
444             const BYTE *srcrow;
445             const WORD *srcpixel;
446             BYTE *dstrow;
447             DWORD *dstpixel;
448
449             srcstride = 2 * prc->Width;
450             srcdatasize = srcstride * prc->Height;
451
452             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
453             if (!srcdata) return E_OUTOFMEMORY;
454
455             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
456
457             if (SUCCEEDED(res))
458             {
459                 srcrow = srcdata;
460                 dstrow = pbBuffer;
461                 for (y=0; y<prc->Height; y++) {
462                     srcpixel=(const WORD*)srcrow;
463                     dstpixel=(DWORD*)dstrow;
464                     for (x=0; x<prc->Width; x++) {
465                         WORD srcval;
466                         srcval=*srcpixel++;
467                         *dstpixel++=0xff000000 | /* constant 255 alpha */
468                                     ((srcval << 9) & 0xf80000) | /* r */
469                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
470                                     ((srcval << 6) & 0x00f800) | /* g */
471                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
472                                     ((srcval << 3) & 0x0000f8) | /* b */
473                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
474                     }
475                     srcrow += srcstride;
476                     dstrow += cbStride;
477                 }
478             }
479
480             HeapFree(GetProcessHeap(), 0, srcdata);
481
482             return res;
483         }
484         return S_OK;
485     case format_16bppBGR565:
486         if (prc)
487         {
488             HRESULT res;
489             UINT x, y;
490             BYTE *srcdata;
491             UINT srcstride, srcdatasize;
492             const BYTE *srcrow;
493             const WORD *srcpixel;
494             BYTE *dstrow;
495             DWORD *dstpixel;
496
497             srcstride = 2 * prc->Width;
498             srcdatasize = srcstride * prc->Height;
499
500             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
501             if (!srcdata) return E_OUTOFMEMORY;
502
503             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
504
505             if (SUCCEEDED(res))
506             {
507                 srcrow = srcdata;
508                 dstrow = pbBuffer;
509                 for (y=0; y<prc->Height; y++) {
510                     srcpixel=(const WORD*)srcrow;
511                     dstpixel=(DWORD*)dstrow;
512                     for (x=0; x<prc->Width; x++) {
513                         WORD srcval;
514                         srcval=*srcpixel++;
515                         *dstpixel++=0xff000000 | /* constant 255 alpha */
516                                     ((srcval << 8) & 0xf80000) | /* r */
517                                     ((srcval << 3) & 0x070000) | /* r - 3 bits */
518                                     ((srcval << 5) & 0x00fc00) | /* g */
519                                     ((srcval >> 1) & 0x000300) | /* g - 2 bits */
520                                     ((srcval << 3) & 0x0000f8) | /* b */
521                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
522                     }
523                     srcrow += srcstride;
524                     dstrow += cbStride;
525                 }
526             }
527
528             HeapFree(GetProcessHeap(), 0, srcdata);
529
530             return res;
531         }
532         return S_OK;
533     case format_16bppBGRA5551:
534         if (prc)
535         {
536             HRESULT res;
537             UINT x, y;
538             BYTE *srcdata;
539             UINT srcstride, srcdatasize;
540             const BYTE *srcrow;
541             const WORD *srcpixel;
542             BYTE *dstrow;
543             DWORD *dstpixel;
544
545             srcstride = 2 * prc->Width;
546             srcdatasize = srcstride * prc->Height;
547
548             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
549             if (!srcdata) return E_OUTOFMEMORY;
550
551             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
552
553             if (SUCCEEDED(res))
554             {
555                 srcrow = srcdata;
556                 dstrow = pbBuffer;
557                 for (y=0; y<prc->Height; y++) {
558                     srcpixel=(const WORD*)srcrow;
559                     dstpixel=(DWORD*)dstrow;
560                     for (x=0; x<prc->Width; x++) {
561                         WORD srcval;
562                         srcval=*srcpixel++;
563                         *dstpixel++=((srcval & 0x8000) ? 0xff000000 : 0) | /* alpha */
564                                     ((srcval << 9) & 0xf80000) | /* r */
565                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
566                                     ((srcval << 6) & 0x00f800) | /* g */
567                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
568                                     ((srcval << 3) & 0x0000f8) | /* b */
569                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
570                     }
571                     srcrow += srcstride;
572                     dstrow += cbStride;
573                 }
574             }
575
576             HeapFree(GetProcessHeap(), 0, srcdata);
577
578             return res;
579         }
580         return S_OK;
581     case format_24bppBGR:
582         if (prc)
583         {
584             HRESULT res;
585             UINT x, y;
586             BYTE *srcdata;
587             UINT srcstride, srcdatasize;
588             const BYTE *srcrow;
589             const BYTE *srcpixel;
590             BYTE *dstrow;
591             BYTE *dstpixel;
592
593             srcstride = 3 * prc->Width;
594             srcdatasize = srcstride * prc->Height;
595
596             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
597             if (!srcdata) return E_OUTOFMEMORY;
598
599             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
600
601             if (SUCCEEDED(res))
602             {
603                 srcrow = srcdata;
604                 dstrow = pbBuffer;
605                 for (y=0; y<prc->Height; y++) {
606                     srcpixel=srcrow;
607                     dstpixel=dstrow;
608                     for (x=0; x<prc->Width; x++) {
609                         *dstpixel++=*srcpixel++; /* blue */
610                         *dstpixel++=*srcpixel++; /* green */
611                         *dstpixel++=*srcpixel++; /* red */
612                         *dstpixel++=255; /* alpha */
613                     }
614                     srcrow += srcstride;
615                     dstrow += cbStride;
616                 }
617             }
618
619             HeapFree(GetProcessHeap(), 0, srcdata);
620
621             return res;
622         }
623         return S_OK;
624     case format_32bppBGR:
625         if (prc)
626         {
627             HRESULT res;
628             UINT x, y;
629
630             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
631             if (FAILED(res)) return res;
632
633             /* set all alpha values to 255 */
634             for (y=0; y<prc->Height; y++)
635                 for (x=0; x<prc->Width; x++)
636                     pbBuffer[cbStride*y+4*x+3] = 0xff;
637         }
638         return S_OK;
639     case format_32bppBGRA:
640         if (prc)
641             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
642         return S_OK;
643     case format_32bppPBGRA:
644         if (prc)
645         {
646             HRESULT res;
647             UINT x, y;
648
649             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
650             if (FAILED(res)) return res;
651
652             for (y=0; y<prc->Height; y++)
653                 for (x=0; x<prc->Width; x++)
654                 {
655                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
656                     if (alpha != 0 && alpha != 255)
657                     {
658                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * 255 / alpha;
659                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * 255 / alpha;
660                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * 255 / alpha;
661                     }
662                 }
663         }
664         return S_OK;
665     case format_48bppRGB:
666         if (prc)
667         {
668             HRESULT res;
669             UINT x, y;
670             BYTE *srcdata;
671             UINT srcstride, srcdatasize;
672             const BYTE *srcrow;
673             const BYTE *srcpixel;
674             BYTE *dstrow;
675             DWORD *dstpixel;
676
677             srcstride = 6 * prc->Width;
678             srcdatasize = srcstride * prc->Height;
679
680             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
681             if (!srcdata) return E_OUTOFMEMORY;
682
683             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
684
685             if (SUCCEEDED(res))
686             {
687                 srcrow = srcdata;
688                 dstrow = pbBuffer;
689                 for (y=0; y<prc->Height; y++) {
690                     srcpixel=srcrow;
691                     dstpixel=(DWORD*)dstrow;
692                     for (x=0; x<prc->Width; x++) {
693                         BYTE red, green, blue;
694                         red = *srcpixel++; srcpixel++;
695                         green = *srcpixel++; srcpixel++;
696                         blue = *srcpixel++; srcpixel++;
697                         *dstpixel++=0xff000000|red<<16|green<<8|blue;
698                     }
699                     srcrow += srcstride;
700                     dstrow += cbStride;
701                 }
702             }
703
704             HeapFree(GetProcessHeap(), 0, srcdata);
705
706             return res;
707         }
708         return S_OK;
709     case format_64bppRGBA:
710         if (prc)
711         {
712             HRESULT res;
713             UINT x, y;
714             BYTE *srcdata;
715             UINT srcstride, srcdatasize;
716             const BYTE *srcrow;
717             const BYTE *srcpixel;
718             BYTE *dstrow;
719             DWORD *dstpixel;
720
721             srcstride = 8 * prc->Width;
722             srcdatasize = srcstride * prc->Height;
723
724             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
725             if (!srcdata) return E_OUTOFMEMORY;
726
727             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
728
729             if (SUCCEEDED(res))
730             {
731                 srcrow = srcdata;
732                 dstrow = pbBuffer;
733                 for (y=0; y<prc->Height; y++) {
734                     srcpixel=srcrow;
735                     dstpixel=(DWORD*)dstrow;
736                     for (x=0; x<prc->Width; x++) {
737                         BYTE red, green, blue, alpha;
738                         red = *srcpixel++; srcpixel++;
739                         green = *srcpixel++; srcpixel++;
740                         blue = *srcpixel++; srcpixel++;
741                         alpha = *srcpixel++; srcpixel++;
742                         *dstpixel++=alpha<<24|red<<16|green<<8|blue;
743                     }
744                     srcrow += srcstride;
745                     dstrow += cbStride;
746                 }
747             }
748
749             HeapFree(GetProcessHeap(), 0, srcdata);
750
751             return res;
752         }
753         return S_OK;
754     case format_32bppCMYK:
755         if (prc)
756         {
757             HRESULT res;
758             UINT x, y;
759
760             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
761             if (FAILED(res)) return res;
762
763             for (y=0; y<prc->Height; y++)
764                 for (x=0; x<prc->Width; x++)
765                 {
766                     BYTE *pixel = pbBuffer+cbStride*y+4*x;
767                     BYTE c=pixel[0], m=pixel[1], y=pixel[2], k=pixel[3];
768                     pixel[0] = (255-y)*(255-k)/255; /* blue */
769                     pixel[1] = (255-m)*(255-k)/255; /* green */
770                     pixel[2] = (255-c)*(255-k)/255; /* red */
771                     pixel[3] = 255; /* alpha */
772                 }
773         }
774         return S_OK;
775     default:
776         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
777     }
778 }
779
780 static HRESULT copypixels_to_32bppBGR(struct FormatConverter *This, const WICRect *prc,
781     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
782 {
783     switch (source_format)
784     {
785     case format_32bppBGR:
786     case format_32bppBGRA:
787     case format_32bppPBGRA:
788         if (prc)
789             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
790         return S_OK;
791     default:
792         return copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
793     }
794 }
795
796 static HRESULT copypixels_to_32bppPBGRA(struct FormatConverter *This, const WICRect *prc,
797     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
798 {
799     HRESULT hr;
800
801     switch (source_format)
802     {
803     case format_32bppPBGRA:
804         if (prc)
805             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
806         return S_OK;
807     default:
808         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
809         if (SUCCEEDED(hr) && prc)
810         {
811             UINT x, y;
812
813             for (y=0; y<prc->Height; y++)
814                 for (x=0; x<prc->Width; x++)
815                 {
816                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
817                     if (alpha != 255)
818                     {
819                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
820                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
821                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
822                     }
823                 }
824         }
825         return hr;
826     }
827 }
828
829 static const struct pixelformatinfo supported_formats[] = {
830     {format_1bppIndexed, &GUID_WICPixelFormat1bppIndexed, NULL},
831     {format_2bppIndexed, &GUID_WICPixelFormat2bppIndexed, NULL},
832     {format_4bppIndexed, &GUID_WICPixelFormat4bppIndexed, NULL},
833     {format_8bppIndexed, &GUID_WICPixelFormat8bppIndexed, NULL},
834     {format_BlackWhite, &GUID_WICPixelFormatBlackWhite, NULL},
835     {format_2bppGray, &GUID_WICPixelFormat2bppGray, NULL},
836     {format_4bppGray, &GUID_WICPixelFormat4bppGray, NULL},
837     {format_8bppGray, &GUID_WICPixelFormat8bppGray, NULL},
838     {format_16bppGray, &GUID_WICPixelFormat16bppGray, NULL},
839     {format_16bppBGR555, &GUID_WICPixelFormat16bppBGR555, NULL},
840     {format_16bppBGR565, &GUID_WICPixelFormat16bppBGR565, NULL},
841     {format_16bppBGRA5551, &GUID_WICPixelFormat16bppBGRA5551, NULL},
842     {format_24bppBGR, &GUID_WICPixelFormat24bppBGR, NULL},
843     {format_32bppBGR, &GUID_WICPixelFormat32bppBGR, copypixels_to_32bppBGR},
844     {format_32bppBGRA, &GUID_WICPixelFormat32bppBGRA, copypixels_to_32bppBGRA},
845     {format_32bppPBGRA, &GUID_WICPixelFormat32bppPBGRA, copypixels_to_32bppPBGRA},
846     {format_48bppRGB, &GUID_WICPixelFormat48bppRGB, NULL},
847     {format_64bppRGBA, &GUID_WICPixelFormat64bppRGBA, NULL},
848     {format_32bppCMYK, &GUID_WICPixelFormat32bppCMYK, NULL},
849     {0}
850 };
851
852 static const struct pixelformatinfo *get_formatinfo(const WICPixelFormatGUID *format)
853 {
854     UINT i;
855
856     for (i=0; supported_formats[i].guid; i++)
857         if (IsEqualGUID(supported_formats[i].guid, format)) return &supported_formats[i];
858
859     return NULL;
860 }
861
862 static HRESULT WINAPI FormatConverter_QueryInterface(IWICFormatConverter *iface, REFIID iid,
863     void **ppv)
864 {
865     FormatConverter *This = impl_from_IWICFormatConverter(iface);
866     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
867
868     if (!ppv) return E_INVALIDARG;
869
870     if (IsEqualIID(&IID_IUnknown, iid) ||
871         IsEqualIID(&IID_IWICBitmapSource, iid) ||
872         IsEqualIID(&IID_IWICFormatConverter, iid))
873     {
874         *ppv = This;
875     }
876     else
877     {
878         *ppv = NULL;
879         return E_NOINTERFACE;
880     }
881
882     IUnknown_AddRef((IUnknown*)*ppv);
883     return S_OK;
884 }
885
886 static ULONG WINAPI FormatConverter_AddRef(IWICFormatConverter *iface)
887 {
888     FormatConverter *This = impl_from_IWICFormatConverter(iface);
889     ULONG ref = InterlockedIncrement(&This->ref);
890
891     TRACE("(%p) refcount=%u\n", iface, ref);
892
893     return ref;
894 }
895
896 static ULONG WINAPI FormatConverter_Release(IWICFormatConverter *iface)
897 {
898     FormatConverter *This = impl_from_IWICFormatConverter(iface);
899     ULONG ref = InterlockedDecrement(&This->ref);
900
901     TRACE("(%p) refcount=%u\n", iface, ref);
902
903     if (ref == 0)
904     {
905         This->lock.DebugInfo->Spare[0] = 0;
906         DeleteCriticalSection(&This->lock);
907         if (This->source) IWICBitmapSource_Release(This->source);
908         HeapFree(GetProcessHeap(), 0, This);
909     }
910
911     return ref;
912 }
913
914 static HRESULT WINAPI FormatConverter_GetSize(IWICFormatConverter *iface,
915     UINT *puiWidth, UINT *puiHeight)
916 {
917     FormatConverter *This = impl_from_IWICFormatConverter(iface);
918
919     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
920
921     if (This->source)
922         return IWICBitmapSource_GetSize(This->source, puiWidth, puiHeight);
923     else
924         return WINCODEC_ERR_NOTINITIALIZED;
925 }
926
927 static HRESULT WINAPI FormatConverter_GetPixelFormat(IWICFormatConverter *iface,
928     WICPixelFormatGUID *pPixelFormat)
929 {
930     FormatConverter *This = impl_from_IWICFormatConverter(iface);
931
932     TRACE("(%p,%p): stub\n", iface, pPixelFormat);
933
934     if (This->source)
935         memcpy(pPixelFormat, This->dst_format->guid, sizeof(GUID));
936     else
937         return WINCODEC_ERR_NOTINITIALIZED;
938
939     return S_OK;
940 }
941
942 static HRESULT WINAPI FormatConverter_GetResolution(IWICFormatConverter *iface,
943     double *pDpiX, double *pDpiY)
944 {
945     FormatConverter *This = impl_from_IWICFormatConverter(iface);
946
947     TRACE("(%p,%p,%p): stub\n", iface, pDpiX, pDpiY);
948
949     if (This->source)
950         return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
951     else
952         return WINCODEC_ERR_NOTINITIALIZED;
953 }
954
955 static HRESULT WINAPI FormatConverter_CopyPalette(IWICFormatConverter *iface,
956     IWICPalette *pIPalette)
957 {
958     FIXME("(%p,%p): stub\n", iface, pIPalette);
959     return E_NOTIMPL;
960 }
961
962 static HRESULT WINAPI FormatConverter_CopyPixels(IWICFormatConverter *iface,
963     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
964 {
965     FormatConverter *This = impl_from_IWICFormatConverter(iface);
966     WICRect rc;
967     HRESULT hr;
968     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
969
970     if (This->source)
971     {
972         if (!prc)
973         {
974             UINT width, height;
975             hr = IWICBitmapSource_GetSize(This->source, &width, &height);
976             if (FAILED(hr)) return hr;
977             rc.X = 0;
978             rc.Y = 0;
979             rc.Width = width;
980             rc.Height = height;
981             prc = &rc;
982         }
983
984         return This->dst_format->copy_function(This, prc, cbStride, cbBufferSize,
985             pbBuffer, This->src_format->format);
986     }
987     else
988         return WINCODEC_ERR_NOTINITIALIZED;
989 }
990
991 static HRESULT WINAPI FormatConverter_Initialize(IWICFormatConverter *iface,
992     IWICBitmapSource *pISource, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither,
993     IWICPalette *pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate)
994 {
995     FormatConverter *This = impl_from_IWICFormatConverter(iface);
996     const struct pixelformatinfo *srcinfo, *dstinfo;
997     static INT fixme=0;
998     GUID srcFormat;
999     HRESULT res=S_OK;
1000
1001     TRACE("(%p,%p,%s,%u,%p,%0.1f,%u)\n", iface, pISource, debugstr_guid(dstFormat),
1002         dither, pIPalette, alphaThresholdPercent, paletteTranslate);
1003
1004     if (pIPalette && !fixme++) FIXME("ignoring palette\n");
1005
1006     EnterCriticalSection(&This->lock);
1007
1008     if (This->source)
1009     {
1010         res = WINCODEC_ERR_WRONGSTATE;
1011         goto end;
1012     }
1013
1014     res = IWICBitmapSource_GetPixelFormat(pISource, &srcFormat);
1015     if (FAILED(res)) goto end;
1016
1017     srcinfo = get_formatinfo(&srcFormat);
1018     if (!srcinfo)
1019     {
1020         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1021         FIXME("Unsupported source format %s\n", debugstr_guid(&srcFormat));
1022         goto end;
1023     }
1024
1025     dstinfo = get_formatinfo(dstFormat);
1026     if (!dstinfo)
1027     {
1028         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1029         FIXME("Unsupported destination format %s\n", debugstr_guid(dstFormat));
1030         goto end;
1031     }
1032
1033     if (dstinfo->copy_function)
1034     {
1035         IWICBitmapSource_AddRef(pISource);
1036         This->src_format = srcinfo;
1037         This->dst_format = dstinfo;
1038         This->dither = dither;
1039         This->alpha_threshold = alphaThresholdPercent;
1040         This->palette_type = paletteTranslate;
1041         This->source = pISource;
1042     }
1043     else
1044     {
1045         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
1046         res = WINCODEC_ERR_UNSUPPORTEDOPERATION;
1047     }
1048
1049 end:
1050
1051     LeaveCriticalSection(&This->lock);
1052
1053     return res;
1054 }
1055
1056 static HRESULT WINAPI FormatConverter_CanConvert(IWICFormatConverter *iface,
1057     REFWICPixelFormatGUID srcPixelFormat, REFWICPixelFormatGUID dstPixelFormat,
1058     BOOL *pfCanConvert)
1059 {
1060     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1061     const struct pixelformatinfo *srcinfo, *dstinfo;
1062
1063     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(srcPixelFormat),
1064         debugstr_guid(dstPixelFormat), pfCanConvert);
1065
1066     srcinfo = get_formatinfo(srcPixelFormat);
1067     if (!srcinfo)
1068     {
1069         FIXME("Unsupported source format %s\n", debugstr_guid(srcPixelFormat));
1070         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1071     }
1072
1073     dstinfo = get_formatinfo(dstPixelFormat);
1074     if (!dstinfo)
1075     {
1076         FIXME("Unsupported destination format %s\n", debugstr_guid(dstPixelFormat));
1077         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1078     }
1079
1080     if (dstinfo->copy_function &&
1081         SUCCEEDED(dstinfo->copy_function(This, NULL, 0, 0, NULL, dstinfo->format)))
1082         *pfCanConvert = TRUE;
1083     else
1084     {
1085         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(srcPixelFormat), debugstr_guid(dstPixelFormat));
1086         *pfCanConvert = FALSE;
1087     }
1088
1089     return S_OK;
1090 }
1091
1092 static const IWICFormatConverterVtbl FormatConverter_Vtbl = {
1093     FormatConverter_QueryInterface,
1094     FormatConverter_AddRef,
1095     FormatConverter_Release,
1096     FormatConverter_GetSize,
1097     FormatConverter_GetPixelFormat,
1098     FormatConverter_GetResolution,
1099     FormatConverter_CopyPalette,
1100     FormatConverter_CopyPixels,
1101     FormatConverter_Initialize,
1102     FormatConverter_CanConvert
1103 };
1104
1105 HRESULT FormatConverter_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1106 {
1107     FormatConverter *This;
1108     HRESULT ret;
1109
1110     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1111
1112     *ppv = NULL;
1113
1114     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1115
1116     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverter));
1117     if (!This) return E_OUTOFMEMORY;
1118
1119     This->IWICFormatConverter_iface.lpVtbl = &FormatConverter_Vtbl;
1120     This->ref = 1;
1121     This->source = NULL;
1122     InitializeCriticalSection(&This->lock);
1123     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FormatConverter.lock");
1124
1125     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1126     IUnknown_Release((IUnknown*)This);
1127
1128     return ret;
1129 }