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 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
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 inline BmpFrameEncode *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
75 {
76 return CONTAINING_RECORD(iface, BmpFrameEncode, IWICBitmapFrameEncode_iface);
77 }
78
79 static HRESULT WINAPI BmpFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
80 void **ppv)
81 {
82 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
83 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
84
85 if (!ppv) return E_INVALIDARG;
86
87 if (IsEqualIID(&IID_IUnknown, iid) ||
88 IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
89 {
90 *ppv = This;
91 }
92 else
93 {
94 *ppv = NULL;
95 return E_NOINTERFACE;
96 }
97
98 IUnknown_AddRef((IUnknown*)*ppv);
99 return S_OK;
100 }
101
102 static ULONG WINAPI BmpFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
103 {
104 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
105 ULONG ref = InterlockedIncrement(&This->ref);
106
107 TRACE("(%p) refcount=%u\n", iface, ref);
108
109 return ref;
110 }
111
112 static ULONG WINAPI BmpFrameEncode_Release(IWICBitmapFrameEncode *iface)
113 {
114 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
115 ULONG ref = InterlockedDecrement(&This->ref);
116
117 TRACE("(%p) refcount=%u\n", iface, ref);
118
119 if (ref == 0)
120 {
121 if (This->stream) IStream_Release(This->stream);
122 HeapFree(GetProcessHeap(), 0, This->bits);
123 HeapFree(GetProcessHeap(), 0, This);
124 }
125
126 return ref;
127 }
128
129 static HRESULT WINAPI BmpFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
130 IPropertyBag2 *pIEncoderOptions)
131 {
132 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
133 TRACE("(%p,%p)\n", iface, pIEncoderOptions);
134
135 if (This->initialized) return WINCODEC_ERR_WRONGSTATE;
136
137 This->initialized = TRUE;
138
139 return S_OK;
140 }
141
142 static HRESULT WINAPI BmpFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
143 UINT uiWidth, UINT uiHeight)
144 {
145 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
146 TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
147
148 if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
149
150 This->width = uiWidth;
151 This->height = uiHeight;
152
153 return S_OK;
154 }
155
156 static HRESULT WINAPI BmpFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
157 double dpiX, double dpiY)
158 {
159 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
160 TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
161
162 if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
163
164 This->xres = dpiX;
165 This->yres = dpiY;
166
167 return S_OK;
168 }
169
170 static HRESULT WINAPI BmpFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
171 WICPixelFormatGUID *pPixelFormat)
172 {
173 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
174 int i;
175 TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
176
177 if (!This->initialized || This->bits) return WINCODEC_ERR_WRONGSTATE;
178
179 for (i=0; formats[i].guid; i++)
180 {
181 if (memcmp(formats[i].guid, pPixelFormat, sizeof(GUID)) == 0)
182 break;
183 }
184
185 if (!formats[i].guid) i = 0;
186
187 This->format = &formats[i];
188 memcpy(pPixelFormat, This->format->guid, sizeof(GUID));
189
190 return S_OK;
191 }
192
193 static HRESULT WINAPI BmpFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
194 UINT cCount, IWICColorContext **ppIColorContext)
195 {
196 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
197 return E_NOTIMPL;
198 }
199
200 static HRESULT WINAPI BmpFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
201 IWICPalette *pIPalette)
202 {
203 FIXME("(%p,%p): stub\n", iface, pIPalette);
204 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
205 }
206
207 static HRESULT WINAPI BmpFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
208 IWICBitmapSource *pIThumbnail)
209 {
210 FIXME("(%p,%p): stub\n", iface, pIThumbnail);
211 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
212 }
213
214 static HRESULT BmpFrameEncode_AllocateBits(BmpFrameEncode *This)
215 {
216 if (!This->bits)
217 {
218 if (!This->initialized || !This->width || !This->height || !This->format)
219 return WINCODEC_ERR_WRONGSTATE;
220
221 This->stride = (((This->width * This->format->bpp)+31)/32)*4;
222 This->bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->stride * This->height);
223 if (!This->bits) return E_OUTOFMEMORY;
224 }
225
226 return S_OK;
227 }
228
229 static HRESULT WINAPI BmpFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
230 UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
231 {
232 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
233 HRESULT hr;
234 WICRect rc;
235 TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
236
237 if (!This->initialized || !This->width || !This->height || !This->format)
238 return WINCODEC_ERR_WRONGSTATE;
239
240 hr = BmpFrameEncode_AllocateBits(This);
241 if (FAILED(hr)) return hr;
242
243 rc.X = 0;
244 rc.Y = 0;
245 rc.Width = This->width;
246 rc.Height = lineCount;
247
248 hr = copy_pixels(This->format->bpp, pbPixels, This->width, lineCount, cbStride,
249 &rc, This->stride, This->stride*(This->height-This->lineswritten),
250 This->bits + This->stride*This->lineswritten);
251
252 if (SUCCEEDED(hr))
253 This->lineswritten += lineCount;
254
255 return hr;
256 }
257
258 static HRESULT WINAPI BmpFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
259 IWICBitmapSource *pIBitmapSource, WICRect *prc)
260 {
261 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
262 HRESULT hr;
263 WICRect rc;
264 WICPixelFormatGUID guid;
265 TRACE("(%p,%p,%p)\n", iface, pIBitmapSource, prc);
266
267 if (!This->initialized || !This->width || !This->height)
268 return WINCODEC_ERR_WRONGSTATE;
269
270 if (!This->format)
271 {
272 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
273 if (FAILED(hr)) return hr;
274 hr = BmpFrameEncode_SetPixelFormat(iface, &guid);
275 if (FAILED(hr)) return hr;
276 }
277
278 hr = IWICBitmapSource_GetPixelFormat(pIBitmapSource, &guid);
279 if (FAILED(hr)) return hr;
280 if (memcmp(&guid, This->format->guid, sizeof(GUID)) != 0)
281 {
282 /* should use WICConvertBitmapSource to convert, but that's unimplemented */
283 ERR("format %s unsupported\n", debugstr_guid(&guid));
284 return E_FAIL;
285 }
286
287 if (This->xres == 0.0 || This->yres == 0.0)
288 {
289 double xres, yres;
290 hr = IWICBitmapSource_GetResolution(pIBitmapSource, &xres, &yres);
291 if (FAILED(hr)) return hr;
292 hr = BmpFrameEncode_SetResolution(iface, xres, yres);
293 if (FAILED(hr)) return hr;
294 }
295
296 if (!prc)
297 {
298 UINT width, height;
299 hr = IWICBitmapSource_GetSize(pIBitmapSource, &width, &height);
300 if (FAILED(hr)) return hr;
301 rc.X = 0;
302 rc.Y = 0;
303 rc.Width = width;
304 rc.Height = height;
305 prc = &rc;
306 }
307
308 if (prc->Width != This->width) return E_INVALIDARG;
309
310 hr = BmpFrameEncode_AllocateBits(This);
311 if (FAILED(hr)) return hr;
312
313 hr = IWICBitmapSource_CopyPixels(pIBitmapSource, prc, This->stride,
314 This->stride*(This->height-This->lineswritten),
315 This->bits + This->stride*This->lineswritten);
316
317 This->lineswritten += rc.Height;
318
319 return S_OK;
320 }
321
322 static HRESULT WINAPI BmpFrameEncode_Commit(IWICBitmapFrameEncode *iface)
323 {
324 BmpFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
325 BITMAPFILEHEADER bfh;
326 BITMAPV5HEADER bih;
327 UINT info_size;
328 LARGE_INTEGER pos;
329 ULONG byteswritten;
330 HRESULT hr;
331
332 TRACE("(%p)\n", iface);
333
334 if (!This->bits || This->committed || This->height != This->lineswritten)
335 return WINCODEC_ERR_WRONGSTATE;
336
337 bfh.bfType = 0x4d42; /* "BM" */
338 bfh.bfReserved1 = 0;
339 bfh.bfReserved2 = 0;
340
341 bih.bV5Size = info_size = sizeof(BITMAPINFOHEADER);
342 bih.bV5Width = This->width;
343 bih.bV5Height = -This->height; /* top-down bitmap */
344 bih.bV5Planes = 1;
345 bih.bV5BitCount = This->format->bpp;
346 bih.bV5Compression = This->format->compression;
347 bih.bV5SizeImage = This->stride*This->height;
348 bih.bV5XPelsPerMeter = (This->xres+0.0127) / 0.0254;
349 bih.bV5YPelsPerMeter = (This->yres+0.0127) / 0.0254;
350 bih.bV5ClrUsed = 0;
351 bih.bV5ClrImportant = 0;
352
353 if (This->format->compression == BI_BITFIELDS)
354 {
355 if (This->format->alphamask)
356 bih.bV5Size = info_size = sizeof(BITMAPV4HEADER);
357 else
358 info_size = sizeof(BITMAPINFOHEADER)+12;
359 bih.bV5RedMask = This->format->redmask;
360 bih.bV5GreenMask = This->format->greenmask;
361 bih.bV5BlueMask = This->format->bluemask;
362 bih.bV5AlphaMask = This->format->alphamask;
363 bih.bV5AlphaMask = LCS_DEVICE_RGB;
364 }
365
366 bfh.bfSize = sizeof(BITMAPFILEHEADER) + info_size + bih.bV5SizeImage;
367 bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + info_size;
368
369 pos.QuadPart = 0;
370 hr = IStream_Seek(This->stream, pos, STREAM_SEEK_SET, NULL);
371 if (FAILED(hr)) return hr;
372
373 hr = IStream_Write(This->stream, &bfh, sizeof(BITMAPFILEHEADER), &byteswritten);
374 if (FAILED(hr)) return hr;
375 if (byteswritten != sizeof(BITMAPFILEHEADER)) return E_FAIL;
376
377 hr = IStream_Write(This->stream, &bih, info_size, &byteswritten);
378 if (FAILED(hr)) return hr;
379 if (byteswritten != info_size) return E_FAIL;
380
381 hr = IStream_Write(This->stream, This->bits, bih.bV5SizeImage, &byteswritten);
382 if (FAILED(hr)) return hr;
383 if (byteswritten != bih.bV5SizeImage) return E_FAIL;
384
385 This->committed = TRUE;
386
387 return S_OK;
388 }
389
390 static HRESULT WINAPI BmpFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
391 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
392 {
393 FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
394 return E_NOTIMPL;
395 }
396
397 static const IWICBitmapFrameEncodeVtbl BmpFrameEncode_Vtbl = {
398 BmpFrameEncode_QueryInterface,
399 BmpFrameEncode_AddRef,
400 BmpFrameEncode_Release,
401 BmpFrameEncode_Initialize,
402 BmpFrameEncode_SetSize,
403 BmpFrameEncode_SetResolution,
404 BmpFrameEncode_SetPixelFormat,
405 BmpFrameEncode_SetColorContexts,
406 BmpFrameEncode_SetPalette,
407 BmpFrameEncode_SetThumbnail,
408 BmpFrameEncode_WritePixels,
409 BmpFrameEncode_WriteSource,
410 BmpFrameEncode_Commit,
411 BmpFrameEncode_GetMetadataQueryWriter
412 };
413
414 typedef struct BmpEncoder {
415 IWICBitmapEncoder IWICBitmapEncoder_iface;
416 LONG ref;
417 IStream *stream;
418 BmpFrameEncode *frame;
419 } BmpEncoder;
420
421 static inline BmpEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
422 {
423 return CONTAINING_RECORD(iface, BmpEncoder, IWICBitmapEncoder_iface);
424 }
425
426 static HRESULT WINAPI BmpEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
427 void **ppv)
428 {
429 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
430 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
431
432 if (!ppv) return E_INVALIDARG;
433
434 if (IsEqualIID(&IID_IUnknown, iid) ||
435 IsEqualIID(&IID_IWICBitmapEncoder, iid))
436 {
437 *ppv = This;
438 }
439 else
440 {
441 *ppv = NULL;
442 return E_NOINTERFACE;
443 }
444
445 IUnknown_AddRef((IUnknown*)*ppv);
446 return S_OK;
447 }
448
449 static ULONG WINAPI BmpEncoder_AddRef(IWICBitmapEncoder *iface)
450 {
451 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
452 ULONG ref = InterlockedIncrement(&This->ref);
453
454 TRACE("(%p) refcount=%u\n", iface, ref);
455
456 return ref;
457 }
458
459 static ULONG WINAPI BmpEncoder_Release(IWICBitmapEncoder *iface)
460 {
461 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
462 ULONG ref = InterlockedDecrement(&This->ref);
463
464 TRACE("(%p) refcount=%u\n", iface, ref);
465
466 if (ref == 0)
467 {
468 if (This->stream) IStream_Release(This->stream);
469 if (This->frame) IWICBitmapFrameEncode_Release(&This->frame->IWICBitmapFrameEncode_iface);
470 HeapFree(GetProcessHeap(), 0, This);
471 }
472
473 return ref;
474 }
475
476 static HRESULT WINAPI BmpEncoder_Initialize(IWICBitmapEncoder *iface,
477 IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
478 {
479 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
480
481 TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
482
483 IStream_AddRef(pIStream);
484 This->stream = pIStream;
485
486 return S_OK;
487 }
488
489 static HRESULT WINAPI BmpEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
490 GUID *pguidContainerFormat)
491 {
492 memcpy(pguidContainerFormat, &GUID_ContainerFormatBmp, sizeof(GUID));
493 return S_OK;
494 }
495
496 static HRESULT WINAPI BmpEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
497 IWICBitmapEncoderInfo **ppIEncoderInfo)
498 {
499 FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
500 return E_NOTIMPL;
501 }
502
503 static HRESULT WINAPI BmpEncoder_SetColorContexts(IWICBitmapEncoder *iface,
504 UINT cCount, IWICColorContext **ppIColorContext)
505 {
506 FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
507 return E_NOTIMPL;
508 }
509
510 static HRESULT WINAPI BmpEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
511 {
512 TRACE("(%p,%p)\n", iface, pIPalette);
513 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
514 }
515
516 static HRESULT WINAPI BmpEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
517 {
518 TRACE("(%p,%p)\n", iface, pIThumbnail);
519 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
520 }
521
522 static HRESULT WINAPI BmpEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
523 {
524 TRACE("(%p,%p)\n", iface, pIPreview);
525 return WINCODEC_ERR_UNSUPPORTEDOPERATION;
526 }
527
528 static HRESULT WINAPI BmpEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
529 IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
530 {
531 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
532 BmpFrameEncode *encode;
533 HRESULT hr;
534
535 TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
536
537 if (This->frame) return WINCODEC_ERR_UNSUPPORTEDOPERATION;
538
539 if (!This->stream) return WINCODEC_ERR_NOTINITIALIZED;
540
541 hr = CreatePropertyBag2(ppIEncoderOptions);
542 if (FAILED(hr)) return hr;
543
544 encode = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpFrameEncode));
545 if (!encode)
546 {
547 IPropertyBag2_Release(*ppIEncoderOptions);
548 *ppIEncoderOptions = NULL;
549 return E_OUTOFMEMORY;
550 }
551 encode->IWICBitmapFrameEncode_iface.lpVtbl = &BmpFrameEncode_Vtbl;
552 encode->ref = 2;
553 IStream_AddRef(This->stream);
554 encode->stream = This->stream;
555 encode->initialized = FALSE;
556 encode->width = 0;
557 encode->height = 0;
558 encode->bits = NULL;
559 encode->format = NULL;
560 encode->xres = 0.0;
561 encode->yres = 0.0;
562 encode->lineswritten = 0;
563 encode->committed = FALSE;
564
565 *ppIFrameEncode = &encode->IWICBitmapFrameEncode_iface;
566 This->frame = encode;
567
568 return S_OK;
569 }
570
571 static HRESULT WINAPI BmpEncoder_Commit(IWICBitmapEncoder *iface)
572 {
573 BmpEncoder *This = impl_from_IWICBitmapEncoder(iface);
574 TRACE("(%p)\n", iface);
575
576 if (!This->frame || !This->frame->committed) return WINCODEC_ERR_WRONGSTATE;
577
578 return S_OK;
579 }
580
581 static HRESULT WINAPI BmpEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
582 IWICMetadataQueryWriter **ppIMetadataQueryWriter)
583 {
584 FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
585 return E_NOTIMPL;
586 }
587
588 static const IWICBitmapEncoderVtbl BmpEncoder_Vtbl = {
589 BmpEncoder_QueryInterface,
590 BmpEncoder_AddRef,
591 BmpEncoder_Release,
592 BmpEncoder_Initialize,
593 BmpEncoder_GetContainerFormat,
594 BmpEncoder_GetEncoderInfo,
595 BmpEncoder_SetColorContexts,
596 BmpEncoder_SetPalette,
597 BmpEncoder_SetThumbnail,
598 BmpEncoder_SetPreview,
599 BmpEncoder_CreateNewFrame,
600 BmpEncoder_Commit,
601 BmpEncoder_GetMetadataQueryWriter
602 };
603
604 HRESULT BmpEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
605 {
606 BmpEncoder *This;
607 HRESULT ret;
608
609 TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
610
611 *ppv = NULL;
612
613 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
614
615 This = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpEncoder));
616 if (!This) return E_OUTOFMEMORY;
617
618 This->IWICBitmapEncoder_iface.lpVtbl = &BmpEncoder_Vtbl;
619 This->ref = 1;
620 This->stream = NULL;
621 This->frame = NULL;
622
623 ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
624 IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
625
626 return ret;
627 }
628
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.