dlls/windowscodecs/encoder.c

   1 /*
   2  * Copyright 2020 Esme Povirk
   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 <stdarg.h>
  20
  21 #define NONAMELESSUNION
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27
  28 #include "wincodecs_private.h"
  29
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  33
  34 static const PROPBAG2 encoder_option_properties[ENCODER_OPTION_END] = {
  35     { PROPBAG2_TYPE_DATA, VT_BOOL, 0, 0, (LPOLESTR)L"InterlaceOption" },
  36     { PROPBAG2_TYPE_DATA, VT_UI1,  0, 0, (LPOLESTR)L"FilterOption" },
  37     { PROPBAG2_TYPE_DATA, VT_UI1,  0, 0, (LPOLESTR)L"TiffCompressionMethod" },
  38     { PROPBAG2_TYPE_DATA, VT_R4,   0, 0, (LPOLESTR)L"CompressionQuality" },
  39     { PROPBAG2_TYPE_DATA, VT_R4,            0, 0, (LPOLESTR)L"ImageQuality" },
  40     { PROPBAG2_TYPE_DATA, VT_UI1,           0, 0, (LPOLESTR)L"BitmapTransform" },
  41     { PROPBAG2_TYPE_DATA, VT_I4 | VT_ARRAY, 0, 0, (LPOLESTR)L"Luminance" },
  42     { PROPBAG2_TYPE_DATA, VT_I4 | VT_ARRAY, 0, 0, (LPOLESTR)L"Chrominance" },
  43     { PROPBAG2_TYPE_DATA, VT_UI1,           0, 0, (LPOLESTR)L"JpegYCrCbSubsampling" },
  44     { PROPBAG2_TYPE_DATA, VT_BOOL,          0, 0, (LPOLESTR)L"SuppressApp0" }
  45 };
  46
  47 typedef struct CommonEncoder {
  48     IWICBitmapEncoder IWICBitmapEncoder_iface;
  49     LONG ref;
  50     CRITICAL_SECTION lock; /* must be held when stream or encoder is accessed */
  51     IStream *stream;
  52     struct encoder *encoder;
  53     struct encoder_info encoder_info;
  54     UINT frame_count;
  55     BOOL uncommitted_frame;
  56     BOOL committed;
  57 } CommonEncoder;
  58
  59 typedef struct CommonEncoderFrame {
  60     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
  61     IWICMetadataBlockWriter IWICMetadataBlockWriter_iface;
  62     LONG ref;
  63     CommonEncoder *parent;
  64     struct encoder_frame encoder_frame;
  65     BOOL initialized;
  66     BOOL frame_created;
  67     UINT lines_written;
  68     BOOL committed;
  69 } CommonEncoderFrame;
  70
  71 static inline CommonEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
  72 {
  73     return CONTAINING_RECORD(iface, CommonEncoder, IWICBitmapEncoder_iface);
  74 }
  75
  76 static inline CommonEncoderFrame *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
  77 {
  78     return CONTAINING_RECORD(iface, CommonEncoderFrame, IWICBitmapFrameEncode_iface);
  79 }
  80
  81 static inline CommonEncoderFrame *impl_from_IWICMetadataBlockWriter(IWICMetadataBlockWriter *iface)
  82 {
  83     return CONTAINING_RECORD(iface, CommonEncoderFrame, IWICMetadataBlockWriter_iface);
  84 }
  85
  86 static HRESULT WINAPI CommonEncoderFrame_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
  87     void **ppv)
  88 {
  89     CommonEncoderFrame *object = impl_from_IWICBitmapFrameEncode(iface);
  90     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  91
  92     if (!ppv) return E_INVALIDARG;
  93
  94     if (IsEqualIID(&IID_IUnknown, iid) ||
  95         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
  96     {
  97         *ppv = &object->IWICBitmapFrameEncode_iface;
  98     }
  99     else if (object->parent->encoder_info.flags & ENCODER_FLAGS_SUPPORTS_METADATA
 100             && IsEqualIID(&IID_IWICMetadataBlockWriter, iid))
 101     {
 102         *ppv = &object->IWICMetadataBlockWriter_iface;
 103     }
 104     else
 105     {
 106         *ppv = NULL;
 107         return E_NOINTERFACE;
 108     }
 109
 110     IUnknown_AddRef((IUnknown*)*ppv);
 111     return S_OK;
 112 }
 113
 114 static ULONG WINAPI CommonEncoderFrame_AddRef(IWICBitmapFrameEncode *iface)
 115 {
 116     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 117     ULONG ref = InterlockedIncrement(&This->ref);
 118
 119     TRACE("(%p) refcount=%u\n", iface, ref);
 120
 121     return ref;
 122 }
 123
 124 static ULONG WINAPI CommonEncoderFrame_Release(IWICBitmapFrameEncode *iface)
 125 {
 126     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 127     ULONG ref = InterlockedDecrement(&This->ref);
 128
 129     TRACE("(%p) refcount=%u\n", iface, ref);
 130
 131     if (ref == 0)
 132     {
 133         IWICBitmapEncoder_Release(&This->parent->IWICBitmapEncoder_iface);
 134         HeapFree(GetProcessHeap(), 0, This);
 135     }
 136
 137     return ref;
 138 }
 139
 140 static HRESULT WINAPI CommonEncoderFrame_Initialize(IWICBitmapFrameEncode *iface,
 141     IPropertyBag2 *pIEncoderOptions)
 142 {
 143     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 144     HRESULT hr=S_OK;
 145     struct encoder_frame options = {{0}};
 146     PROPBAG2 opts[7]= {{0}};
 147     VARIANT opt_values[7];
 148     HRESULT opt_hres[7];
 149     DWORD num_opts, i;
 150
 151     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
 152
 153     if (pIEncoderOptions)
 154     {
 155         for (i=0; This->parent->encoder_info.encoder_options[i] != ENCODER_OPTION_END; i++)
 156             opts[i] = encoder_option_properties[This->parent->encoder_info.encoder_options[i]];
 157         num_opts = i;
 158
 159         hr = IPropertyBag2_Read(pIEncoderOptions, num_opts, opts, NULL, opt_values, opt_hres);
 160
 161         if (FAILED(hr))
 162             return hr;
 163
 164         for (i=0; This->parent->encoder_info.encoder_options[i] != ENCODER_OPTION_END; i++)
 165         {
 166             VARIANT *val = &opt_values[i];
 167
 168             switch (This->parent->encoder_info.encoder_options[i])
 169             {
 170             case ENCODER_OPTION_INTERLACE:
 171                 if (V_VT(val) == VT_EMPTY)
 172                     options.interlace = FALSE;
 173                 else
 174                     options.interlace = (V_BOOL(val) != 0);
 175                 break;
 176             case ENCODER_OPTION_FILTER:
 177                 options.filter = V_UI1(val);
 178                 if (options.filter > WICPngFilterAdaptive)
 179                 {
 180                     WARN("Unrecognized filter option value %u.\n", options.filter);
 181                     options.filter = WICPngFilterUnspecified;
 182                 }
 183                 break;
 184             default:
 185                 break;
 186             }
 187         }
 188     }
 189     else
 190     {
 191         options.interlace = FALSE;
 192         options.filter = WICPngFilterUnspecified;
 193     }
 194
 195     EnterCriticalSection(&This->parent->lock);
 196
 197     if (This->initialized)
 198         hr = WINCODEC_ERR_WRONGSTATE;
 199     else
 200     {
 201         This->encoder_frame = options;
 202         This->initialized = TRUE;
 203     }
 204
 205     LeaveCriticalSection(&This->parent->lock);
 206
 207     return hr;
 208 }
 209
 210 static HRESULT WINAPI CommonEncoderFrame_SetSize(IWICBitmapFrameEncode *iface,
 211     UINT uiWidth, UINT uiHeight)
 212 {
 213     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 214     HRESULT hr;
 215
 216     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
 217
 218     EnterCriticalSection(&This->parent->lock);
 219
 220     if (This->parent->encoder_info.flags & ENCODER_FLAGS_ICNS_SIZE)
 221     {
 222         if (uiWidth != uiHeight)
 223         {
 224             WARN("cannot generate ICNS icon from %dx%d image\n", uiWidth, uiHeight);
 225             hr = E_INVALIDARG;
 226             goto end;
 227         }
 228
 229         switch (uiWidth)
 230         {
 231             case 16:
 232             case 32:
 233             case 48:
 234             case 128:
 235             case 256:
 236             case 512:
 237                 break;
 238             default:
 239                 WARN("cannot generate ICNS icon from %dx%d image\n", uiWidth, uiHeight);
 240                 hr = E_INVALIDARG;
 241                 goto end;
 242         }
 243     }
 244
 245     if (!This->initialized || This->frame_created)
 246     {
 247         hr = WINCODEC_ERR_WRONGSTATE;
 248     }
 249     else
 250     {
 251         This->encoder_frame.width = uiWidth;
 252         This->encoder_frame.height = uiHeight;
 253         hr = S_OK;
 254     }
 255
 256 end:
 257     LeaveCriticalSection(&This->parent->lock);
 258
 259     return hr;
 260 }
 261
 262 static HRESULT WINAPI CommonEncoderFrame_SetResolution(IWICBitmapFrameEncode *iface,
 263     double dpiX, double dpiY)
 264 {
 265     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 266     HRESULT hr;
 267
 268     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
 269
 270     EnterCriticalSection(&This->parent->lock);
 271
 272     if (!This->initialized || This->frame_created)
 273     {
 274         hr = WINCODEC_ERR_WRONGSTATE;
 275     }
 276     else
 277     {
 278         This->encoder_frame.dpix = dpiX;
 279         This->encoder_frame.dpiy = dpiY;
 280         hr = S_OK;
 281     }
 282
 283     LeaveCriticalSection(&This->parent->lock);
 284
 285     return hr;
 286 }
 287
 288 static HRESULT WINAPI CommonEncoderFrame_SetPixelFormat(IWICBitmapFrameEncode *iface,
 289     WICPixelFormatGUID *pPixelFormat)
 290 {
 291     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 292     HRESULT hr;
 293     GUID pixel_format;
 294     DWORD bpp;
 295     BOOL indexed;
 296
 297     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
 298
 299     EnterCriticalSection(&This->parent->lock);
 300
 301     if (!This->initialized || This->frame_created)
 302     {
 303         hr = WINCODEC_ERR_WRONGSTATE;
 304     }
 305     else
 306     {
 307         pixel_format = *pPixelFormat;
 308         hr = encoder_get_supported_format(This->parent->encoder, &pixel_format, &bpp, &indexed);
 309     }
 310
 311     if (SUCCEEDED(hr))
 312     {
 313         TRACE("<-- %s bpp=%i indexed=%i\n", wine_dbgstr_guid(&pixel_format), bpp, indexed);
 314         *pPixelFormat = pixel_format;
 315         This->encoder_frame.pixel_format = pixel_format;
 316         This->encoder_frame.bpp = bpp;
 317         This->encoder_frame.indexed = indexed;
 318     }
 319
 320     LeaveCriticalSection(&This->parent->lock);
 321
 322     return hr;
 323 }
 324
 325 static HRESULT WINAPI CommonEncoderFrame_SetColorContexts(IWICBitmapFrameEncode *iface,
 326     UINT cCount, IWICColorContext **ppIColorContext)
 327 {
 328     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 329     return E_NOTIMPL;
 330 }
 331
 332 static HRESULT WINAPI CommonEncoderFrame_SetPalette(IWICBitmapFrameEncode *iface,
 333     IWICPalette *palette)
 334 {
 335     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 336     HRESULT hr;
 337
 338     TRACE("(%p,%p)\n", iface, palette);
 339
 340     if (!palette)
 341         return E_INVALIDARG;
 342
 343     EnterCriticalSection(&This->parent->lock);
 344
 345     if (!This->initialized)
 346         hr = WINCODEC_ERR_NOTINITIALIZED;
 347     else if (This->frame_created)
 348         hr = WINCODEC_ERR_WRONGSTATE;
 349     else
 350         hr = IWICPalette_GetColors(palette, 256, This->encoder_frame.palette,
 351             &This->encoder_frame.num_colors);
 352
 353     LeaveCriticalSection(&This->parent->lock);
 354
 355     return hr;
 356 }
 357
 358 static HRESULT WINAPI CommonEncoderFrame_SetThumbnail(IWICBitmapFrameEncode *iface,
 359     IWICBitmapSource *pIThumbnail)
 360 {
 361     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
 362     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 363 }
 364
 365 static HRESULT WINAPI CommonEncoderFrame_WritePixels(IWICBitmapFrameEncode *iface,
 366     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
 367 {
 368     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 369     HRESULT hr=S_OK;
 370     DWORD required_stride;
 371
 372     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
 373
 374     EnterCriticalSection(&This->parent->lock);
 375
 376     if (!This->initialized || !This->encoder_frame.height || !This->encoder_frame.width ||
 377         !This->encoder_frame.bpp)
 378     {
 379         LeaveCriticalSection(&This->parent->lock);
 380         return WINCODEC_ERR_WRONGSTATE;
 381     }
 382
 383     required_stride = (This->encoder_frame.width * This->encoder_frame.bpp + 7)/8;
 384
 385     if (lineCount == 0 || This->encoder_frame.height - This->lines_written < lineCount ||
 386         cbStride < required_stride || cbBufferSize < cbStride * (lineCount - 1) + required_stride ||
 387         !pbPixels)
 388     {
 389         LeaveCriticalSection(&This->parent->lock);
 390         return E_INVALIDARG;
 391     }
 392
 393     if (!This->frame_created)
 394     {
 395         hr = encoder_create_frame(This->parent->encoder, &This->encoder_frame);
 396         if (SUCCEEDED(hr))
 397             This->frame_created = TRUE;
 398     }
 399
 400     if (SUCCEEDED(hr))
 401     {
 402         hr = encoder_write_lines(This->parent->encoder, pbPixels, lineCount, cbStride);
 403         if (SUCCEEDED(hr))
 404             This->lines_written += lineCount;
 405     }
 406
 407     LeaveCriticalSection(&This->parent->lock);
 408
 409     return hr;
 410 }
 411
 412 static HRESULT WINAPI CommonEncoderFrame_WriteSource(IWICBitmapFrameEncode *iface,
 413     IWICBitmapSource *pIBitmapSource, WICRect *prc)
 414 {
 415     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 416     HRESULT hr;
 417     TRACE("(%p,%p,%s)\n", iface, pIBitmapSource, debug_wic_rect(prc));
 418
 419     if (!This->initialized)
 420         return WINCODEC_ERR_WRONGSTATE;
 421
 422     hr = configure_write_source(iface, pIBitmapSource, prc,
 423         This->encoder_frame.bpp ? &This->encoder_frame.pixel_format : NULL,
 424         This->encoder_frame.width, This->encoder_frame.height,
 425         This->encoder_frame.dpix, This->encoder_frame.dpiy);
 426
 427     if (SUCCEEDED(hr))
 428     {
 429         hr = write_source(iface, pIBitmapSource, prc,
 430             &This->encoder_frame.pixel_format, This->encoder_frame.bpp,
 431             !This->encoder_frame.num_colors && This->encoder_frame.indexed,
 432             This->encoder_frame.width, This->encoder_frame.height);
 433     }
 434
 435     return hr;
 436 }
 437
 438 static HRESULT WINAPI CommonEncoderFrame_Commit(IWICBitmapFrameEncode *iface)
 439 {
 440     CommonEncoderFrame *This = impl_from_IWICBitmapFrameEncode(iface);
 441     HRESULT hr;
 442
 443     TRACE("(%p)\n", iface);
 444
 445     EnterCriticalSection(&This->parent->lock);
 446
 447     if (!This->frame_created || This->lines_written != This->encoder_frame.height ||
 448         This->committed)
 449     {
 450         hr = WINCODEC_ERR_WRONGSTATE;
 451     }
 452     else
 453     {
 454         hr = encoder_commit_frame(This->parent->encoder);
 455         if (SUCCEEDED(hr))
 456         {
 457             This->committed = TRUE;
 458             This->parent->uncommitted_frame = FALSE;
 459         }
 460     }
 461
 462     LeaveCriticalSection(&This->parent->lock);
 463
 464     return hr;
 465 }
 466
 467 static HRESULT WINAPI CommonEncoderFrame_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
 468     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 469 {
 470     CommonEncoderFrame *encoder = impl_from_IWICBitmapFrameEncode(iface);
 471
 472     TRACE("iface, %p, ppIMetadataQueryWriter %p.\n", iface, ppIMetadataQueryWriter);
 473
 474     if (!ppIMetadataQueryWriter)
 475         return E_INVALIDARG;
 476
 477     if (!encoder->initialized)
 478         return WINCODEC_ERR_NOTINITIALIZED;
 479
 480     if (!(encoder->parent->encoder_info.flags & ENCODER_FLAGS_SUPPORTS_METADATA))
 481         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 482
 483     return MetadataQueryWriter_CreateInstance(&encoder->IWICMetadataBlockWriter_iface, NULL, ppIMetadataQueryWriter);
 484 }
 485
 486 static const IWICBitmapFrameEncodeVtbl CommonEncoderFrame_Vtbl = {
 487     CommonEncoderFrame_QueryInterface,
 488     CommonEncoderFrame_AddRef,
 489     CommonEncoderFrame_Release,
 490     CommonEncoderFrame_Initialize,
 491     CommonEncoderFrame_SetSize,
 492     CommonEncoderFrame_SetResolution,
 493     CommonEncoderFrame_SetPixelFormat,
 494     CommonEncoderFrame_SetColorContexts,
 495     CommonEncoderFrame_SetPalette,
 496     CommonEncoderFrame_SetThumbnail,
 497     CommonEncoderFrame_WritePixels,
 498     CommonEncoderFrame_WriteSource,
 499     CommonEncoderFrame_Commit,
 500     CommonEncoderFrame_GetMetadataQueryWriter
 501 };
 502
 503 static HRESULT WINAPI CommonEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
 504     void **ppv)
 505 {
 506     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 507     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 508
 509     if (!ppv) return E_INVALIDARG;
 510
 511     if (IsEqualIID(&IID_IUnknown, iid) ||
 512         IsEqualIID(&IID_IWICBitmapEncoder, iid))
 513     {
 514         *ppv = &This->IWICBitmapEncoder_iface;
 515     }
 516     else
 517     {
 518         *ppv = NULL;
 519         return E_NOINTERFACE;
 520     }
 521
 522     IUnknown_AddRef((IUnknown*)*ppv);
 523     return S_OK;
 524 }
 525
 526 static ULONG WINAPI CommonEncoder_AddRef(IWICBitmapEncoder *iface)
 527 {
 528     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 529     ULONG ref = InterlockedIncrement(&This->ref);
 530
 531     TRACE("(%p) refcount=%u\n", iface, ref);
 532
 533     return ref;
 534 }
 535
 536 static ULONG WINAPI CommonEncoder_Release(IWICBitmapEncoder *iface)
 537 {
 538     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 539     ULONG ref = InterlockedDecrement(&This->ref);
 540
 541     TRACE("(%p) refcount=%u\n", iface, ref);
 542
 543     if (ref == 0)
 544     {
 545         This->lock.DebugInfo->Spare[0] = 0;
 546         DeleteCriticalSection(&This->lock);
 547         if (This->stream)
 548             IStream_Release(This->stream);
 549         encoder_destroy(This->encoder);
 550         HeapFree(GetProcessHeap(), 0, This);
 551     }
 552
 553     return ref;
 554 }
 555
 556 static HRESULT WINAPI CommonEncoder_Initialize(IWICBitmapEncoder *iface,
 557     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
 558 {
 559     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 560     HRESULT hr;
 561
 562     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
 563
 564     if (!pIStream)
 565         return E_POINTER;
 566
 567     EnterCriticalSection(&This->lock);
 568
 569     if (This->stream)
 570     {
 571         LeaveCriticalSection(&This->lock);
 572         return WINCODEC_ERR_WRONGSTATE;
 573     }
 574
 575     hr = encoder_initialize(This->encoder, pIStream);
 576
 577     if (SUCCEEDED(hr))
 578     {
 579         This->stream = pIStream;
 580         IStream_AddRef(This->stream);
 581     }
 582
 583     LeaveCriticalSection(&This->lock);
 584
 585     return S_OK;
 586 }
 587
 588 static HRESULT WINAPI CommonEncoder_GetContainerFormat(IWICBitmapEncoder *iface, GUID *format)
 589 {
 590     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 591     TRACE("(%p,%p)\n", iface, format);
 592
 593     if (!format)
 594         return E_INVALIDARG;
 595
 596     memcpy(format, &This->encoder_info.container_format, sizeof(*format));
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI CommonEncoder_GetEncoderInfo(IWICBitmapEncoder *iface, IWICBitmapEncoderInfo **info)
 601 {
 602     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 603     IWICComponentInfo *comp_info;
 604     HRESULT hr;
 605
 606     TRACE("%p,%p\n", iface, info);
 607
 608     if (!info) return E_INVALIDARG;
 609
 610     hr = CreateComponentInfo(&This->encoder_info.clsid, &comp_info);
 611     if (hr == S_OK)
 612     {
 613         hr = IWICComponentInfo_QueryInterface(comp_info, &IID_IWICBitmapEncoderInfo, (void **)info);
 614         IWICComponentInfo_Release(comp_info);
 615     }
 616     return hr;
 617 }
 618
 619 static HRESULT WINAPI CommonEncoder_SetColorContexts(IWICBitmapEncoder *iface,
 620     UINT cCount, IWICColorContext **ppIColorContext)
 621 {
 622     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI CommonEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *palette)
 627 {
 628     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 629     HRESULT hr;
 630
 631     TRACE("(%p,%p)\n", iface, palette);
 632
 633     EnterCriticalSection(&This->lock);
 634
 635     hr = This->stream ? WINCODEC_ERR_UNSUPPORTEDOPERATION : WINCODEC_ERR_NOTINITIALIZED;
 636
 637     LeaveCriticalSection(&This->lock);
 638
 639     return hr;
 640 }
 641
 642 static HRESULT WINAPI CommonEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
 643 {
 644     TRACE("(%p,%p)\n", iface, pIThumbnail);
 645     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 646 }
 647
 648 static HRESULT WINAPI CommonEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
 649 {
 650     TRACE("(%p,%p)\n", iface, pIPreview);
 651     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 652 }
 653
 654 static HRESULT WINAPI CommonEncoderFrame_Block_QueryInterface(IWICMetadataBlockWriter *iface, REFIID iid, void **ppv)
 655 {
 656     CommonEncoderFrame *encoder = impl_from_IWICMetadataBlockWriter(iface);
 657
 658     return IWICBitmapFrameEncode_QueryInterface(&encoder->IWICBitmapFrameEncode_iface, iid, ppv);
 659 }
 660
 661 static ULONG WINAPI CommonEncoderFrame_Block_AddRef(IWICMetadataBlockWriter *iface)
 662 {
 663     CommonEncoderFrame *encoder = impl_from_IWICMetadataBlockWriter(iface);
 664
 665     return IWICBitmapFrameEncode_AddRef(&encoder->IWICBitmapFrameEncode_iface);
 666 }
 667
 668 static ULONG WINAPI CommonEncoderFrame_Block_Release(IWICMetadataBlockWriter *iface)
 669 {
 670     CommonEncoderFrame *encoder = impl_from_IWICMetadataBlockWriter(iface);
 671
 672     return IWICBitmapFrameEncode_Release(&encoder->IWICBitmapFrameEncode_iface);
 673 }
 674
 675 static HRESULT WINAPI CommonEncoderFrame_Block_GetContainerFormat(IWICMetadataBlockWriter *iface, GUID *container_format)
 676 {
 677     FIXME("iface %p, container_format %p stub.\n", iface, container_format);
 678
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI CommonEncoderFrame_Block_GetCount(IWICMetadataBlockWriter *iface, UINT *count)
 683 {
 684     FIXME("iface %p, count %p stub.\n", iface, count);
 685
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI CommonEncoderFrame_Block_GetReaderByIndex(IWICMetadataBlockWriter *iface,
 690         UINT index, IWICMetadataReader **metadata_reader)
 691 {
 692     FIXME("iface %p, index %d, metadata_reader %p stub.\n", iface, index, metadata_reader);
 693
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI CommonEncoderFrame_Block_GetEnumerator(IWICMetadataBlockWriter *iface, IEnumUnknown **enum_metadata)
 698 {
 699     FIXME("iface %p, ppIEnumMetadata %p stub.\n", iface, enum_metadata);
 700
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI CommonEncoderFrame_Block_InitializeFromBlockReader(IWICMetadataBlockWriter *iface,
 705         IWICMetadataBlockReader *metadata_block_reader)
 706 {
 707     FIXME("iface %p, metadata_block_reader %p stub.\n", iface, metadata_block_reader);
 708
 709     return E_NOTIMPL;
 710 }
 711
 712 static HRESULT WINAPI CommonEncoderFrame_Block_GetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index,
 713         IWICMetadataWriter **metadata_writer)
 714 {
 715     FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
 716
 717     return E_NOTIMPL;
 718 }
 719
 720 static HRESULT WINAPI CommonEncoderFrame_Block_AddWriter(IWICMetadataBlockWriter *iface, IWICMetadataWriter *metadata_writer)
 721 {
 722     FIXME("iface %p, metadata_writer %p.\n", iface, metadata_writer);
 723
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI CommonEncoderFrame_Block_SetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index,
 728         IWICMetadataWriter *metadata_writer)
 729 {
 730     FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
 731
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT WINAPI CommonEncoderFrame_Block_RemoveWriterByIndex(IWICMetadataBlockWriter *iface, UINT index)
 736 {
 737     FIXME("iface %p, index %u.\n", iface, index);
 738
 739     return E_NOTIMPL;
 740 }
 741
 742 static const IWICMetadataBlockWriterVtbl CommonEncoderFrame_BlockVtbl =
 743 {
 744     CommonEncoderFrame_Block_QueryInterface,
 745     CommonEncoderFrame_Block_AddRef,
 746     CommonEncoderFrame_Block_Release,
 747     CommonEncoderFrame_Block_GetContainerFormat,
 748     CommonEncoderFrame_Block_GetCount,
 749     CommonEncoderFrame_Block_GetReaderByIndex,
 750     CommonEncoderFrame_Block_GetEnumerator,
 751     CommonEncoderFrame_Block_InitializeFromBlockReader,
 752     CommonEncoderFrame_Block_GetWriterByIndex,
 753     CommonEncoderFrame_Block_AddWriter,
 754     CommonEncoderFrame_Block_SetWriterByIndex,
 755     CommonEncoderFrame_Block_RemoveWriterByIndex,
 756 };
 757
 758 static HRESULT WINAPI CommonEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
 759     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
 760 {
 761     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 762     CommonEncoderFrame *result;
 763     HRESULT hr;
 764     DWORD opts_length;
 765     PROPBAG2 opts[6];
 766
 767     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
 768
 769     EnterCriticalSection(&This->lock);
 770
 771     if (This->frame_count != 0 && !(This->encoder_info.flags & ENCODER_FLAGS_MULTI_FRAME))
 772     {
 773         LeaveCriticalSection(&This->lock);
 774         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 775     }
 776
 777     if (!This->stream || This->committed || This->uncommitted_frame)
 778     {
 779         LeaveCriticalSection(&This->lock);
 780         return WINCODEC_ERR_NOTINITIALIZED;
 781     }
 782
 783     result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*result));
 784     if (!result)
 785     {
 786         LeaveCriticalSection(&This->lock);
 787         return E_OUTOFMEMORY;
 788     }
 789
 790     result->IWICBitmapFrameEncode_iface.lpVtbl = &CommonEncoderFrame_Vtbl;
 791     result->IWICMetadataBlockWriter_iface.lpVtbl = &CommonEncoderFrame_BlockVtbl;
 792     result->ref = 1;
 793     result->parent = This;
 794
 795     if (ppIEncoderOptions)
 796     {
 797         for (opts_length = 0; This->encoder_info.encoder_options[opts_length] < ENCODER_OPTION_END; opts_length++)
 798         {
 799             opts[opts_length] = encoder_option_properties[This->encoder_info.encoder_options[opts_length]];
 800         }
 801
 802         hr = CreatePropertyBag2(opts, opts_length, ppIEncoderOptions);
 803         if (FAILED(hr))
 804         {
 805             LeaveCriticalSection(&This->lock);
 806             HeapFree(GetProcessHeap(), 0, result);
 807             return hr;
 808         }
 809     }
 810
 811     IWICBitmapEncoder_AddRef(iface);
 812     This->frame_count++;
 813     This->uncommitted_frame = TRUE;
 814
 815     LeaveCriticalSection(&This->lock);
 816
 817     *ppIFrameEncode = &result->IWICBitmapFrameEncode_iface;
 818
 819     return S_OK;
 820 }
 821
 822 static HRESULT WINAPI CommonEncoder_Commit(IWICBitmapEncoder *iface)
 823 {
 824     CommonEncoder *This = impl_from_IWICBitmapEncoder(iface);
 825     HRESULT hr;
 826
 827     TRACE("(%p)\n", iface);
 828
 829     EnterCriticalSection(&This->lock);
 830
 831     if (This->committed || This->uncommitted_frame)
 832         hr = WINCODEC_ERR_WRONGSTATE;
 833     else
 834     {
 835         hr = encoder_commit_file(This->encoder);
 836         if (SUCCEEDED(hr))
 837             This->committed = TRUE;
 838     }
 839
 840     LeaveCriticalSection(&This->lock);
 841
 842     return hr;
 843 }
 844
 845 static HRESULT WINAPI CommonEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
 846     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 847 {
 848     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
 849     return E_NOTIMPL;
 850 }
 851
 852 static const IWICBitmapEncoderVtbl CommonEncoder_Vtbl = {
 853     CommonEncoder_QueryInterface,
 854     CommonEncoder_AddRef,
 855     CommonEncoder_Release,
 856     CommonEncoder_Initialize,
 857     CommonEncoder_GetContainerFormat,
 858     CommonEncoder_GetEncoderInfo,
 859     CommonEncoder_SetColorContexts,
 860     CommonEncoder_SetPalette,
 861     CommonEncoder_SetThumbnail,
 862     CommonEncoder_SetPreview,
 863     CommonEncoder_CreateNewFrame,
 864     CommonEncoder_Commit,
 865     CommonEncoder_GetMetadataQueryWriter
 866 };
 867
 868 HRESULT CommonEncoder_CreateInstance(struct encoder *encoder,
 869     const struct encoder_info *encoder_info, REFIID iid, void** ppv)
 870 {
 871     CommonEncoder *This;
 872     HRESULT ret;
 873
 874     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 875
 876     *ppv = NULL;
 877
 878     This = HeapAlloc(GetProcessHeap(), 0, sizeof(CommonEncoder));
 879     if (!This)
 880     {
 881         encoder_destroy(encoder);
 882         return E_OUTOFMEMORY;
 883     }
 884
 885     This->IWICBitmapEncoder_iface.lpVtbl = &CommonEncoder_Vtbl;
 886     This->ref = 1;
 887     This->stream = NULL;
 888     This->encoder = encoder;
 889     This->encoder_info = *encoder_info;
 890     This->frame_count = 0;
 891     This->uncommitted_frame = FALSE;
 892     This->committed = FALSE;
 893     InitializeCriticalSection(&This->lock);
 894     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": CommonEncoder.lock");
 895
 896     ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
 897     IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
 898
 899     return ret;
 900 }