dll/win32/windowscodecs/bmpencode.c

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