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