windowscodecs: Implement Graphic Control Extension metadata reader.
[wine] / dlls / windowscodecs / bmpdecode.c
1 /*
2  * Copyright 2009 Vincent Povirk for CodeWeavers
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 <assert.h>
22 #include <stdarg.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "wingdi.h"
30 #include "objbase.h"
31 #include "wincodec.h"
32
33 #include "wincodecs_private.h"
34
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
38
39 typedef struct {
40     DWORD bc2Size;
41     DWORD bc2Width;
42     DWORD bc2Height;
43     WORD  bc2Planes;
44     WORD  bc2BitCount;
45     DWORD bc2Compression;
46     DWORD bc2SizeImage;
47     DWORD bc2XRes;
48     DWORD bc2YRes;
49     DWORD bc2ClrUsed;
50     DWORD bc2ClrImportant;
51     /* same as BITMAPINFOHEADER until this point */
52     WORD  bc2ResUnit;
53     WORD  bc2Reserved;
54     WORD  bc2Orientation;
55     WORD  bc2Halftoning;
56     DWORD bc2HalftoneSize1;
57     DWORD bc2HalftoneSize2;
58     DWORD bc2ColorSpace;
59     DWORD bc2AppData;
60 } BITMAPCOREHEADER2;
61
62 typedef HRESULT (*ReadDataFunc)(BmpDecoder* This);
63
64 struct BmpDecoder {
65     IWICBitmapDecoder IWICBitmapDecoder_iface;
66     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
67     LONG ref;
68     BOOL initialized;
69     IStream *stream;
70     ULONG palette_offset;
71     ULONG image_offset;
72     BITMAPV5HEADER bih;
73     const WICPixelFormatGUID *pixelformat;
74     int bitsperpixel;
75     ReadDataFunc read_data_func;
76     INT stride;
77     BYTE *imagedata;
78     BYTE *imagedatastart;
79     CRITICAL_SECTION lock; /* must be held when initialized/imagedata is set or stream is accessed */
80     int packed; /* If TRUE, don't look for a file header and assume a packed DIB. */
81     int icoframe; /* If TRUE, this is a frame of a .ico file. */
82 };
83
84 static inline BmpDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
85 {
86     return CONTAINING_RECORD(iface, BmpDecoder, IWICBitmapDecoder_iface);
87 }
88
89 static inline BmpDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
90 {
91     return CONTAINING_RECORD(iface, BmpDecoder, IWICBitmapFrameDecode_iface);
92 }
93
94 static HRESULT WINAPI BmpFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
95     void **ppv)
96 {
97     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
98
99     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
100
101     if (!ppv) return E_INVALIDARG;
102
103     if (IsEqualIID(&IID_IUnknown, iid) ||
104         IsEqualIID(&IID_IWICBitmapSource, iid) ||
105         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
106     {
107         *ppv = &This->IWICBitmapFrameDecode_iface;
108     }
109     else
110     {
111         *ppv = NULL;
112         return E_NOINTERFACE;
113     }
114
115     IUnknown_AddRef((IUnknown*)*ppv);
116     return S_OK;
117 }
118
119 static ULONG WINAPI BmpFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
120 {
121     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
122
123     return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
124 }
125
126 static ULONG WINAPI BmpFrameDecode_Release(IWICBitmapFrameDecode *iface)
127 {
128     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
129
130     return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
131 }
132
133 static HRESULT WINAPI BmpFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
134     UINT *puiWidth, UINT *puiHeight)
135 {
136     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
137     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
138
139     if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
140     {
141         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
142         *puiWidth = bch->bcWidth;
143         *puiHeight = bch->bcHeight;
144     }
145     else
146     {
147         *puiWidth = This->bih.bV5Width;
148         *puiHeight = abs(This->bih.bV5Height);
149     }
150     return S_OK;
151 }
152
153 static HRESULT WINAPI BmpFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
154     WICPixelFormatGUID *pPixelFormat)
155 {
156     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
157     TRACE("(%p,%p)\n", iface, pPixelFormat);
158
159     memcpy(pPixelFormat, This->pixelformat, sizeof(GUID));
160
161     return S_OK;
162 }
163
164 static HRESULT BmpHeader_GetResolution(BITMAPV5HEADER *bih, double *pDpiX, double *pDpiY)
165 {
166     switch (bih->bV5Size)
167     {
168     case sizeof(BITMAPCOREHEADER):
169         *pDpiX = 96.0;
170         *pDpiY = 96.0;
171         return S_OK;
172     case sizeof(BITMAPCOREHEADER2):
173     case sizeof(BITMAPINFOHEADER):
174     case sizeof(BITMAPV4HEADER):
175     case sizeof(BITMAPV5HEADER):
176         *pDpiX = bih->bV5XPelsPerMeter * 0.0254;
177         *pDpiY = bih->bV5YPelsPerMeter * 0.0254;
178         return S_OK;
179     default:
180         return E_FAIL;
181     }
182 }
183
184 static HRESULT WINAPI BmpFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
185     double *pDpiX, double *pDpiY)
186 {
187     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
188     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
189
190     return BmpHeader_GetResolution(&This->bih, pDpiX, pDpiY);
191 }
192
193 static HRESULT WINAPI BmpFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
194     IWICPalette *pIPalette)
195 {
196     HRESULT hr;
197     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
198     int count;
199     WICColor *wiccolors=NULL;
200     RGBTRIPLE *bgrcolors=NULL;
201
202     TRACE("(%p,%p)\n", iface, pIPalette);
203
204     EnterCriticalSection(&This->lock);
205
206     if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
207     {
208         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
209         if (bch->bcBitCount <= 8)
210         {
211             /* 2**n colors in BGR format after the header */
212             ULONG tablesize, bytesread;
213             LARGE_INTEGER offset;
214             int i;
215
216             count = 1 << bch->bcBitCount;
217             wiccolors = HeapAlloc(GetProcessHeap(), 0, sizeof(WICColor) * count);
218             tablesize = sizeof(RGBTRIPLE) * count;
219             bgrcolors = HeapAlloc(GetProcessHeap(), 0, tablesize);
220             if (!wiccolors || !bgrcolors)
221             {
222                 hr = E_OUTOFMEMORY;
223                 goto end;
224             }
225
226             offset.QuadPart = This->palette_offset;
227             hr = IStream_Seek(This->stream, offset, STREAM_SEEK_SET, NULL);
228             if (FAILED(hr)) goto end;
229
230             hr = IStream_Read(This->stream, bgrcolors, tablesize, &bytesread);
231             if (FAILED(hr)) goto end;
232             if (bytesread != tablesize) {
233                 hr = E_FAIL;
234                 goto end;
235             }
236
237             for (i=0; i<count; i++)
238             {
239                 wiccolors[i] = 0xff000000|
240                                (bgrcolors[i].rgbtRed<<16)|
241                                (bgrcolors[i].rgbtGreen<<8)|
242                                bgrcolors[i].rgbtBlue;
243             }
244         }
245         else
246         {
247             hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
248             goto end;
249         }
250     }
251     else
252     {
253         if (This->bih.bV5BitCount <= 8)
254         {
255             ULONG tablesize, bytesread;
256             LARGE_INTEGER offset;
257             int i;
258
259             if (This->bih.bV5ClrUsed == 0)
260                 count = 1 << This->bih.bV5BitCount;
261             else
262                 count = This->bih.bV5ClrUsed;
263
264             tablesize = sizeof(WICColor) * count;
265             wiccolors = HeapAlloc(GetProcessHeap(), 0, tablesize);
266             if (!wiccolors)
267             {
268                 hr = E_OUTOFMEMORY;
269                 goto end;
270             }
271
272             offset.QuadPart = This->palette_offset;
273             hr = IStream_Seek(This->stream, offset, STREAM_SEEK_SET, NULL);
274             if (FAILED(hr)) goto end;
275
276             hr = IStream_Read(This->stream, wiccolors, tablesize, &bytesread);
277             if (FAILED(hr)) goto end;
278             if (bytesread != tablesize) {
279                 hr = E_FAIL;
280                 goto end;
281             }
282
283             /* convert from BGR to BGRA by setting alpha to 100% */
284             for (i=0; i<count; i++)
285                 wiccolors[i] |= 0xff000000;
286         }
287         else
288         {
289             hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
290             goto end;
291         }
292     }
293
294 end:
295
296     LeaveCriticalSection(&This->lock);
297
298     if (SUCCEEDED(hr))
299         hr = IWICPalette_InitializeCustom(pIPalette, wiccolors, count);
300
301     HeapFree(GetProcessHeap(), 0, wiccolors);
302     HeapFree(GetProcessHeap(), 0, bgrcolors);
303     return hr;
304 }
305
306 static HRESULT WINAPI BmpFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
307     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
308 {
309     BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
310     HRESULT hr=S_OK;
311     UINT width, height;
312     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
313
314     EnterCriticalSection(&This->lock);
315     if (!This->imagedata)
316     {
317         hr = This->read_data_func(This);
318     }
319     LeaveCriticalSection(&This->lock);
320     if (FAILED(hr)) return hr;
321
322     hr = BmpFrameDecode_GetSize(iface, &width, &height);
323     if (FAILED(hr)) return hr;
324
325     return copy_pixels(This->bitsperpixel, This->imagedatastart,
326         width, height, This->stride,
327         prc, cbStride, cbBufferSize, pbBuffer);
328 }
329
330 static HRESULT WINAPI BmpFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
331     IWICMetadataQueryReader **ppIMetadataQueryReader)
332 {
333     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
334     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
335 }
336
337 static HRESULT WINAPI BmpFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
338     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
339 {
340     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
341     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
342 }
343
344 static HRESULT WINAPI BmpFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
345     IWICBitmapSource **ppIThumbnail)
346 {
347     TRACE("(%p,%p)\n", iface, ppIThumbnail);
348     return WINCODEC_ERR_CODECNOTHUMBNAIL;
349 }
350
351 static HRESULT BmpFrameDecode_ReadUncompressed(BmpDecoder* This)
352 {
353     UINT bytesperrow;
354     UINT width, height;
355     UINT datasize;
356     int bottomup;
357     HRESULT hr;
358     LARGE_INTEGER offbits;
359     ULONG bytesread;
360
361     if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
362     {
363         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
364         width = bch->bcWidth;
365         height = bch->bcHeight;
366         bottomup = 1;
367     }
368     else
369     {
370         width = This->bih.bV5Width;
371         height = abs(This->bih.bV5Height);
372         bottomup = (This->bih.bV5Height > 0);
373     }
374
375     /* row sizes in BMP files must be divisible by 4 bytes */
376     bytesperrow = (((width * This->bitsperpixel)+31)/32)*4;
377     datasize = bytesperrow * height;
378
379     This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
380     if (!This->imagedata) return E_OUTOFMEMORY;
381
382     offbits.QuadPart = This->image_offset;
383     hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
384     if (FAILED(hr)) goto fail;
385
386     hr = IStream_Read(This->stream, This->imagedata, datasize, &bytesread);
387     if (FAILED(hr) || bytesread != datasize) goto fail;
388
389     if (bottomup)
390     {
391         This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
392         This->stride = -bytesperrow;
393     }
394     else
395     {
396         This->imagedatastart = This->imagedata;
397         This->stride = bytesperrow;
398     }
399     return S_OK;
400
401 fail:
402     HeapFree(GetProcessHeap(), 0, This->imagedata);
403     This->imagedata = NULL;
404     if (SUCCEEDED(hr)) hr = E_FAIL;
405     return hr;
406 }
407
408 static HRESULT BmpFrameDecode_ReadRGB8(BmpDecoder* This)
409 {
410     HRESULT hr;
411     UINT width, height;
412
413     hr = IWICBitmapFrameDecode_GetSize(&This->IWICBitmapFrameDecode_iface, &width, &height);
414
415     if (SUCCEEDED(hr))
416     {
417         hr = BmpFrameDecode_ReadUncompressed(This);
418     }
419
420     if (SUCCEEDED(hr))
421     {
422         reverse_bgr8(This->bitsperpixel/8, This->imagedatastart,
423             width, height, This->stride);
424     }
425
426     return hr;
427 }
428
429 static HRESULT ReadByte(IStream *stream, BYTE *buffer, ULONG buffer_size,
430     ULONG *cursor, ULONG *bytesread, BYTE *result)
431 {
432     HRESULT hr=S_OK;
433
434     if (*bytesread == 0 || *cursor == *bytesread)
435     {
436         hr = IStream_Read(stream, buffer, buffer_size, bytesread);
437         *cursor = 0;
438     }
439
440     if (SUCCEEDED(hr))
441     {
442         if (*cursor < *bytesread)
443             *result = buffer[(*cursor)++];
444         else
445             hr = E_FAIL;
446     }
447
448     return hr;
449 }
450
451 static HRESULT BmpFrameDecode_ReadRLE8(BmpDecoder* This)
452 {
453     UINT bytesperrow;
454     UINT width, height;
455     BYTE rledata[4096];
456     UINT datasize, palettesize;
457     DWORD palette[256];
458     UINT x, y;
459     DWORD *bgrdata;
460     HRESULT hr;
461     LARGE_INTEGER offbits;
462     ULONG cursor=0, bytesread=0;
463
464     width = This->bih.bV5Width;
465     height = abs(This->bih.bV5Height);
466     bytesperrow = width * 4;
467     datasize = bytesperrow * height;
468     if (This->bih.bV5ClrUsed && This->bih.bV5ClrUsed < 256)
469         palettesize = 4 * This->bih.bV5ClrUsed;
470     else
471         palettesize = 4 * 256;
472
473     This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
474     if (!This->imagedata)
475     {
476         hr = E_OUTOFMEMORY;
477         goto fail;
478     }
479
480     /* read palette */
481     offbits.QuadPart = This->palette_offset;
482     hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
483     if (FAILED(hr)) goto fail;
484
485     hr = IStream_Read(This->stream, palette, palettesize, &bytesread);
486     if (FAILED(hr) || bytesread != palettesize) goto fail;
487
488     /* read RLE data */
489     offbits.QuadPart = This->image_offset;
490     hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
491     if (FAILED(hr)) goto fail;
492
493     /* decode RLE */
494     bgrdata = (DWORD*)This->imagedata;
495     x = 0;
496     y = 0;
497     cursor = 0;
498     bytesread = 0;
499     while (y < height)
500     {
501         BYTE length;
502         hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length);
503
504         if (FAILED(hr))
505             goto fail;
506         else if (length == 0)
507         {
508             /* escape code */
509             BYTE escape;
510             hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &escape);
511             if (FAILED(hr))
512                 goto fail;
513             switch(escape)
514             {
515             case 0: /* end of line */
516                 x = 0;
517                 y++;
518                 break;
519             case 1: /* end of bitmap */
520                 goto end;
521             case 2: /* delta */
522             {
523                 BYTE dx, dy;
524                 hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dx);
525                 if (SUCCEEDED(hr))
526                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dy);
527                 if (FAILED(hr))
528                     goto fail;
529                 x += dx;
530                 y += dy;
531                 break;
532             }
533             default: /* absolute mode */
534                 length = escape;
535                 while (length-- && x < width)
536                 {
537                     BYTE index;
538                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &index);
539                     if (FAILED(hr))
540                         goto fail;
541                     bgrdata[y*width + x++] = palette[index];
542                 }
543                 if (escape & 1)
544                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length); /* skip pad byte */
545                 if (FAILED(hr))
546                     goto fail;
547             }
548         }
549         else
550         {
551             BYTE index;
552             DWORD color;
553             hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &index);
554             if (FAILED(hr))
555                 goto fail;
556             color = palette[index];
557             while (length-- && x < width)
558                 bgrdata[y*width + x++] = color;
559         }
560     }
561
562 end:
563     This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
564     This->stride = -bytesperrow;
565
566     return S_OK;
567
568 fail:
569     HeapFree(GetProcessHeap(), 0, This->imagedata);
570     This->imagedata = NULL;
571     if (SUCCEEDED(hr)) hr = E_FAIL;
572     return hr;
573 }
574
575 static HRESULT BmpFrameDecode_ReadRLE4(BmpDecoder* This)
576 {
577     UINT bytesperrow;
578     UINT width, height;
579     BYTE rledata[4096];
580     UINT datasize, palettesize;
581     DWORD palette[16];
582     UINT x, y;
583     DWORD *bgrdata;
584     HRESULT hr;
585     LARGE_INTEGER offbits;
586     ULONG cursor=0, bytesread=0;
587
588     width = This->bih.bV5Width;
589     height = abs(This->bih.bV5Height);
590     bytesperrow = width * 4;
591     datasize = bytesperrow * height;
592     if (This->bih.bV5ClrUsed && This->bih.bV5ClrUsed < 16)
593         palettesize = 4 * This->bih.bV5ClrUsed;
594     else
595         palettesize = 4 * 16;
596
597     This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
598     if (!This->imagedata)
599     {
600         hr = E_OUTOFMEMORY;
601         goto fail;
602     }
603
604     /* read palette */
605     offbits.QuadPart = This->palette_offset;
606     hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
607     if (FAILED(hr)) goto fail;
608
609     hr = IStream_Read(This->stream, palette, palettesize, &bytesread);
610     if (FAILED(hr) || bytesread != palettesize) goto fail;
611
612     /* read RLE data */
613     offbits.QuadPart = This->image_offset;
614     hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
615     if (FAILED(hr)) goto fail;
616
617     /* decode RLE */
618     bgrdata = (DWORD*)This->imagedata;
619     x = 0;
620     y = 0;
621     cursor = 0;
622     bytesread = 0;
623     while (y < height)
624     {
625         BYTE length;
626         hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length);
627
628         if (FAILED(hr))
629             goto fail;
630         else if (length == 0)
631         {
632             /* escape code */
633             BYTE escape;
634             hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &escape);
635             if (FAILED(hr))
636                 goto fail;
637             switch(escape)
638             {
639             case 0: /* end of line */
640                 x = 0;
641                 y++;
642                 break;
643             case 1: /* end of bitmap */
644                 goto end;
645             case 2: /* delta */
646             {
647                 BYTE dx, dy;
648                 hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dx);
649                 if (SUCCEEDED(hr))
650                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dy);
651                 if (FAILED(hr))
652                     goto fail;
653                 x += dx;
654                 y += dy;
655                 break;
656             }
657             default: /* absolute mode */
658             {
659                 BYTE realsize=0;
660                 length = escape;
661                 while (length-- && x < width)
662                 {
663                     BYTE colors;
664                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &colors);
665                     realsize++;
666                     if (FAILED(hr))
667                         goto fail;
668                     bgrdata[y*width + x++] = palette[colors>>4];
669                     if (length-- && x < width)
670                         bgrdata[y*width + x++] = palette[colors&0xf];
671                     else
672                         break;
673                 }
674                 if (realsize & 1)
675                     hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length); /* skip pad byte */
676                 if (FAILED(hr))
677                     goto fail;
678             }
679             }
680         }
681         else
682         {
683             BYTE colors;
684             DWORD color1;
685             DWORD color2;
686             hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &colors);
687             if (FAILED(hr))
688                 goto fail;
689             color1 = palette[colors>>4];
690             color2 = palette[colors&0xf];
691             while (length-- && x < width)
692             {
693                 bgrdata[y*width + x++] = color1;
694                 if (length-- && x < width)
695                     bgrdata[y*width + x++] = color2;
696                 else
697                     break;
698             }
699         }
700     }
701
702 end:
703     This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
704     This->stride = -bytesperrow;
705
706     return S_OK;
707
708 fail:
709     HeapFree(GetProcessHeap(), 0, This->imagedata);
710     This->imagedata = NULL;
711     if (SUCCEEDED(hr)) hr = E_FAIL;
712     return hr;
713 }
714
715 static HRESULT BmpFrameDecode_ReadUnsupported(BmpDecoder* This)
716 {
717     return E_FAIL;
718 }
719
720 struct bitfields_format {
721     WORD bitcount; /* 0 for end of list */
722     DWORD redmask;
723     DWORD greenmask;
724     DWORD bluemask;
725     DWORD alphamask;
726     const WICPixelFormatGUID *pixelformat;
727     ReadDataFunc read_data_func;
728 };
729
730 static const struct bitfields_format bitfields_formats[] = {
731     {16,0x7c00,0x3e0,0x1f,0,&GUID_WICPixelFormat16bppBGR555,BmpFrameDecode_ReadUncompressed},
732     {16,0xf800,0x7e0,0x1f,0,&GUID_WICPixelFormat16bppBGR565,BmpFrameDecode_ReadUncompressed},
733     {32,0xff0000,0xff00,0xff,0,&GUID_WICPixelFormat32bppBGR,BmpFrameDecode_ReadUncompressed},
734     {32,0xff0000,0xff00,0xff,0xff000000,&GUID_WICPixelFormat32bppBGRA,BmpFrameDecode_ReadUncompressed},
735     {32,0xff,0xff00,0xff0000,0,&GUID_WICPixelFormat32bppBGR,BmpFrameDecode_ReadRGB8},
736     {0}
737 };
738
739 static const IWICBitmapFrameDecodeVtbl BmpDecoder_FrameVtbl = {
740     BmpFrameDecode_QueryInterface,
741     BmpFrameDecode_AddRef,
742     BmpFrameDecode_Release,
743     BmpFrameDecode_GetSize,
744     BmpFrameDecode_GetPixelFormat,
745     BmpFrameDecode_GetResolution,
746     BmpFrameDecode_CopyPalette,
747     BmpFrameDecode_CopyPixels,
748     BmpFrameDecode_GetMetadataQueryReader,
749     BmpFrameDecode_GetColorContexts,
750     BmpFrameDecode_GetThumbnail
751 };
752
753 static HRESULT BmpDecoder_ReadHeaders(BmpDecoder* This, IStream *stream)
754 {
755     HRESULT hr;
756     ULONG bytestoread, bytesread;
757     LARGE_INTEGER seek;
758
759     if (This->initialized) return WINCODEC_ERR_WRONGSTATE;
760
761     seek.QuadPart = 0;
762     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
763     if (FAILED(hr)) return hr;
764
765     if (!This->packed)
766     {
767         BITMAPFILEHEADER bfh;
768         hr = IStream_Read(stream, &bfh, sizeof(BITMAPFILEHEADER), &bytesread);
769         if (FAILED(hr)) return hr;
770         if (bytesread != sizeof(BITMAPFILEHEADER) ||
771             bfh.bfType != 0x4d42 /* "BM" */) return E_FAIL;
772         This->image_offset = bfh.bfOffBits;
773     }
774
775     hr = IStream_Read(stream, &This->bih.bV5Size, sizeof(DWORD), &bytesread);
776     if (FAILED(hr)) return hr;
777     if (bytesread != sizeof(DWORD) ||
778         (This->bih.bV5Size != sizeof(BITMAPCOREHEADER) &&
779          This->bih.bV5Size != sizeof(BITMAPCOREHEADER2) &&
780          This->bih.bV5Size != sizeof(BITMAPINFOHEADER) &&
781          This->bih.bV5Size != sizeof(BITMAPV4HEADER) &&
782          This->bih.bV5Size != sizeof(BITMAPV5HEADER))) return E_FAIL;
783
784     bytestoread = This->bih.bV5Size-sizeof(DWORD);
785     hr = IStream_Read(stream, &This->bih.bV5Width, bytestoread, &bytesread);
786     if (FAILED(hr)) return hr;
787     if (bytestoread != bytesread) return E_FAIL;
788
789     if (This->packed)
790         This->palette_offset = This->bih.bV5Size;
791     else
792         This->palette_offset = sizeof(BITMAPFILEHEADER) + This->bih.bV5Size;
793
794     if (This->icoframe)
795     {
796         if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
797         {
798             BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
799             bch->bcHeight /= 2;
800         }
801         else
802         {
803             This->bih.bV5Height /= 2;
804         }
805     }
806
807     /* if this is a BITMAPINFOHEADER with BI_BITFIELDS compression, we need to
808         read the extra fields */
809     if (This->bih.bV5Size == sizeof(BITMAPINFOHEADER) &&
810         This->bih.bV5Compression == BI_BITFIELDS)
811     {
812         hr = IStream_Read(stream, &This->bih.bV5RedMask, 12, &bytesread);
813         if (FAILED(hr)) return hr;
814         if (bytesread != 12) return E_FAIL;
815         This->bih.bV5AlphaMask = 0;
816         This->palette_offset += 12;
817     }
818
819     /* decide what kind of bitmap this is and how/if we can read it */
820     if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
821     {
822         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
823         TRACE("BITMAPCOREHEADER with depth=%i\n", bch->bcBitCount);
824         This->bitsperpixel = bch->bcBitCount;
825         This->read_data_func = BmpFrameDecode_ReadUncompressed;
826         switch(bch->bcBitCount)
827         {
828         case 1:
829             This->pixelformat = &GUID_WICPixelFormat1bppIndexed;
830             break;
831         case 2:
832             This->pixelformat = &GUID_WICPixelFormat2bppIndexed;
833             break;
834         case 4:
835             This->pixelformat = &GUID_WICPixelFormat4bppIndexed;
836             break;
837         case 8:
838             This->pixelformat = &GUID_WICPixelFormat8bppIndexed;
839             break;
840         case 24:
841             This->pixelformat = &GUID_WICPixelFormat24bppBGR;
842             break;
843         default:
844             This->pixelformat = &GUID_WICPixelFormatUndefined;
845             WARN("unsupported bit depth %i for BITMAPCOREHEADER\n", bch->bcBitCount);
846             break;
847         }
848     }
849     else /* struct is compatible with BITMAPINFOHEADER */
850     {
851         TRACE("bitmap header=%i compression=%i depth=%i\n", This->bih.bV5Size, This->bih.bV5Compression, This->bih.bV5BitCount);
852         switch(This->bih.bV5Compression)
853         {
854         case BI_RGB:
855             This->bitsperpixel = This->bih.bV5BitCount;
856             This->read_data_func = BmpFrameDecode_ReadUncompressed;
857             switch(This->bih.bV5BitCount)
858             {
859             case 1:
860                 This->pixelformat = &GUID_WICPixelFormat1bppIndexed;
861                 break;
862             case 2:
863                 This->pixelformat = &GUID_WICPixelFormat2bppIndexed;
864                 break;
865             case 4:
866                 This->pixelformat = &GUID_WICPixelFormat4bppIndexed;
867                 break;
868             case 8:
869                 This->pixelformat = &GUID_WICPixelFormat8bppIndexed;
870                 break;
871             case 16:
872                 This->pixelformat = &GUID_WICPixelFormat16bppBGR555;
873                 break;
874             case 24:
875                 This->pixelformat = &GUID_WICPixelFormat24bppBGR;
876                 break;
877             case 32:
878                 This->pixelformat = &GUID_WICPixelFormat32bppBGR;
879                 break;
880             default:
881                 This->pixelformat = &GUID_WICPixelFormatUndefined;
882                 FIXME("unsupported bit depth %i for uncompressed RGB\n", This->bih.bV5BitCount);
883             }
884             break;
885         case BI_RLE8:
886             This->bitsperpixel = 32;
887             This->read_data_func = BmpFrameDecode_ReadRLE8;
888             This->pixelformat = &GUID_WICPixelFormat32bppBGR;
889             break;
890         case BI_RLE4:
891             This->bitsperpixel = 32;
892             This->read_data_func = BmpFrameDecode_ReadRLE4;
893             This->pixelformat = &GUID_WICPixelFormat32bppBGR;
894             break;
895         case BI_BITFIELDS:
896         {
897             const struct bitfields_format *format;
898             if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER2))
899             {
900                 /* BCH2 doesn't support bitfields; this is Huffman 1D compression */
901                 This->bitsperpixel = 0;
902                 This->read_data_func = BmpFrameDecode_ReadUnsupported;
903                 This->pixelformat = &GUID_WICPixelFormatUndefined;
904                 FIXME("Huffman 1D compression is unsupported\n");
905                 break;
906             }
907             This->bitsperpixel = This->bih.bV5BitCount;
908             for (format = bitfields_formats; format->bitcount; format++)
909             {
910                 if ((format->bitcount == This->bih.bV5BitCount) &&
911                     (format->redmask == This->bih.bV5RedMask) &&
912                     (format->greenmask == This->bih.bV5GreenMask) &&
913                     (format->bluemask == This->bih.bV5BlueMask) &&
914                     (format->alphamask == This->bih.bV5AlphaMask))
915                 {
916                     This->read_data_func = format->read_data_func;
917                     This->pixelformat = format->pixelformat;
918                     break;
919                 }
920             }
921             if (!format->bitcount)
922             {
923                 This->read_data_func = BmpFrameDecode_ReadUncompressed;
924                 This->pixelformat = &GUID_WICPixelFormatUndefined;
925                 FIXME("unsupported bitfields type depth=%i red=%x green=%x blue=%x alpha=%x\n",
926                     This->bih.bV5BitCount, This->bih.bV5RedMask, This->bih.bV5GreenMask, This->bih.bV5BlueMask, This->bih.bV5AlphaMask);
927             }
928             break;
929         }
930         default:
931             This->bitsperpixel = 0;
932             This->read_data_func = BmpFrameDecode_ReadUnsupported;
933             This->pixelformat = &GUID_WICPixelFormatUndefined;
934             FIXME("unsupported bitmap type header=%i compression=%i depth=%i\n", This->bih.bV5Size, This->bih.bV5Compression, This->bih.bV5BitCount);
935             break;
936         }
937     }
938
939     if (This->packed)
940     {
941         /* In a packed DIB, the image follows the palette. */
942         ULONG palette_count, palette_size;
943         if (This->bih.bV5ClrUsed)
944             palette_count = This->bih.bV5ClrUsed;
945         else if (This->bih.bV5BitCount <= 8)
946             palette_count = 1 << This->bih.bV5BitCount;
947         else
948             palette_count = 0;
949         if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
950             palette_size = sizeof(RGBTRIPLE) * palette_count;
951         else
952             palette_size = sizeof(RGBQUAD) * palette_count;
953         This->image_offset = This->palette_offset + palette_size;
954     }
955
956     This->initialized = TRUE;
957
958     return S_OK;
959 }
960
961 static HRESULT WINAPI BmpDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
962     void **ppv)
963 {
964     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
965     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
966
967     if (!ppv) return E_INVALIDARG;
968
969     if (IsEqualIID(&IID_IUnknown, iid) ||
970         IsEqualIID(&IID_IWICBitmapDecoder, iid))
971     {
972         *ppv = &This->IWICBitmapDecoder_iface;
973     }
974     else
975     {
976         *ppv = NULL;
977         return E_NOINTERFACE;
978     }
979
980     IUnknown_AddRef((IUnknown*)*ppv);
981     return S_OK;
982 }
983
984 static ULONG WINAPI BmpDecoder_AddRef(IWICBitmapDecoder *iface)
985 {
986     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
987     ULONG ref = InterlockedIncrement(&This->ref);
988
989     TRACE("(%p) refcount=%u\n", iface, ref);
990
991     return ref;
992 }
993
994 static ULONG WINAPI BmpDecoder_Release(IWICBitmapDecoder *iface)
995 {
996     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
997     ULONG ref = InterlockedDecrement(&This->ref);
998
999     TRACE("(%p) refcount=%u\n", iface, ref);
1000
1001     if (ref == 0)
1002     {
1003         if (This->stream) IStream_Release(This->stream);
1004         HeapFree(GetProcessHeap(), 0, This->imagedata);
1005         This->lock.DebugInfo->Spare[0] = 0;
1006         DeleteCriticalSection(&This->lock);
1007         HeapFree(GetProcessHeap(), 0, This);
1008     }
1009
1010     return ref;
1011 }
1012
1013 static HRESULT WINAPI BmpDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
1014     DWORD *pdwCapability)
1015 {
1016     HRESULT hr;
1017     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
1018
1019     EnterCriticalSection(&This->lock);
1020     hr = BmpDecoder_ReadHeaders(This, pIStream);
1021     LeaveCriticalSection(&This->lock);
1022     if (FAILED(hr)) return hr;
1023
1024     if (This->read_data_func == BmpFrameDecode_ReadUnsupported)
1025         *pdwCapability = 0;
1026     else
1027         *pdwCapability = WICBitmapDecoderCapabilityCanDecodeAllImages;
1028
1029     return S_OK;
1030 }
1031
1032 static HRESULT WINAPI BmpDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
1033     WICDecodeOptions cacheOptions)
1034 {
1035     HRESULT hr;
1036     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
1037
1038     EnterCriticalSection(&This->lock);
1039     hr = BmpDecoder_ReadHeaders(This, pIStream);
1040
1041     if (SUCCEEDED(hr))
1042     {
1043         This->stream = pIStream;
1044         IStream_AddRef(pIStream);
1045     }
1046     LeaveCriticalSection(&This->lock);
1047
1048     return hr;
1049 }
1050
1051 static HRESULT WINAPI BmpDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
1052     GUID *pguidContainerFormat)
1053 {
1054     memcpy(pguidContainerFormat, &GUID_ContainerFormatBmp, sizeof(GUID));
1055     return S_OK;
1056 }
1057
1058 static HRESULT WINAPI BmpDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
1059     IWICBitmapDecoderInfo **ppIDecoderInfo)
1060 {
1061     HRESULT hr;
1062     IWICComponentInfo *compinfo;
1063
1064     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
1065
1066     hr = CreateComponentInfo(&CLSID_WICBmpDecoder, &compinfo);
1067     if (FAILED(hr)) return hr;
1068
1069     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
1070         (void**)ppIDecoderInfo);
1071
1072     IWICComponentInfo_Release(compinfo);
1073
1074     return hr;
1075 }
1076
1077 static HRESULT WINAPI BmpDecoder_CopyPalette(IWICBitmapDecoder *iface,
1078     IWICPalette *pIPalette)
1079 {
1080     TRACE("(%p,%p)\n", iface, pIPalette);
1081
1082     return WINCODEC_ERR_PALETTEUNAVAILABLE;
1083 }
1084
1085 static HRESULT WINAPI BmpDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
1086     IWICMetadataQueryReader **ppIMetadataQueryReader)
1087 {
1088     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1089     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1090 }
1091
1092 static HRESULT WINAPI BmpDecoder_GetPreview(IWICBitmapDecoder *iface,
1093     IWICBitmapSource **ppIBitmapSource)
1094 {
1095     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
1096     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1097 }
1098
1099 static HRESULT WINAPI BmpDecoder_GetColorContexts(IWICBitmapDecoder *iface,
1100     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
1101 {
1102     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1103     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1104 }
1105
1106 static HRESULT WINAPI BmpDecoder_GetThumbnail(IWICBitmapDecoder *iface,
1107     IWICBitmapSource **ppIThumbnail)
1108 {
1109     TRACE("(%p,%p)\n", iface, ppIThumbnail);
1110     return WINCODEC_ERR_CODECNOTHUMBNAIL;
1111 }
1112
1113 static HRESULT WINAPI BmpDecoder_GetFrameCount(IWICBitmapDecoder *iface,
1114     UINT *pCount)
1115 {
1116     *pCount = 1;
1117     return S_OK;
1118 }
1119
1120 static HRESULT WINAPI BmpDecoder_GetFrame(IWICBitmapDecoder *iface,
1121     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
1122 {
1123     BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
1124
1125     if (index != 0) return E_INVALIDARG;
1126
1127     if (!This->stream) return WINCODEC_ERR_WRONGSTATE;
1128
1129     *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
1130     IWICBitmapDecoder_AddRef(iface);
1131
1132     return S_OK;
1133 }
1134
1135 static const IWICBitmapDecoderVtbl BmpDecoder_Vtbl = {
1136     BmpDecoder_QueryInterface,
1137     BmpDecoder_AddRef,
1138     BmpDecoder_Release,
1139     BmpDecoder_QueryCapability,
1140     BmpDecoder_Initialize,
1141     BmpDecoder_GetContainerFormat,
1142     BmpDecoder_GetDecoderInfo,
1143     BmpDecoder_CopyPalette,
1144     BmpDecoder_GetMetadataQueryReader,
1145     BmpDecoder_GetPreview,
1146     BmpDecoder_GetColorContexts,
1147     BmpDecoder_GetThumbnail,
1148     BmpDecoder_GetFrameCount,
1149     BmpDecoder_GetFrame
1150 };
1151
1152 static HRESULT BmpDecoder_Create(int packed, int icoframe, BmpDecoder **ppDecoder)
1153 {
1154     BmpDecoder *This;
1155
1156     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpDecoder));
1157     if (!This) return E_OUTOFMEMORY;
1158
1159     This->IWICBitmapDecoder_iface.lpVtbl = &BmpDecoder_Vtbl;
1160     This->IWICBitmapFrameDecode_iface.lpVtbl = &BmpDecoder_FrameVtbl;
1161     This->ref = 1;
1162     This->initialized = FALSE;
1163     This->stream = NULL;
1164     This->imagedata = NULL;
1165     InitializeCriticalSection(&This->lock);
1166     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BmpDecoder.lock");
1167     This->packed = packed;
1168     This->icoframe = icoframe;
1169
1170     *ppDecoder = This;
1171
1172     return S_OK;
1173 }
1174
1175 static HRESULT BmpDecoder_Construct(int packed, int icoframe, IUnknown *pUnkOuter, REFIID iid, void** ppv)
1176 {
1177     BmpDecoder *This;
1178     HRESULT ret;
1179
1180     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1181
1182     *ppv = NULL;
1183
1184     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1185
1186     ret = BmpDecoder_Create(packed, icoframe, &This);
1187     if (FAILED(ret)) return ret;
1188
1189     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1190     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1191
1192     return ret;
1193 }
1194
1195 HRESULT BmpDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1196 {
1197     return BmpDecoder_Construct(FALSE, FALSE, pUnkOuter, iid, ppv);
1198 }
1199
1200 HRESULT DibDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1201 {
1202     return BmpDecoder_Construct(TRUE, FALSE, pUnkOuter, iid, ppv);
1203 }
1204
1205 HRESULT IcoDibDecoder_CreateInstance(BmpDecoder **ppDecoder)
1206 {
1207     return BmpDecoder_Create(TRUE, TRUE, ppDecoder);
1208 }
1209
1210 void BmpDecoder_GetWICDecoder(BmpDecoder *This, IWICBitmapDecoder **ppDecoder)
1211 {
1212     *ppDecoder = &This->IWICBitmapDecoder_iface;
1213 }
1214
1215 /* Return the offset where the mask of an icon might be, or 0 for failure. */
1216 void BmpDecoder_FindIconMask(BmpDecoder *This, ULONG *mask_offset, int *topdown)
1217 {
1218     assert(This->stream != NULL);
1219
1220     if (This->read_data_func == BmpFrameDecode_ReadUncompressed)
1221     {
1222         /* RGB or BITFIELDS data */
1223         ULONG width, height, bytesperrow, datasize;
1224         IWICBitmapFrameDecode_GetSize(&This->IWICBitmapFrameDecode_iface, &width, &height);
1225         bytesperrow = (((width * This->bitsperpixel)+31)/32)*4;
1226         datasize = bytesperrow * height;
1227         *mask_offset = This->image_offset + datasize;
1228     }
1229     else
1230         *mask_offset = 0;
1231
1232     *topdown = This->stride > 0;
1233 }