wininet: Store hostname for secure connection in its SSL context.
[wine] / dlls / windowscodecs / gifformat.c
1 /*
2  * Copyright 2009 Vincent Povirk for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "objbase.h"
28 #include "wincodec.h"
29
30 #include "ungif.h"
31
32 #include "wincodecs_private.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
37
38 typedef struct {
39     const IWICBitmapDecoderVtbl *lpVtbl;
40     LONG ref;
41     BOOL initialized;
42     GifFileType *gif;
43 } GifDecoder;
44
45 typedef struct {
46     const IWICBitmapFrameDecodeVtbl *lpVtbl;
47     LONG ref;
48     SavedImage *frame;
49     GifDecoder *parent;
50 } GifFrameDecode;
51
52 static HRESULT WINAPI GifFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
53     void **ppv)
54 {
55     GifFrameDecode *This = (GifFrameDecode*)iface;
56     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
57
58     if (!ppv) return E_INVALIDARG;
59
60     if (IsEqualIID(&IID_IUnknown, iid) ||
61         IsEqualIID(&IID_IWICBitmapSource, iid) ||
62         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
63     {
64         *ppv = This;
65     }
66     else
67     {
68         *ppv = NULL;
69         return E_NOINTERFACE;
70     }
71
72     IUnknown_AddRef((IUnknown*)*ppv);
73     return S_OK;
74 }
75
76 static ULONG WINAPI GifFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
77 {
78     GifFrameDecode *This = (GifFrameDecode*)iface;
79     ULONG ref = InterlockedIncrement(&This->ref);
80
81     TRACE("(%p) refcount=%u\n", iface, ref);
82
83     return ref;
84 }
85
86 static ULONG WINAPI GifFrameDecode_Release(IWICBitmapFrameDecode *iface)
87 {
88     GifFrameDecode *This = (GifFrameDecode*)iface;
89     ULONG ref = InterlockedDecrement(&This->ref);
90
91     TRACE("(%p) refcount=%u\n", iface, ref);
92
93     if (ref == 0)
94     {
95         IUnknown_Release((IUnknown*)This->parent);
96         HeapFree(GetProcessHeap(), 0, This);
97     }
98
99     return ref;
100 }
101
102 static HRESULT WINAPI GifFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
103     UINT *puiWidth, UINT *puiHeight)
104 {
105     GifFrameDecode *This = (GifFrameDecode*)iface;
106     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
107
108     *puiWidth = This->frame->ImageDesc.Width;
109     *puiHeight = This->frame->ImageDesc.Height;
110
111     return S_OK;
112 }
113
114 static HRESULT WINAPI GifFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
115     WICPixelFormatGUID *pPixelFormat)
116 {
117     memcpy(pPixelFormat, &GUID_WICPixelFormat8bppIndexed, sizeof(GUID));
118
119     return S_OK;
120 }
121
122 static HRESULT WINAPI GifFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
123     double *pDpiX, double *pDpiY)
124 {
125     FIXME("(%p,%p,%p): stub\n", iface, pDpiX, pDpiY);
126     return E_NOTIMPL;
127 }
128
129 static HRESULT WINAPI GifFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
130     IWICPalette *pIPalette)
131 {
132     GifFrameDecode *This = (GifFrameDecode*)iface;
133     WICColor colors[256];
134     ColorMapObject *cm = This->frame->ImageDesc.ColorMap;
135     int i, trans;
136     ExtensionBlock *eb;
137     TRACE("(%p,%p)\n", iface, pIPalette);
138
139     if (!cm) cm = This->parent->gif->SColorMap;
140
141     if (cm->ColorCount > 256)
142     {
143         ERR("GIF contains %i colors???\n", cm->ColorCount);
144         return E_FAIL;
145     }
146
147     for (i = 0; i < cm->ColorCount; i++) {
148         colors[i] = 0xff000000| /* alpha */
149                     cm->Colors[i].Red << 16|
150                     cm->Colors[i].Green << 8|
151                     cm->Colors[i].Blue;
152     }
153
154     /* look for the transparent color extension */
155     for (i = 0; i < This->frame->ExtensionBlockCount; ++i) {
156         eb = This->frame->ExtensionBlocks + i;
157         if (eb->Function == 0xF9 && eb->ByteCount == 4) {
158             if ((eb->Bytes[0] & 1) == 1) {
159                 trans = (unsigned char)eb->Bytes[3];
160                 colors[trans] &= 0xffffff; /* set alpha to 0 */
161                 break;
162             }
163         }
164     }
165
166     IWICPalette_InitializeCustom(pIPalette, colors, cm->ColorCount);
167
168     return S_OK;
169 }
170
171 static HRESULT copy_interlaced_pixels(const BYTE *srcbuffer,
172     UINT srcwidth, UINT srcheight, INT srcstride, const WICRect *rc,
173     UINT dststride, UINT dstbuffersize, BYTE *dstbuffer)
174 {
175     UINT row_offset; /* number of bytes into the source rows where the data starts */
176     const BYTE *src;
177     BYTE *dst;
178     UINT y;
179
180     if (rc->X < 0 || rc->Y < 0 || rc->X+rc->Width > srcwidth || rc->Y+rc->Height > srcheight)
181         return E_INVALIDARG;
182
183     if (dststride < rc->Width)
184         return E_INVALIDARG;
185
186     if ((dststride * rc->Height) > dstbuffersize)
187         return E_INVALIDARG;
188
189     row_offset = rc->X;
190
191     dst = dstbuffer;
192     for (y=rc->Y; y-rc->Y < rc->Height; y++)
193     {
194         if (y%8 == 0)
195             src = srcbuffer + srcstride * (y/8);
196         else if (y%4 == 0)
197             src = srcbuffer + srcstride * ((srcheight+7)/8 + y/8);
198         else if (y%2 == 0)
199             src = srcbuffer + srcstride * ((srcheight+3)/4 + y/4);
200         else /* y%2 == 1 */
201             src = srcbuffer + srcstride * ((srcheight+1)/2 + y/2);
202         src += row_offset;
203         memcpy(dst, src, rc->Width);
204         dst += dststride;
205     }
206     return S_OK;
207 }
208
209 static HRESULT WINAPI GifFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
210     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
211 {
212     GifFrameDecode *This = (GifFrameDecode*)iface;
213     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
214
215     if (This->frame->ImageDesc.Interlace)
216     {
217         return copy_interlaced_pixels(This->frame->RasterBits, This->frame->ImageDesc.Width,
218             This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
219             prc, cbStride, cbBufferSize, pbBuffer);
220     }
221     else
222     {
223         return copy_pixels(8, This->frame->RasterBits, This->frame->ImageDesc.Width,
224             This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
225             prc, cbStride, cbBufferSize, pbBuffer);
226     }
227 }
228
229 static HRESULT WINAPI GifFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
230     IWICMetadataQueryReader **ppIMetadataQueryReader)
231 {
232     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
233     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
234 }
235
236 static HRESULT WINAPI GifFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
237     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
238 {
239     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
240     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
241 }
242
243 static HRESULT WINAPI GifFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
244     IWICBitmapSource **ppIThumbnail)
245 {
246     TRACE("(%p,%p)\n", iface, ppIThumbnail);
247     return WINCODEC_ERR_CODECNOTHUMBNAIL;
248 }
249
250 static const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl = {
251     GifFrameDecode_QueryInterface,
252     GifFrameDecode_AddRef,
253     GifFrameDecode_Release,
254     GifFrameDecode_GetSize,
255     GifFrameDecode_GetPixelFormat,
256     GifFrameDecode_GetResolution,
257     GifFrameDecode_CopyPalette,
258     GifFrameDecode_CopyPixels,
259     GifFrameDecode_GetMetadataQueryReader,
260     GifFrameDecode_GetColorContexts,
261     GifFrameDecode_GetThumbnail
262 };
263
264 static HRESULT WINAPI GifDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
265     void **ppv)
266 {
267     GifDecoder *This = (GifDecoder*)iface;
268     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
269
270     if (!ppv) return E_INVALIDARG;
271
272     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
273     {
274         *ppv = This;
275     }
276     else
277     {
278         *ppv = NULL;
279         return E_NOINTERFACE;
280     }
281
282     IUnknown_AddRef((IUnknown*)*ppv);
283     return S_OK;
284 }
285
286 static ULONG WINAPI GifDecoder_AddRef(IWICBitmapDecoder *iface)
287 {
288     GifDecoder *This = (GifDecoder*)iface;
289     ULONG ref = InterlockedIncrement(&This->ref);
290
291     TRACE("(%p) refcount=%u\n", iface, ref);
292
293     return ref;
294 }
295
296 static ULONG WINAPI GifDecoder_Release(IWICBitmapDecoder *iface)
297 {
298     GifDecoder *This = (GifDecoder*)iface;
299     ULONG ref = InterlockedDecrement(&This->ref);
300
301     TRACE("(%p) refcount=%u\n", iface, ref);
302
303     if (ref == 0)
304     {
305         DGifCloseFile(This->gif);
306         HeapFree(GetProcessHeap(), 0, This);
307     }
308
309     return ref;
310 }
311
312 static HRESULT WINAPI GifDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
313     DWORD *pdwCapability)
314 {
315     FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
316     return E_NOTIMPL;
317 }
318
319 static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len) {
320     IStream *stream = gif->UserData;
321     ULONG bytesread;
322     HRESULT hr;
323
324     if (!stream)
325     {
326         ERR("attempting to read file after initialization\n");
327         return 0;
328     }
329
330     hr = IStream_Read(stream, data, len, &bytesread);
331     if (hr != S_OK) bytesread = 0;
332     return bytesread;
333 }
334
335 static HRESULT WINAPI GifDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
336     WICDecodeOptions cacheOptions)
337 {
338     GifDecoder *This = (GifDecoder*)iface;
339     LARGE_INTEGER seek;
340     int ret;
341
342     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
343
344     if (This->initialized || This->gif)
345     {
346         WARN("already initialized\n");
347         return WINCODEC_ERR_WRONGSTATE;
348     }
349
350     /* seek to start of stream */
351     seek.QuadPart = 0;
352     IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
353
354     /* read all data from the stream */
355     This->gif = DGifOpen((void*)pIStream, _gif_inputfunc);
356     if (!This->gif) return E_FAIL;
357
358     ret = DGifSlurp(This->gif);
359     if (ret == GIF_ERROR) return E_FAIL;
360
361     /* make sure we don't use the stream after this method returns */
362     This->gif->UserData = NULL;
363
364     This->initialized = TRUE;
365
366     return S_OK;
367 }
368
369 static HRESULT WINAPI GifDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
370     GUID *pguidContainerFormat)
371 {
372     memcpy(pguidContainerFormat, &GUID_ContainerFormatGif, sizeof(GUID));
373     return S_OK;
374 }
375
376 static HRESULT WINAPI GifDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
377     IWICBitmapDecoderInfo **ppIDecoderInfo)
378 {
379     HRESULT hr;
380     IWICComponentInfo *compinfo;
381
382     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
383
384     hr = CreateComponentInfo(&CLSID_WICGifDecoder, &compinfo);
385     if (FAILED(hr)) return hr;
386
387     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
388         (void**)ppIDecoderInfo);
389
390     IWICComponentInfo_Release(compinfo);
391
392     return hr;
393 }
394
395 static HRESULT WINAPI GifDecoder_CopyPalette(IWICBitmapDecoder *iface,
396     IWICPalette *pIPalette)
397 {
398     TRACE("(%p,%p)\n", iface, pIPalette);
399     return WINCODEC_ERR_PALETTEUNAVAILABLE;
400 }
401
402 static HRESULT WINAPI GifDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
403     IWICMetadataQueryReader **ppIMetadataQueryReader)
404 {
405     TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
406     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
407 }
408
409 static HRESULT WINAPI GifDecoder_GetPreview(IWICBitmapDecoder *iface,
410     IWICBitmapSource **ppIBitmapSource)
411 {
412     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
413     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
414 }
415
416 static HRESULT WINAPI GifDecoder_GetColorContexts(IWICBitmapDecoder *iface,
417     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
418 {
419     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
420     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
421 }
422
423 static HRESULT WINAPI GifDecoder_GetThumbnail(IWICBitmapDecoder *iface,
424     IWICBitmapSource **ppIThumbnail)
425 {
426     TRACE("(%p,%p)\n", iface, ppIThumbnail);
427     return WINCODEC_ERR_CODECNOTHUMBNAIL;
428 }
429
430 static HRESULT WINAPI GifDecoder_GetFrameCount(IWICBitmapDecoder *iface,
431     UINT *pCount)
432 {
433     GifDecoder *This = (GifDecoder*)iface;
434     TRACE("(%p,%p)\n", iface, pCount);
435
436     if (!This->initialized) return WINCODEC_ERR_NOTINITIALIZED;
437
438     *pCount = This->gif->ImageCount;
439
440     TRACE("<- %u\n", *pCount);
441
442     return S_OK;
443 }
444
445 static HRESULT WINAPI GifDecoder_GetFrame(IWICBitmapDecoder *iface,
446     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
447 {
448     GifDecoder *This = (GifDecoder*)iface;
449     GifFrameDecode *result;
450     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
451
452     if (!This->initialized) return WINCODEC_ERR_NOTINITIALIZED;
453
454     if (index >= This->gif->ImageCount) return E_INVALIDARG;
455
456     result = HeapAlloc(GetProcessHeap(), 0, sizeof(GifFrameDecode));
457     if (!result) return E_OUTOFMEMORY;
458
459     result->lpVtbl = &GifFrameDecode_Vtbl;
460     result->ref = 1;
461     result->frame = &This->gif->SavedImages[index];
462     IWICBitmapDecoder_AddRef(iface);
463     result->parent = This;
464
465     *ppIBitmapFrame = (IWICBitmapFrameDecode*)result;
466
467     return S_OK;
468 }
469
470 static const IWICBitmapDecoderVtbl GifDecoder_Vtbl = {
471     GifDecoder_QueryInterface,
472     GifDecoder_AddRef,
473     GifDecoder_Release,
474     GifDecoder_QueryCapability,
475     GifDecoder_Initialize,
476     GifDecoder_GetContainerFormat,
477     GifDecoder_GetDecoderInfo,
478     GifDecoder_CopyPalette,
479     GifDecoder_GetMetadataQueryReader,
480     GifDecoder_GetPreview,
481     GifDecoder_GetColorContexts,
482     GifDecoder_GetThumbnail,
483     GifDecoder_GetFrameCount,
484     GifDecoder_GetFrame
485 };
486
487 HRESULT GifDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
488 {
489     GifDecoder *This;
490     HRESULT ret;
491
492     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
493
494     *ppv = NULL;
495
496     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
497
498     This = HeapAlloc(GetProcessHeap(), 0, sizeof(GifDecoder));
499     if (!This) return E_OUTOFMEMORY;
500
501     This->lpVtbl = &GifDecoder_Vtbl;
502     This->ref = 1;
503     This->initialized = FALSE;
504     This->gif = NULL;
505
506     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
507     IUnknown_Release((IUnknown*)This);
508
509     return ret;
510 }