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