[SHELL32] CDrivesFolder: Implement the eject and disconnect menu items. CORE-13841
[reactos.git] / dll / win32 / windowscodecs / tgaformat.c
1 /*
2 * Copyright 2010 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 "pshpack1.h"
22
23 typedef struct {
24 BYTE id_length;
25 BYTE colormap_type;
26 BYTE image_type;
27 /* Colormap Specification */
28 WORD colormap_firstentry;
29 WORD colormap_length;
30 BYTE colormap_entrysize;
31 /* Image Specification */
32 WORD xorigin;
33 WORD yorigin;
34 WORD width;
35 WORD height;
36 BYTE depth;
37 BYTE image_descriptor;
38 } tga_header;
39
40 #define IMAGETYPE_COLORMAPPED 1
41 #define IMAGETYPE_TRUECOLOR 2
42 #define IMAGETYPE_GRAYSCALE 3
43 #define IMAGETYPE_RLE 8
44
45 #define IMAGE_ATTRIBUTE_BITCOUNT_MASK 0xf
46 #define IMAGE_RIGHTTOLEFT 0x10
47 #define IMAGE_TOPTOBOTTOM 0x20
48
49 typedef struct {
50 DWORD extension_area_offset;
51 DWORD developer_directory_offset;
52 char magic[18];
53 } tga_footer;
54
55 static const BYTE tga_footer_magic[18] = "TRUEVISION-XFILE.";
56
57 typedef struct {
58 WORD size;
59 char author_name[41];
60 char author_comments[324];
61 WORD timestamp[6];
62 char job_name[41];
63 WORD job_timestamp[6];
64 char software_id[41];
65 WORD software_version;
66 char software_version_letter;
67 DWORD key_color;
68 WORD pixel_width;
69 WORD pixel_height;
70 WORD gamma_numerator;
71 WORD gamma_denominator;
72 DWORD color_correction_offset;
73 DWORD thumbnail_offset;
74 DWORD scanline_offset;
75 BYTE attributes_type;
76 } tga_extension_area;
77
78 #define ATTRIBUTE_NO_ALPHA 0
79 #define ATTRIBUTE_UNDEFINED 1
80 #define ATTRIBUTE_UNDEFINED_PRESERVE 2
81 #define ATTRIBUTE_ALPHA 3
82 #define ATTRIBUTE_PALPHA 4
83
84 #include "poppack.h"
85
86 typedef struct {
87 IWICBitmapDecoder IWICBitmapDecoder_iface;
88 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
89 LONG ref;
90 BOOL initialized;
91 IStream *stream;
92 tga_header header;
93 tga_extension_area extension_area;
94 BYTE *imagebits;
95 BYTE *origin;
96 int stride;
97 ULONG id_offset;
98 ULONG colormap_length;
99 ULONG colormap_offset;
100 ULONG image_offset;
101 ULONG extension_area_offset;
102 ULONG developer_directory_offset;
103 CRITICAL_SECTION lock;
104 } TgaDecoder;
105
106 static inline TgaDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
107 {
108 return CONTAINING_RECORD(iface, TgaDecoder, IWICBitmapDecoder_iface);
109 }
110
111 static inline TgaDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
112 {
113 return CONTAINING_RECORD(iface, TgaDecoder, IWICBitmapFrameDecode_iface);
114 }
115
116 static HRESULT WINAPI TgaDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
117 void **ppv)
118 {
119 TgaDecoder *This = impl_from_IWICBitmapDecoder(iface);
120 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
121
122 if (!ppv) return E_INVALIDARG;
123
124 if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
125 {
126 *ppv = &This->IWICBitmapDecoder_iface;
127 }
128 else
129 {
130 *ppv = NULL;
131 return E_NOINTERFACE;
132 }
133
134 IUnknown_AddRef((IUnknown*)*ppv);
135 return S_OK;
136 }
137
138 static ULONG WINAPI TgaDecoder_AddRef(IWICBitmapDecoder *iface)
139 {
140 TgaDecoder *This = impl_from_IWICBitmapDecoder(iface);
141 ULONG ref = InterlockedIncrement(&This->ref);
142
143 TRACE("(%p) refcount=%u\n", iface, ref);
144
145 return ref;
146 }
147
148 static ULONG WINAPI TgaDecoder_Release(IWICBitmapDecoder *iface)
149 {
150 TgaDecoder *This = impl_from_IWICBitmapDecoder(iface);
151 ULONG ref = InterlockedDecrement(&This->ref);
152
153 TRACE("(%p) refcount=%u\n", iface, ref);
154
155 if (ref == 0)
156 {
157 This->lock.DebugInfo->Spare[0] = 0;
158 DeleteCriticalSection(&This->lock);
159 if (This->stream)
160 IStream_Release(This->stream);
161 HeapFree(GetProcessHeap(), 0, This->imagebits);
162 HeapFree(GetProcessHeap(), 0, This);
163 }
164
165 return ref;
166 }
167
168 static HRESULT WINAPI TgaDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
169 DWORD *capability)
170 {
171 HRESULT hr;
172
173 TRACE("(%p,%p,%p)\n", iface, stream, capability);
174
175 if (!stream || !capability) return E_INVALIDARG;
176
177 hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
178 if (hr != S_OK) return hr;
179
180 *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
181 WICBitmapDecoderCapabilityCanDecodeSomeImages;
182 return S_OK;
183 }
184
185 static HRESULT WINAPI TgaDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
186 WICDecodeOptions cacheOptions)
187 {
188 TgaDecoder *This = impl_from_IWICBitmapDecoder(iface);
189 HRESULT hr=S_OK;
190 DWORD bytesread;
191 LARGE_INTEGER seek;
192 tga_footer footer;
193 int attribute_bitcount;
194 int mapped_depth=0;
195
196 TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOptions);
197
198 EnterCriticalSection(&This->lock);
199
200 if (This->initialized)
201 {
202 hr = WINCODEC_ERR_WRONGSTATE;
203 goto end;
204 }
205
206 seek.QuadPart = 0;
207 hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
208 if (FAILED(hr)) goto end;
209
210 hr = IStream_Read(pIStream, &This->header, sizeof(tga_header), &bytesread);
211 if (SUCCEEDED(hr) && bytesread != sizeof(tga_header))
212 {
213 TRACE("got only %u bytes\n", bytesread);
214 hr = E_FAIL;
215 }
216 if (FAILED(hr)) goto end;
217
218 TRACE("imagetype=%u, colormap type=%u, depth=%u, image descriptor=0x%x\n",
219 This->header.image_type, This->header.colormap_type,
220 This->header.depth, This->header.image_descriptor);
221
222 /* Sanity checking. Since TGA has no clear identifying markers, we need
223 * to be careful to not load a non-TGA image. */
224 switch (This->header.image_type)
225 {
226 case IMAGETYPE_COLORMAPPED:
227 case IMAGETYPE_COLORMAPPED|IMAGETYPE_RLE:
228 if (This->header.colormap_type != 1)
229 hr = E_FAIL;
230 mapped_depth = This->header.colormap_entrysize;
231 break;
232 case IMAGETYPE_TRUECOLOR:
233 case IMAGETYPE_TRUECOLOR|IMAGETYPE_RLE:
234 if (This->header.colormap_type != 0 && This->header.colormap_type != 1)
235 hr = E_FAIL;
236 mapped_depth = This->header.depth;
237 break;
238 case IMAGETYPE_GRAYSCALE:
239 case IMAGETYPE_GRAYSCALE|IMAGETYPE_RLE:
240 if (This->header.colormap_type != 0)
241 hr = E_FAIL;
242 mapped_depth = 0;
243 break;
244 default:
245 hr = E_FAIL;
246 }
247
248 if (This->header.depth != 8 && This->header.depth != 16 &&
249 This->header.depth != 24 && This->header.depth != 32)
250 hr = E_FAIL;
251
252 if ((This->header.image_descriptor & 0xc0) != 0)
253 hr = E_FAIL;
254
255 attribute_bitcount = This->header.image_descriptor & IMAGE_ATTRIBUTE_BITCOUNT_MASK;
256
257 if (attribute_bitcount &&
258 !((mapped_depth == 32 && attribute_bitcount == 8) ||
259 (mapped_depth == 16 && attribute_bitcount == 1)))
260 hr = E_FAIL;
261
262 if (FAILED(hr))
263 {
264 WARN("bad tga header\n");
265 goto end;
266 }
267
268 /* Locate data in the file based on the header. */
269 This->id_offset = sizeof(tga_header);
270 This->colormap_offset = This->id_offset + This->header.id_length;
271 if (This->header.colormap_type == 1)
272 This->colormap_length = ((This->header.colormap_entrysize+7)/8) * This->header.colormap_length;
273 else
274 This->colormap_length = 0;
275 This->image_offset = This->colormap_offset + This->colormap_length;
276
277 /* Read footer if there is one */
278 seek.QuadPart = -(LONGLONG)sizeof(tga_footer);
279 hr = IStream_Seek(pIStream, seek, STREAM_SEEK_END, NULL);
280
281 if (SUCCEEDED(hr)) {
282 hr = IStream_Read(pIStream, &footer, sizeof(tga_footer), &bytesread);
283 if (SUCCEEDED(hr) && bytesread != sizeof(tga_footer))
284 {
285 TRACE("got only %u footer bytes\n", bytesread);
286 hr = E_FAIL;
287 }
288
289 if (memcmp(footer.magic, tga_footer_magic, sizeof(tga_footer_magic)) == 0)
290 {
291 This->extension_area_offset = footer.extension_area_offset;
292 This->developer_directory_offset = footer.developer_directory_offset;
293 }
294 else
295 {
296 This->extension_area_offset = 0;
297 This->developer_directory_offset = 0;
298 }
299 }
300 else
301 {
302 /* File is too small to have a footer. */
303 This->extension_area_offset = 0;
304 This->developer_directory_offset = 0;
305 hr = S_OK;
306 }
307
308 if (This->extension_area_offset)
309 {
310 seek.QuadPart = This->extension_area_offset;
311 hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
312 if (FAILED(hr)) goto end;
313
314 hr = IStream_Read(pIStream, &This->extension_area, sizeof(tga_extension_area), &bytesread);
315 if (SUCCEEDED(hr) && bytesread != sizeof(tga_extension_area))
316 {
317 TRACE("got only %u extension area bytes\n", bytesread);
318 hr = E_FAIL;
319 }
320 if (SUCCEEDED(hr) && This->extension_area.size < 495)
321 {
322 TRACE("extension area is only %u bytes long\n", This->extension_area.size);
323 hr = E_FAIL;
324 }
325 if (FAILED(hr)) goto end;
326 }
327
328 IStream_AddRef(pIStream);
329 This->stream = pIStream;
330 This->initialized = TRUE;
331
332 end:
333 LeaveCriticalSection(&This->lock);
334 return hr;
335 }
336
337 static HRESULT WINAPI TgaDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
338 GUID *pguidContainerFormat)
339 {
340 memcpy(pguidContainerFormat, &GUID_WineContainerFormatTga, sizeof(GUID));
341 return S_OK;
342 }
343
344 static HRESULT WINAPI TgaDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
345 IWICBitmapDecoderInfo **ppIDecoderInfo)
346 {
347 HRESULT hr;
348 IWICComponentInfo *compinfo;
349
350 TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
351
352 hr = CreateComponentInfo(&CLSID_WineTgaDecoder, &compinfo);
353 if (FAILED(hr)) return hr;
354
355 hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
356 (void**)ppIDecoderInfo);
357
358 IWICComponentInfo_Release(compinfo);
359
360 return hr;
361 }
362
363 static HRESULT WINAPI TgaDecoder_CopyPalette(IWICBitmapDecoder *iface,
364 IWICPalette *pIPalette)
365 {
366 FIXME("(%p,%p): stub\n", iface, pIPalette);
367 return E_NOTIMPL;
368 }
369
370 static HRESULT WINAPI TgaDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
371 IWICMetadataQueryReader **ppIMetadataQueryReader)
372 {
373 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
374 return E_NOTIMPL;
375 }
376
377 static HRESULT WINAPI TgaDecoder_GetPreview(IWICBitmapDecoder *iface,
378 IWICBitmapSource **ppIBitmapSource)
379 {
380 FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
381 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
382 }
383
384 static HRESULT WINAPI TgaDecoder_GetColorContexts(IWICBitmapDecoder *iface,
385 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
386 {
387 FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
388 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
389 }
390
391 static HRESULT WINAPI TgaDecoder_GetThumbnail(IWICBitmapDecoder *iface,
392 IWICBitmapSource **ppIThumbnail)
393 {
394 FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
395 return WINCODEC_ERR_CODECNOTHUMBNAIL;
396 }
397
398 static HRESULT WINAPI TgaDecoder_GetFrameCount(IWICBitmapDecoder *iface,
399 UINT *pCount)
400 {
401 if (!pCount) return E_INVALIDARG;
402
403 *pCount = 1;
404 return S_OK;
405 }
406
407 static HRESULT WINAPI TgaDecoder_GetFrame(IWICBitmapDecoder *iface,
408 UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
409 {
410 TgaDecoder *This = impl_from_IWICBitmapDecoder(iface);
411 TRACE("(%p,%p)\n", iface, ppIBitmapFrame);
412
413 if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
414
415 if (index != 0) return E_INVALIDARG;
416
417 IWICBitmapDecoder_AddRef(iface);
418 *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
419
420 return S_OK;
421 }
422
423 static const IWICBitmapDecoderVtbl TgaDecoder_Vtbl = {
424 TgaDecoder_QueryInterface,
425 TgaDecoder_AddRef,
426 TgaDecoder_Release,
427 TgaDecoder_QueryCapability,
428 TgaDecoder_Initialize,
429 TgaDecoder_GetContainerFormat,
430 TgaDecoder_GetDecoderInfo,
431 TgaDecoder_CopyPalette,
432 TgaDecoder_GetMetadataQueryReader,
433 TgaDecoder_GetPreview,
434 TgaDecoder_GetColorContexts,
435 TgaDecoder_GetThumbnail,
436 TgaDecoder_GetFrameCount,
437 TgaDecoder_GetFrame
438 };
439
440 static HRESULT WINAPI TgaDecoder_Frame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
441 void **ppv)
442 {
443 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
444
445 if (!ppv) return E_INVALIDARG;
446
447 if (IsEqualIID(&IID_IUnknown, iid) ||
448 IsEqualIID(&IID_IWICBitmapSource, iid) ||
449 IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
450 {
451 *ppv = iface;
452 }
453 else
454 {
455 *ppv = NULL;
456 return E_NOINTERFACE;
457 }
458
459 IUnknown_AddRef((IUnknown*)*ppv);
460 return S_OK;
461 }
462
463 static ULONG WINAPI TgaDecoder_Frame_AddRef(IWICBitmapFrameDecode *iface)
464 {
465 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
466 return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
467 }
468
469 static ULONG WINAPI TgaDecoder_Frame_Release(IWICBitmapFrameDecode *iface)
470 {
471 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
472 return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
473 }
474
475 static HRESULT WINAPI TgaDecoder_Frame_GetSize(IWICBitmapFrameDecode *iface,
476 UINT *puiWidth, UINT *puiHeight)
477 {
478 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
479
480 *puiWidth = This->header.width;
481 *puiHeight = This->header.height;
482
483 TRACE("(%p)->(%u,%u)\n", iface, *puiWidth, *puiHeight);
484
485 return S_OK;
486 }
487
488 static HRESULT WINAPI TgaDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode *iface,
489 WICPixelFormatGUID *pPixelFormat)
490 {
491 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
492 int attribute_bitcount;
493 byte attribute_type;
494
495 TRACE("(%p,%p)\n", iface, pPixelFormat);
496
497 attribute_bitcount = This->header.image_descriptor & IMAGE_ATTRIBUTE_BITCOUNT_MASK;
498
499 if (attribute_bitcount && This->extension_area_offset)
500 attribute_type = This->extension_area.attributes_type;
501 else if (attribute_bitcount)
502 attribute_type = ATTRIBUTE_ALPHA;
503 else
504 attribute_type = ATTRIBUTE_NO_ALPHA;
505
506 switch (This->header.image_type & ~IMAGETYPE_RLE)
507 {
508 case IMAGETYPE_COLORMAPPED:
509 switch (This->header.depth)
510 {
511 case 8:
512 memcpy(pPixelFormat, &GUID_WICPixelFormat8bppIndexed, sizeof(GUID));
513 break;
514 default:
515 FIXME("Unhandled indexed color depth %u\n", This->header.depth);
516 return E_NOTIMPL;
517 }
518 break;
519 case IMAGETYPE_TRUECOLOR:
520 switch (This->header.depth)
521 {
522 case 16:
523 switch (attribute_type)
524 {
525 case ATTRIBUTE_NO_ALPHA:
526 case ATTRIBUTE_UNDEFINED:
527 case ATTRIBUTE_UNDEFINED_PRESERVE:
528 memcpy(pPixelFormat, &GUID_WICPixelFormat16bppBGR555, sizeof(GUID));
529 break;
530 case ATTRIBUTE_ALPHA:
531 case ATTRIBUTE_PALPHA:
532 memcpy(pPixelFormat, &GUID_WICPixelFormat16bppBGRA5551, sizeof(GUID));
533 break;
534 default:
535 FIXME("Unhandled 16-bit attribute type %u\n", attribute_type);
536 return E_NOTIMPL;
537 }
538 break;
539 case 24:
540 memcpy(pPixelFormat, &GUID_WICPixelFormat24bppBGR, sizeof(GUID));
541 break;
542 case 32:
543 switch (attribute_type)
544 {
545 case ATTRIBUTE_NO_ALPHA:
546 case ATTRIBUTE_UNDEFINED:
547 case ATTRIBUTE_UNDEFINED_PRESERVE:
548 memcpy(pPixelFormat, &GUID_WICPixelFormat32bppBGR, sizeof(GUID));
549 break;
550 case ATTRIBUTE_ALPHA:
551 memcpy(pPixelFormat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
552 break;
553 case ATTRIBUTE_PALPHA:
554 memcpy(pPixelFormat, &GUID_WICPixelFormat32bppPBGRA, sizeof(GUID));
555 break;
556 default:
557 FIXME("Unhandled 32-bit attribute type %u\n", attribute_type);
558 return E_NOTIMPL;
559 }
560 break;
561 default:
562 FIXME("Unhandled truecolor depth %u\n", This->header.depth);
563 return E_NOTIMPL;
564 }
565 break;
566 case IMAGETYPE_GRAYSCALE:
567 switch (This->header.depth)
568 {
569 case 8:
570 memcpy(pPixelFormat, &GUID_WICPixelFormat8bppGray, sizeof(GUID));
571 break;
572 case 16:
573 memcpy(pPixelFormat, &GUID_WICPixelFormat16bppGray, sizeof(GUID));
574 break;
575 default:
576 FIXME("Unhandled grayscale depth %u\n", This->header.depth);
577 return E_NOTIMPL;
578 }
579 break;
580 default:
581 ERR("Unknown image type %u\n", This->header.image_type);
582 return E_FAIL;
583 }
584
585 return S_OK;
586 }
587
588 static HRESULT WINAPI TgaDecoder_Frame_GetResolution(IWICBitmapFrameDecode *iface,
589 double *pDpiX, double *pDpiY)
590 {
591 FIXME("(%p,%p,%p): stub\n", iface, pDpiX, pDpiY);
592 return E_NOTIMPL;
593 }
594
595 static HRESULT WINAPI TgaDecoder_Frame_CopyPalette(IWICBitmapFrameDecode *iface,
596 IWICPalette *pIPalette)
597 {
598 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
599 HRESULT hr=S_OK;
600 WICColor colors[256], *color;
601 BYTE *colormap_data;
602 WORD *wcolormap_data;
603 DWORD *dwcolormap_data;
604 LARGE_INTEGER seek;
605 ULONG bytesread;
606 int depth, attribute_bitcount, attribute_type;
607 int i;
608
609 TRACE("(%p,%p)\n", iface, pIPalette);
610
611 if (!This->colormap_length)
612 {
613 WARN("no colormap present in this file\n");
614 return WINCODEC_ERR_PALETTEUNAVAILABLE;
615 }
616
617 if (This->header.colormap_firstentry + This->header.colormap_length > 256)
618 {
619 FIXME("cannot read colormap with %i entries starting at %i\n",
620 This->header.colormap_firstentry + This->header.colormap_length,
621 This->header.colormap_firstentry);
622 return E_FAIL;
623 }
624
625 colormap_data = HeapAlloc(GetProcessHeap(), 0, This->colormap_length);
626 if (!colormap_data) return E_OUTOFMEMORY;
627
628 wcolormap_data = (WORD*)colormap_data;
629 dwcolormap_data = (DWORD*)colormap_data;
630
631 EnterCriticalSection(&This->lock);
632
633 seek.QuadPart = This->colormap_offset;
634 hr = IStream_Seek(This->stream, seek, STREAM_SEEK_SET, NULL);
635
636 if (SUCCEEDED(hr))
637 {
638 hr = IStream_Read(This->stream, colormap_data, This->colormap_length, &bytesread);
639 if (SUCCEEDED(hr) && bytesread != This->colormap_length)
640 {
641 WARN("expected %i bytes in colormap, got %i\n", This->colormap_length, bytesread);
642 hr = E_FAIL;
643 }
644 }
645
646 LeaveCriticalSection(&This->lock);
647
648 if (SUCCEEDED(hr))
649 {
650 attribute_bitcount = This->header.image_descriptor & IMAGE_ATTRIBUTE_BITCOUNT_MASK;
651
652 if (attribute_bitcount && This->extension_area_offset)
653 attribute_type = This->extension_area.attributes_type;
654 else if (attribute_bitcount)
655 attribute_type = ATTRIBUTE_ALPHA;
656 else
657 attribute_type = ATTRIBUTE_NO_ALPHA;
658
659 depth = This->header.colormap_entrysize;
660 if (depth == 15)
661 {
662 depth = 16;
663 attribute_type = ATTRIBUTE_NO_ALPHA;
664 }
665
666 memset(colors, 0, sizeof(colors));
667
668 color = &colors[This->header.colormap_firstentry];
669
670 /* Colormap entries can be in any truecolor format, and we have to convert them. */
671 switch (depth)
672 {
673 case 16:
674 switch (attribute_type)
675 {
676 case ATTRIBUTE_NO_ALPHA:
677 case ATTRIBUTE_UNDEFINED:
678 case ATTRIBUTE_UNDEFINED_PRESERVE:
679 for (i=0; i<This->header.colormap_length; i++)
680 {
681 WORD srcval = wcolormap_data[i];
682 *color++=0xff000000 | /* constant 255 alpha */
683 ((srcval << 9) & 0xf80000) | /* r */
684 ((srcval << 4) & 0x070000) | /* r - 3 bits */
685 ((srcval << 6) & 0x00f800) | /* g */
686 ((srcval << 1) & 0x000700) | /* g - 3 bits */
687 ((srcval << 3) & 0x0000f8) | /* b */
688 ((srcval >> 2) & 0x000007); /* b - 3 bits */
689 }
690 break;
691 case ATTRIBUTE_ALPHA:
692 case ATTRIBUTE_PALPHA:
693 for (i=0; i<This->header.colormap_length; i++)
694 {
695 WORD srcval = wcolormap_data[i];
696 *color++=((srcval & 0x8000) ? 0xff000000 : 0) | /* alpha */
697 ((srcval << 9) & 0xf80000) | /* r */
698 ((srcval << 4) & 0x070000) | /* r - 3 bits */
699 ((srcval << 6) & 0x00f800) | /* g */
700 ((srcval << 1) & 0x000700) | /* g - 3 bits */
701 ((srcval << 3) & 0x0000f8) | /* b */
702 ((srcval >> 2) & 0x000007); /* b - 3 bits */
703 }
704 break;
705 default:
706 FIXME("Unhandled 16-bit attribute type %u\n", attribute_type);
707 hr = E_NOTIMPL;
708 }
709 break;
710 case 24:
711 for (i=0; i<This->header.colormap_length; i++)
712 {
713 *color++=0xff000000 | /* alpha */
714 colormap_data[i*3+2] | /* red */
715 colormap_data[i*3+1] | /* green */
716 colormap_data[i*3]; /* blue */
717 }
718 break;
719 case 32:
720 switch (attribute_type)
721 {
722 case ATTRIBUTE_NO_ALPHA:
723 case ATTRIBUTE_UNDEFINED:
724 case ATTRIBUTE_UNDEFINED_PRESERVE:
725 for (i=0; i<This->header.colormap_length; i++)
726 *color++=dwcolormap_data[i]|0xff000000;
727 break;
728 case ATTRIBUTE_ALPHA:
729 for (i=0; i<This->header.colormap_length; i++)
730 *color++=dwcolormap_data[i];
731 break;
732 case ATTRIBUTE_PALPHA:
733 /* FIXME: Unpremultiply alpha */
734 default:
735 FIXME("Unhandled 16-bit attribute type %u\n", attribute_type);
736 hr = E_NOTIMPL;
737 }
738 break;
739 default:
740 FIXME("Unhandled truecolor depth %u\n", This->header.depth);
741 hr = E_NOTIMPL;
742 }
743 }
744
745 HeapFree(GetProcessHeap(), 0, colormap_data);
746
747 if (SUCCEEDED(hr))
748 hr = IWICPalette_InitializeCustom(pIPalette, colors, 256);
749
750 return hr;
751 }
752
753 static HRESULT TgaDecoder_ReadRLE(TgaDecoder *This, BYTE *imagebits, int datasize)
754 {
755 int i=0, j, bytesperpixel;
756 ULONG bytesread;
757 HRESULT hr=S_OK;
758
759 bytesperpixel = This->header.depth / 8;
760
761 while (i<datasize)
762 {
763 BYTE rc;
764 int count, size;
765 BYTE pixeldata[4];
766
767 hr = IStream_Read(This->stream, &rc, 1, &bytesread);
768 if (bytesread != 1) hr = E_FAIL;
769 if (FAILED(hr)) break;
770
771 count = (rc&0x7f)+1;
772 size = count * bytesperpixel;
773
774 if (size + i > datasize)
775 {
776 WARN("RLE packet too large\n");
777 hr = E_FAIL;
778 break;
779 }
780
781 if (rc&0x80)
782 {
783 /* Run-length packet */
784 hr = IStream_Read(This->stream, pixeldata, bytesperpixel, &bytesread);
785 if (bytesread != bytesperpixel) hr = E_FAIL;
786 if (FAILED(hr)) break;
787
788 if (bytesperpixel == 1)
789 memset(&imagebits[i], pixeldata[0], count);
790 else
791 {
792 for (j=0; j<count; j++)
793 memcpy(&imagebits[i+j*bytesperpixel], pixeldata, bytesperpixel);
794 }
795 }
796 else
797 {
798 /* Raw packet */
799 hr = IStream_Read(This->stream, &imagebits[i], size, &bytesread);
800 if (bytesread != size) hr = E_FAIL;
801 if (FAILED(hr)) break;
802 }
803
804 i += size;
805 }
806
807 return hr;
808 }
809
810 static HRESULT TgaDecoder_ReadImage(TgaDecoder *This)
811 {
812 HRESULT hr=S_OK;
813 int datasize;
814 LARGE_INTEGER seek;
815 ULONG bytesread;
816
817 if (This->imagebits)
818 return S_OK;
819
820 EnterCriticalSection(&This->lock);
821
822 if (!This->imagebits)
823 {
824 if (This->header.image_descriptor & IMAGE_RIGHTTOLEFT)
825 {
826 FIXME("Right to left image reading not implemented\n");
827 hr = E_NOTIMPL;
828 }
829
830 if (SUCCEEDED(hr))
831 {
832 datasize = This->header.width * This->header.height * (This->header.depth / 8);
833 This->imagebits = HeapAlloc(GetProcessHeap(), 0, datasize);
834 if (!This->imagebits) hr = E_OUTOFMEMORY;
835 }
836
837 if (SUCCEEDED(hr))
838 {
839 seek.QuadPart = This->image_offset;
840 hr = IStream_Seek(This->stream, seek, STREAM_SEEK_SET, NULL);
841 }
842
843 if (SUCCEEDED(hr))
844 {
845 if (This->header.image_type & IMAGETYPE_RLE)
846 {
847 hr = TgaDecoder_ReadRLE(This, This->imagebits, datasize);
848 }
849 else
850 {
851 hr = IStream_Read(This->stream, This->imagebits, datasize, &bytesread);
852 if (SUCCEEDED(hr) && bytesread != datasize)
853 hr = E_FAIL;
854 }
855 }
856
857 if (SUCCEEDED(hr))
858 {
859 if (This->header.image_descriptor & IMAGE_TOPTOBOTTOM)
860 {
861 This->origin = This->imagebits;
862 This->stride = This->header.width * (This->header.depth / 8);
863 }
864 else
865 {
866 This->stride = -This->header.width * (This->header.depth / 8);
867 This->origin = This->imagebits + This->header.width * (This->header.height - 1) * (This->header.depth / 8);
868 }
869 }
870 else
871 {
872 HeapFree(GetProcessHeap(), 0, This->imagebits);
873 This->imagebits = NULL;
874 }
875 }
876
877 LeaveCriticalSection(&This->lock);
878
879 return hr;
880 }
881
882 static HRESULT WINAPI TgaDecoder_Frame_CopyPixels(IWICBitmapFrameDecode *iface,
883 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
884 {
885 TgaDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
886 HRESULT hr;
887
888 TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
889
890 hr = TgaDecoder_ReadImage(This);
891
892 if (SUCCEEDED(hr))
893 {
894 hr = copy_pixels(This->header.depth, This->origin,
895 This->header.width, This->header.height, This->stride,
896 prc, cbStride, cbBufferSize, pbBuffer);
897 }
898
899 return hr;
900 }
901
902 static HRESULT WINAPI TgaDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
903 IWICMetadataQueryReader **ppIMetadataQueryReader)
904 {
905 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
906 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
907 }
908
909 static HRESULT WINAPI TgaDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode *iface,
910 UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
911 {
912 FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
913 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
914 }
915
916 static HRESULT WINAPI TgaDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode *iface,
917 IWICBitmapSource **ppIThumbnail)
918 {
919 FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
920 return WINCODEC_ERR_CODECNOTHUMBNAIL;
921 }
922
923 static const IWICBitmapFrameDecodeVtbl TgaDecoder_Frame_Vtbl = {
924 TgaDecoder_Frame_QueryInterface,
925 TgaDecoder_Frame_AddRef,
926 TgaDecoder_Frame_Release,
927 TgaDecoder_Frame_GetSize,
928 TgaDecoder_Frame_GetPixelFormat,
929 TgaDecoder_Frame_GetResolution,
930 TgaDecoder_Frame_CopyPalette,
931 TgaDecoder_Frame_CopyPixels,
932 TgaDecoder_Frame_GetMetadataQueryReader,
933 TgaDecoder_Frame_GetColorContexts,
934 TgaDecoder_Frame_GetThumbnail
935 };
936
937 HRESULT TgaDecoder_CreateInstance(REFIID iid, void** ppv)
938 {
939 TgaDecoder *This;
940 HRESULT ret;
941
942 TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
943
944 *ppv = NULL;
945
946 This = HeapAlloc(GetProcessHeap(), 0, sizeof(TgaDecoder));
947 if (!This) return E_OUTOFMEMORY;
948
949 This->IWICBitmapDecoder_iface.lpVtbl = &TgaDecoder_Vtbl;
950 This->IWICBitmapFrameDecode_iface.lpVtbl = &TgaDecoder_Frame_Vtbl;
951 This->ref = 1;
952 This->initialized = FALSE;
953 This->stream = NULL;
954 This->imagebits = NULL;
955 InitializeCriticalSection(&This->lock);
956 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TgaDecoder.lock");
957
958 ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
959 IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
960
961 return ret;
962 }