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