wined3d: The ARB loop unroller's iteration is unsigned.
[wine] / dlls / windowscodecs / bmpencode.c
1 /*
2  * Copyright 2009 Vincent Povirk for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winreg.h"
28 #include "wingdi.h"
29 #include "objbase.h"
30 #include "wincodec.h"
31
32 #include "wincodecs_private.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
37
38 struct bmp_pixelformat {
39     const WICPixelFormatGUID *guid;
40     UINT bpp;
41     DWORD compression;
42     DWORD redmask;
43     DWORD greenmask;
44     DWORD bluemask;
45     DWORD alphamask;
46 };
47
48 static const struct bmp_pixelformat formats[] = {
49     {&GUID_WICPixelFormat24bppBGR, 24, BI_RGB},
50     {&GUID_WICPixelFormat16bppBGR555, 16, BI_RGB},
51     {&GUID_WICPixelFormat16bppBGR565, 16, BI_BITFIELDS, 0xf800, 0x7e0, 0x1f, 0},
52     {&GUID_WICPixelFormat32bppBGR, 32, BI_RGB},
53 #if 0
54     /* Windows doesn't seem to support this one. */
55     {&GUID_WICPixelFormat32bppBGRA, 32, BI_BITFIELDS, 0xff0000, 0xff00, 0xff, 0xff000000},
56 #endif
57     {NULL}
58 };
59
60 typedef struct BmpFrameEncode {
61     const IWICBitmapFrameEncodeVtbl *lpVtbl;
62     LONG ref;
63     IStream *stream;
64     BOOL initialized;
65     UINT width, height;
66     BYTE *bits;
67     const struct bmp_pixelformat *format;
68     double xres, yres;
69     UINT lineswritten;
70     UINT stride;
71     BOOL committed;
72 } BmpFrameEncode;
73
74 static HRESULT WINAPI BmpFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
75     void **ppv)
76 {
77     BmpFrameEncode *This = (BmpFrameEncode*)iface;
78     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
79
80     if (!ppv) return E_INVALIDARG;
81
82     if (IsEqualIID(&IID_IUnknown, iid) ||
83         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
84     {
85         *ppv = This;
86     }
87     else
88     {
89         *ppv = NULL;
90         return E_NOINTERFACE;
91     }
92
93     IUnknown_AddRef((IUnknown*)*ppv);
94     return S_OK;
95 }
96
97 static ULONG WINAPI BmpFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
98 {
99     BmpFrameEncode *This = (BmpFrameEncode*)iface;
100     ULONG ref = InterlockedIncrement(&This->ref);
101
102     TRACE("(%p) refcount=%u\n", iface, ref);
103
104     return ref;
105 }
106
107 static ULONG WINAPI BmpFrameEncode_Release(IWICBitmapFrameEncode *iface)
108 {
109     BmpFrameEncode *This = (BmpFrameEncode*)iface;
110     ULONG ref = InterlockedDecrement(&This->ref);
111
112     TRACE("(%p) refcount=%u\n", iface, ref);
113
114     if (ref == 0)
115     {
116         if (This->stream) IStream_Release(This->stream);
117         HeapFree(GetProcessHeap(), 0, This->bits);
118         HeapFree(GetProcessHeap(), 0, This);
119     }
120
121     return ref;
122 }
123
124 static HRESULT WINAPI BmpFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
125     IPropertyBag2 *pIEncoderOptions)
126 {
127     BmpFrameEncode *This = (BmpFrameEncode*)iface;
128     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
129
130     if (This->initialized) return WINCODEC_ERR_WRONGSTATE;
131
132     This->initialized = TRUE;
133
134     return S_OK;
135 }
136
137 static HRESULT WINAPI BmpFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
138     UINT uiWidth, UINT uiHeight)
139 {
140     BmpFrameEncode *This = (BmpFrameEncode*)iface;
141     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
142
143     if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
144
145     This->width = uiWidth;
146     This->height = uiHeight;
147
148     return S_OK;
149 }
150
151 static HRESULT WINAPI BmpFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
152     double dpiX, double dpiY)
153 {
154     BmpFrameEncode *This = (BmpFrameEncode*)iface;
155     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
156
157     if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
158
159     This->xres = dpiX;
160     This->yres = dpiY;
161
162     return S_OK;
163 }
164
165 static HRESULT WINAPI BmpFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
166     WICPixelFormatGUID *pPixelFormat)
167 {
168     BmpFrameEncode *This = (BmpFrameEncode*)iface;
169     int i;
170     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
171
172     if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
173
174     for (i=0; formats[i].guid; i++)
175     {
176         if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
177             break;
178     }
179
180     if (!formats[i].guid) i = 0;
181
182     This->format = &formats[i];
183     memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
184
185     return S_OK;
186 }
187
188 static HRESULT WINAPI BmpFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
189     UINT cCount, IWICColorContext **ppIColorContext)
190 {
191     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
192     return E_NOTIMPL;
193 }
194
195 static HRESULT WINAPI BmpFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
196     IWICPalette *pIPalette)
197 {
198     FIXME("(%p,%p): stub\n", iface, pIPalette);
199     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
200 }
201
202 static HRESULT WINAPI BmpFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
203     IWICBitmapSource *pIThumbnail)
204 {
205     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
206     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
207 }
208
209 static HRESULT BmpFrameEncode_AllocateBits(BmpFrameEncode *This)
210 {
211     if (!This->bits)
212     {
213         if (!This->initialized || !This->width || !This->height || !This->format)
214             return WINCODEC_ERR_WRONGSTATE;
215
216         This->stride = (((This->width * This->format->bpp)+31)/32)*4;
217         This->bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->stride * This->height);
218         if (!This->bits) return E_OUTOFMEMORY;
219     }
220
221     return S_OK;
222 }
223
224 static HRESULT WINAPI BmpFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
225     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
226 {
227     BmpFrameEncode *This = (BmpFrameEncode*)iface;
228     HRESULT hr;
229     WICRect rc;
230     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
231
232     if (!This->initialized || !This->width || !This->height || !This->format)
233         return WINCODEC_ERR_WRONGSTATE;
234
235     hr = BmpFrameEncode_AllocateBits(This);
236     if (FAILED(hr)) return hr;
237
238     rc.X = 0;
239     rc.Y = 0;
240     rc.Width = This->width;
241     rc.Height = lineCount;
242
243     hr = copy_pixels(This->format->bpp, pbPixels, This->width, lineCount, cbStride,
244         &rc, This->stride, This->stride*(This->height-This->lineswritten),
245         This->bits + This->stride*This->lineswritten);
246
247     if (SUCCEEDED(hr))
248         This->lineswritten += lineCount;
249
250     return hr;
251 }
252
253 static HRESULT WINAPI BmpFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
254     IWICBitmapSource *pIBitmapSource, WICRect *prc)
255 {
256     BmpFrameEncode *This = (BmpFrameEncode*)iface;
257     HRESULT hr;
258     WICRect rc;
259     WICPixelFormatGUID guid;
260     TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
261
262     if (!This->initialized || !This->width || !This->height)
263         return WINCODEC_ERR_WRONGSTATE;
264
265     if (!This->format)
266     {
267         hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
268         if (FAILED(hr)) return hr;
269         hr = BmpFrameEncode_SetPixelFormat(iface, &guid);
270         if (FAILED(hr)) return hr;
271     }
272
273     hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
274     if (FAILED(hr)) return hr;
275     if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
276     {
277         /* should use WICConvertBitmapSource to convert, but that's unimplemented */
278         ERR("format %s unsupported\n", debugstr_guid(&guid));
279         return E_FAIL;
280     }
281
282     if (This->xres == 0.0 || This->yres == 0.0)
283     {
284         double xres, yres;
285         hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
286         if (FAILED(hr)) return hr;
287         hr = BmpFrameEncode_SetResolution(iface, xres, yres);
288         if (FAILED(hr)) return hr;
289     }
290
291     if (!prc)
292     {
293         UINT width, height;
294         hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
295         if (FAILED(hr)) return hr;
296         rc.X = 0;
297         rc.Y = 0;
298         rc.Width = width;
299         rc.Height = height;
300         prc = &rc;
301     }
302
303     if (prc->Width != This->width) return E_INVALIDARG;
304
305     hr = BmpFrameEncode_AllocateBits(This);
306     if (FAILED(hr)) return hr;
307
308     hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, This->stride,
309         This->stride*(This->height-This->lineswritten),
310         This->bits + This->stride*This->lineswritten);
311
312     This->lineswritten += rc.Height;
313
314     return S_OK;
315 }
316
317 static HRESULT WINAPI BmpFrameEncode_Commit(IWICBitmapFrameEncode *iface)
318 {
319     BmpFrameEncode *This = (BmpFrameEncode*)iface;
320     BITMAPFILEHEADER bfh;
321     BITMAPV5HEADER bih;
322     UINT info_size;
323     LARGE_INTEGER pos;
324     ULONG byteswritten;
325     HRESULT hr;
326
327     TRACE("(%p)\n", iface);
328
329     if (!This->bits || This->committed || This->height != This->lineswritten)
330         return WINCODEC_ERR_WRONGSTATE;
331
332     bfh.bfType = 0x4d42; /* "BM" */
333     bfh.bfReserved1 = 0;
334     bfh.bfReserved2 = 0;
335
336     bih.bV5Size = info_size = sizeof(BITMAPINFOHEADER);
337     bih.bV5Width = This->width;
338     bih.bV5Height = -This->height; /* top-down bitmap */
339     bih.bV5Planes = 1;
340     bih.bV5BitCount = This->format->bpp;
341     bih.bV5Compression = This->format->compression;
342     bih.bV5SizeImage = This->stride*This->height;
343     bih.bV5XPelsPerMeter = (This->xres+0.0127) / 0.0254;
344     bih.bV5YPelsPerMeter = (This->yres+0.0127) / 0.0254;
345     bih.bV5ClrUsed = 0;
346     bih.bV5ClrImportant = 0;
347
348     if (This->format->compression == BI_BITFIELDS)
349     {
350         if (This->format->alphamask)
351             bih.bV5Size = info_size = sizeof(BITMAPV4HEADER);
352         else
353             info_size = sizeof(BITMAPINFOHEADER)+12;
354         bih.bV5RedMask = This->format->redmask;
355         bih.bV5GreenMask = This->format->greenmask;
356         bih.bV5BlueMask = This->format->bluemask;
357         bih.bV5AlphaMask = This->format->alphamask;
358         bih.bV5AlphaMask = LCS_DEVICE_RGB;
359     }
360
361     bfh.bfSize = sizeof(BITMAPFILEHEADER) + info_size + bih.bV5SizeImage;
362     bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + info_size;
363
364     pos.QuadPart = 0;
365     hr = IStream_Seek(This->stream, pos, STREAM_SEEK_SET, NULL);
366     if (FAILED(hr)) return hr;
367
368     hr = IStream_Write(This->stream, &bfh, sizeof(BITMAPFILEHEADER), &byteswritten);
369     if (FAILED(hr)) return hr;
370     if (byteswritten != sizeof(BITMAPFILEHEADER)) return E_FAIL;
371
372     hr = IStream_Write(This->stream, &bih, info_size, &byteswritten);
373     if (FAILED(hr)) return hr;
374     if (byteswritten != info_size) return E_FAIL;
375
376     hr = IStream_Write(This->stream, This->bits, bih.bV5SizeImage, &byteswritten);
377     if (FAILED(hr)) return hr;
378     if (byteswritten != bih.bV5SizeImage) return E_FAIL;
379
380     This->committed = TRUE;
381
382     return S_OK;
383 }
384
385 static HRESULT WINAPI BmpFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
386     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
387 {
388     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
389     return E_NOTIMPL;
390 }
391
392 static const IWICBitmapFrameEncodeVtbl BmpFrameEncode_Vtbl = {
393     BmpFrameEncode_QueryInterface,
394     BmpFrameEncode_AddRef,
395     BmpFrameEncode_Release,
396     BmpFrameEncode_Initialize,
397     BmpFrameEncode_SetSize,
398     BmpFrameEncode_SetResolution,
399     BmpFrameEncode_SetPixelFormat,
400     BmpFrameEncode_SetColorContexts,
401     BmpFrameEncode_SetPalette,
402     BmpFrameEncode_SetThumbnail,
403     BmpFrameEncode_WritePixels,
404     BmpFrameEncode_WriteSource,
405     BmpFrameEncode_Commit,
406     BmpFrameEncode_GetMetadataQueryWriter
407 };
408
409 typedef struct BmpEncoder {
410     const IWICBitmapEncoderVtbl *lpVtbl;
411     LONG ref;
412     IStream *stream;
413     IWICBitmapFrameEncode *frame;
414 } BmpEncoder;
415
416 static HRESULT WINAPI BmpEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
417     void **ppv)
418 {
419     BmpEncoder *This = (BmpEncoder*)iface;
420     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
421
422     if (!ppv) return E_INVALIDARG;
423
424     if (IsEqualIID(&IID_IUnknown, iid) ||
425         IsEqualIID(&IID_IWICBitmapEncoder, iid))
426     {
427         *ppv = This;
428     }
429     else
430     {
431         *ppv = NULL;
432         return E_NOINTERFACE;
433     }
434
435     IUnknown_AddRef((IUnknown*)*ppv);
436     return S_OK;
437 }
438
439 static ULONG WINAPI BmpEncoder_AddRef(IWICBitmapEncoder *iface)
440 {
441     BmpEncoder *This = (BmpEncoder*)iface;
442     ULONG ref = InterlockedIncrement(&This->ref);
443
444     TRACE("(%p) refcount=%u\n", iface, ref);
445
446     return ref;
447 }
448
449 static ULONG WINAPI BmpEncoder_Release(IWICBitmapEncoder *iface)
450 {
451     BmpEncoder *This = (BmpEncoder*)iface;
452     ULONG ref = InterlockedDecrement(&This->ref);
453
454     TRACE("(%p) refcount=%u\n", iface, ref);
455
456     if (ref == 0)
457     {
458         if (This->stream) IStream_Release(This->stream);
459         if (This->frame) IWICBitmapFrameEncode_Release(This->frame);
460         HeapFree(GetProcessHeap(), 0, This);
461     }
462
463     return ref;
464 }
465
466 static HRESULT WINAPI BmpEncoder_Initialize(IWICBitmapEncoder *iface,
467     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
468 {
469     BmpEncoder *This = (BmpEncoder*)iface;
470
471     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
472
473     IStream_AddRef(pIStream);
474     This->stream = pIStream;
475
476     return S_OK;
477 }
478
479 static HRESULT WINAPI BmpEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
480     GUID *pguidContainerFormat)
481 {
482     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
483     return E_NOTIMPL;
484 }
485
486 static HRESULT WINAPI BmpEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
487     IWICBitmapEncoderInfo **ppIEncoderInfo)
488 {
489     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
490     return E_NOTIMPL;
491 }
492
493 static HRESULT WINAPI BmpEncoder_SetColorContexts(IWICBitmapEncoder *iface,
494     UINT cCount, IWICColorContext **ppIColorContext)
495 {
496     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
497     return E_NOTIMPL;
498 }
499
500 static HRESULT WINAPI BmpEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
501 {
502     TRACE("(%p,%p)\n", iface, pIPalette);
503     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
504 }
505
506 static HRESULT WINAPI BmpEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
507 {
508     TRACE("(%p,%p)\n", iface, pIThumbnail);
509     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
510 }
511
512 static HRESULT WINAPI BmpEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
513 {
514     TRACE("(%p,%p)\n", iface, pIPreview);
515     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
516 }
517
518 static HRESULT WINAPI BmpEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
519     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
520 {
521     BmpEncoder *This = (BmpEncoder*)iface;
522     BmpFrameEncode *encode;
523     HRESULT hr;
524
525     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
526
527     if (This->frame) return WINCODEC_ERR_UNSUPPORTEDOPERATION;
528
529     if (!This->stream) return WINCODEC_ERR_NOTINITIALIZED;
530
531     hr = CreatePropertyBag2(ppIEncoderOptions);
532     if (FAILED(hr)) return hr;
533
534     encode = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpFrameEncode));
535     if (!encode)
536     {
537         IPropertyBag2_Release(*ppIEncoderOptions);
538         *ppIEncoderOptions = NULL;
539         return E_OUTOFMEMORY;
540     }
541     encode->lpVtbl = &BmpFrameEncode_Vtbl;
542     encode->ref = 2;
543     IStream_AddRef(This->stream);
544     encode->stream = This->stream;
545     encode->initialized = FALSE;
546     encode->width = 0;
547     encode->height = 0;
548     encode->bits = NULL;
549     encode->format = NULL;
550     encode->xres = 0.0;
551     encode->yres = 0.0;
552     encode->lineswritten = 0;
553     encode->committed = FALSE;
554
555     *ppIFrameEncode = (IWICBitmapFrameEncode*)encode;
556     This->frame = (IWICBitmapFrameEncode*)encode;
557
558     return S_OK;
559 }
560
561 static HRESULT WINAPI BmpEncoder_Commit(IWICBitmapEncoder *iface)
562 {
563     BmpEncoder *This = (BmpEncoder*)iface;
564     BmpFrameEncode *frame = (BmpFrameEncode*)This->frame;
565     TRACE("(%p)\n", iface);
566
567     if (!frame || !frame->committed) return WINCODEC_ERR_WRONGSTATE;
568
569     return S_OK;
570 }
571
572 static HRESULT WINAPI BmpEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
573     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
574 {
575     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
576     return E_NOTIMPL;
577 }
578
579 static const IWICBitmapEncoderVtbl BmpEncoder_Vtbl = {
580     BmpEncoder_QueryInterface,
581     BmpEncoder_AddRef,
582     BmpEncoder_Release,
583     BmpEncoder_Initialize,
584     BmpEncoder_GetContainerFormat,
585     BmpEncoder_GetEncoderInfo,
586     BmpEncoder_SetColorContexts,
587     BmpEncoder_SetPalette,
588     BmpEncoder_SetThumbnail,
589     BmpEncoder_SetPreview,
590     BmpEncoder_CreateNewFrame,
591     BmpEncoder_Commit,
592     BmpEncoder_GetMetadataQueryWriter
593 };
594
595 HRESULT BmpEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
596 {
597     BmpEncoder *This;
598     HRESULT ret;
599
600     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
601
602     *ppv = NULL;
603
604     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
605
606     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpEncoder));
607     if (!This) return E_OUTOFMEMORY;
608
609     This->lpVtbl = &BmpEncoder_Vtbl;
610     This->ref = 1;
611     This->stream = NULL;
612     This->frame = NULL;
613
614     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
615     IUnknown_Release((IUnknown*)This);
616
617     return ret;
618 }