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