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