dlls/windowscodecs/icnsformat.c

   1 /*
   2  * Copyright 2010 Damjan Jovanovic
   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 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23
  24 #ifdef HAVE_APPLICATIONSERVICES_APPLICATIONSERVICES_H
  25 #define GetCurrentProcess GetCurrentProcess_Mac
  26 #define GetCurrentThread GetCurrentThread_Mac
  27 #define LoadResource LoadResource_Mac
  28 #define AnimatePalette AnimatePalette_Mac
  29 #define EqualRgn EqualRgn_Mac
  30 #define FillRgn FillRgn_Mac
  31 #define FrameRgn FrameRgn_Mac
  32 #define GetPixel GetPixel_Mac
  33 #define InvertRgn InvertRgn_Mac
  34 #define LineTo LineTo_Mac
  35 #define OffsetRgn OffsetRgn_Mac
  36 #define PaintRgn PaintRgn_Mac
  37 #define Polygon Polygon_Mac
  38 #define ResizePalette ResizePalette_Mac
  39 #define SetRectRgn SetRectRgn_Mac
  40 #define EqualRect EqualRect_Mac
  41 #define FillRect FillRect_Mac
  42 #define FrameRect FrameRect_Mac
  43 #define GetCursor GetCursor_Mac
  44 #define InvertRect InvertRect_Mac
  45 #define OffsetRect OffsetRect_Mac
  46 #define PtInRect PtInRect_Mac
  47 #define SetCursor SetCursor_Mac
  48 #define SetRect SetRect_Mac
  49 #define ShowCursor ShowCursor_Mac
  50 #define UnionRect UnionRect_Mac
  51 #include <ApplicationServices/ApplicationServices.h>
  52 #undef GetCurrentProcess
  53 #undef GetCurrentThread
  54 #undef LoadResource
  55 #undef AnimatePalette
  56 #undef EqualRgn
  57 #undef FillRgn
  58 #undef FrameRgn
  59 #undef GetPixel
  60 #undef InvertRgn
  61 #undef LineTo
  62 #undef OffsetRgn
  63 #undef PaintRgn
  64 #undef Polygon
  65 #undef ResizePalette
  66 #undef SetRectRgn
  67 #undef EqualRect
  68 #undef FillRect
  69 #undef FrameRect
  70 #undef GetCursor
  71 #undef InvertRect
  72 #undef OffsetRect
  73 #undef PtInRect
  74 #undef SetCursor
  75 #undef SetRect
  76 #undef ShowCursor
  77 #undef UnionRect
  78 #endif
  79
  80 #define COBJMACROS
  81
  82 #include "windef.h"
  83 #include "winbase.h"
  84 #include "objbase.h"
  85
  86 #include "wincodecs_private.h"
  87
  88 #include "wine/debug.h"
  89
  90 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  91
  92 #if defined(HAVE_APPLICATIONSERVICES_APPLICATIONSERVICES_H) && \
  93     MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4
  94
  95 typedef struct IcnsEncoder {
  96     IWICBitmapEncoder IWICBitmapEncoder_iface;
  97     LONG ref;
  98     IStream *stream;
  99     IconFamilyHandle icns_family;
 100     BOOL any_frame_committed;
 101     int outstanding_commits;
 102     BOOL committed;
 103     CRITICAL_SECTION lock;
 104 } IcnsEncoder;
 105
 106 static inline IcnsEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
 107 {
 108     return CONTAINING_RECORD(iface, IcnsEncoder, IWICBitmapEncoder_iface);
 109 }
 110
 111 typedef struct IcnsFrameEncode {
 112     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
 113     IcnsEncoder *encoder;
 114     LONG ref;
 115     BOOL initialized;
 116     UINT size;
 117     OSType icns_type;
 118     BYTE* icns_image;
 119     int lines_written;
 120     BOOL committed;
 121 } IcnsFrameEncode;
 122
 123 static inline IcnsFrameEncode *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
 124 {
 125     return CONTAINING_RECORD(iface, IcnsFrameEncode, IWICBitmapFrameEncode_iface);
 126 }
 127
 128 static HRESULT WINAPI IcnsFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
 129     void **ppv)
 130 {
 131     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 132     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 133
 134     if (!ppv) return E_INVALIDARG;
 135
 136     if (IsEqualIID(&IID_IUnknown, iid) ||
 137         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
 138     {
 139         *ppv = &This->IWICBitmapFrameEncode_iface;
 140     }
 141     else
 142     {
 143         *ppv = NULL;
 144         return E_NOINTERFACE;
 145     }
 146
 147     IUnknown_AddRef((IUnknown*)*ppv);
 148     return S_OK;
 149 }
 150
 151 static ULONG WINAPI IcnsFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
 152 {
 153     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 154     ULONG ref = InterlockedIncrement(&This->ref);
 155
 156     TRACE("(%p) refcount=%u\n", iface, ref);
 157
 158     return ref;
 159 }
 160
 161 static ULONG WINAPI IcnsFrameEncode_Release(IWICBitmapFrameEncode *iface)
 162 {
 163     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 164     ULONG ref = InterlockedDecrement(&This->ref);
 165
 166     TRACE("(%p) refcount=%u\n", iface, ref);
 167
 168     if (ref == 0)
 169     {
 170         if (!This->committed)
 171         {
 172             EnterCriticalSection(&This->encoder->lock);
 173             This->encoder->outstanding_commits--;
 174             LeaveCriticalSection(&This->encoder->lock);
 175         }
 176         HeapFree(GetProcessHeap(), 0, This->icns_image);
 177
 178         IWICBitmapEncoder_Release(&This->encoder->IWICBitmapEncoder_iface);
 179         HeapFree(GetProcessHeap(), 0, This);
 180     }
 181
 182     return ref;
 183 }
 184
 185 static HRESULT WINAPI IcnsFrameEncode_Initialize(IWICBitmapFrameEncode *iface,
 186     IPropertyBag2 *pIEncoderOptions)
 187 {
 188     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 189     HRESULT hr = S_OK;
 190
 191     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
 192
 193     EnterCriticalSection(&This->encoder->lock);
 194
 195     if (This->initialized)
 196     {
 197         hr = WINCODEC_ERR_WRONGSTATE;
 198         goto end;
 199     }
 200     This->initialized = TRUE;
 201
 202 end:
 203     LeaveCriticalSection(&This->encoder->lock);
 204     return hr;
 205 }
 206
 207 static HRESULT WINAPI IcnsFrameEncode_SetSize(IWICBitmapFrameEncode *iface,
 208     UINT uiWidth, UINT uiHeight)
 209 {
 210     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 211     HRESULT hr = S_OK;
 212
 213     TRACE("(%p,%u,%u)\n", iface, uiWidth, uiHeight);
 214
 215     EnterCriticalSection(&This->encoder->lock);
 216
 217     if (!This->initialized || This->icns_image)
 218     {
 219         hr = WINCODEC_ERR_WRONGSTATE;
 220         goto end;
 221     }
 222
 223     if (uiWidth != uiHeight)
 224     {
 225         WARN("cannot generate ICNS icon from %dx%d image\n", uiWidth, uiHeight);
 226         hr = E_INVALIDARG;
 227         goto end;
 228     }
 229
 230     switch (uiWidth)
 231     {
 232         case 16:
 233         case 32:
 234         case 48:
 235         case 128:
 236         case 256:
 237         case 512:
 238             break;
 239         default:
 240             WARN("cannot generate ICNS icon from %dx%d image\n", This->size, This->size);
 241             hr = E_INVALIDARG;
 242             goto end;
 243     }
 244
 245     This->size = uiWidth;
 246
 247 end:
 248     LeaveCriticalSection(&This->encoder->lock);
 249     return hr;
 250 }
 251
 252 static HRESULT WINAPI IcnsFrameEncode_SetResolution(IWICBitmapFrameEncode *iface,
 253     double dpiX, double dpiY)
 254 {
 255     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 256     HRESULT hr = S_OK;
 257
 258     TRACE("(%p,%0.2f,%0.2f)\n", iface, dpiX, dpiY);
 259
 260     EnterCriticalSection(&This->encoder->lock);
 261
 262     if (!This->initialized || This->icns_image)
 263     {
 264         hr = WINCODEC_ERR_WRONGSTATE;
 265         goto end;
 266     }
 267
 268 end:
 269     LeaveCriticalSection(&This->encoder->lock);
 270     return S_OK;
 271 }
 272
 273 static HRESULT WINAPI IcnsFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface,
 274     WICPixelFormatGUID *pPixelFormat)
 275 {
 276     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 277     HRESULT hr = S_OK;
 278
 279     TRACE("(%p,%s)\n", iface, debugstr_guid(pPixelFormat));
 280
 281     EnterCriticalSection(&This->encoder->lock);
 282
 283     if (!This->initialized || This->icns_image)
 284     {
 285         hr = WINCODEC_ERR_WRONGSTATE;
 286         goto end;
 287     }
 288
 289     memcpy(pPixelFormat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
 290
 291 end:
 292     LeaveCriticalSection(&This->encoder->lock);
 293     return S_OK;
 294 }
 295
 296 static HRESULT WINAPI IcnsFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface,
 297     UINT cCount, IWICColorContext **ppIColorContext)
 298 {
 299     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI IcnsFrameEncode_SetPalette(IWICBitmapFrameEncode *iface,
 304     IWICPalette *pIPalette)
 305 {
 306     FIXME("(%p,%p): stub\n", iface, pIPalette);
 307     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 308 }
 309
 310 static HRESULT WINAPI IcnsFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface,
 311     IWICBitmapSource *pIThumbnail)
 312 {
 313     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
 314     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 315 }
 316
 317 static HRESULT WINAPI IcnsFrameEncode_WritePixels(IWICBitmapFrameEncode *iface,
 318     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
 319 {
 320     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 321     HRESULT hr = S_OK;
 322     UINT i;
 323
 324     TRACE("(%p,%u,%u,%u,%p)\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
 325
 326     EnterCriticalSection(&This->encoder->lock);
 327
 328     if (!This->initialized || !This->size)
 329     {
 330         hr = WINCODEC_ERR_WRONGSTATE;
 331         goto end;
 332     }
 333     if (lineCount == 0 || lineCount + This->lines_written > This->size)
 334     {
 335         hr = E_INVALIDARG;
 336         goto end;
 337     }
 338
 339     if (!This->icns_image)
 340     {
 341         switch (This->size)
 342         {
 343             case 16:  This->icns_type = kIconServices16PixelDataARGB;  break;
 344             case 32:  This->icns_type = kIconServices32PixelDataARGB;  break;
 345             case 48:  This->icns_type = kIconServices48PixelDataARGB;  break;
 346             case 128: This->icns_type = kIconServices128PixelDataARGB; break;
 347             case 256: This->icns_type = kIconServices256PixelDataARGB; break;
 348             case 512: This->icns_type = kIconServices512PixelDataARGB; break;
 349             default:
 350                 WARN("cannot generate ICNS icon from %dx%d image\n", This->size, This->size);
 351                 hr = E_INVALIDARG;
 352                 goto end;
 353         }
 354         This->icns_image = HeapAlloc(GetProcessHeap(), 0, This->size * This->size * 4);
 355         if (!This->icns_image)
 356         {
 357             WARN("failed to allocate image buffer\n");
 358             hr = E_FAIL;
 359             goto end;
 360         }
 361     }
 362
 363     for (i = 0; i < lineCount; i++)
 364     {
 365         BYTE *src_row, *dst_row;
 366         UINT j;
 367         src_row = pbPixels + cbStride * i;
 368         dst_row = This->icns_image + (This->lines_written + i)*(This->size*4);
 369         /* swap bgr -> rgb */
 370         for (j = 0; j < This->size*4; j += 4)
 371         {
 372             dst_row[j] = src_row[j+3];
 373             dst_row[j+1] = src_row[j+2];
 374             dst_row[j+2] = src_row[j+1];
 375             dst_row[j+3] = src_row[j];
 376         }
 377     }
 378     This->lines_written += lineCount;
 379
 380 end:
 381     LeaveCriticalSection(&This->encoder->lock);
 382     return hr;
 383 }
 384
 385 static HRESULT WINAPI IcnsFrameEncode_WriteSource(IWICBitmapFrameEncode *iface,
 386     IWICBitmapSource *pIBitmapSource, WICRect *prc)
 387 {
 388     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 389     HRESULT hr;
 390
 391     TRACE("(%p,%p,%s)\n", iface, pIBitmapSource, debug_wic_rect(prc));
 392
 393     if (!This->initialized)
 394         return WINCODEC_ERR_WRONGSTATE;
 395
 396     hr = configure_write_source(iface, pIBitmapSource, prc,
 397         &GUID_WICPixelFormat32bppBGRA, This->size, This->size,
 398         1.0, 1.0);
 399
 400     if (SUCCEEDED(hr))
 401     {
 402         hr = write_source(iface, pIBitmapSource, prc,
 403             &GUID_WICPixelFormat32bppBGRA, 32, FALSE, This->size, This->size);
 404     }
 405
 406     return hr;
 407 }
 408
 409 static HRESULT WINAPI IcnsFrameEncode_Commit(IWICBitmapFrameEncode *iface)
 410 {
 411     IcnsFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
 412     Handle handle;
 413     OSErr ret;
 414     HRESULT hr = S_OK;
 415
 416     TRACE("(%p)\n", iface);
 417
 418     EnterCriticalSection(&This->encoder->lock);
 419
 420     if (!This->icns_image || This->lines_written != This->size || This->committed)
 421     {
 422         hr = WINCODEC_ERR_WRONGSTATE;
 423         goto end;
 424     }
 425
 426     ret = PtrToHand(This->icns_image, &handle, This->size * This->size * 4);
 427     if (ret != noErr || !handle)
 428     {
 429         WARN("PtrToHand failed with error %d\n", ret);
 430         hr = E_FAIL;
 431         goto end;
 432     }
 433
 434     ret = SetIconFamilyData(This->encoder->icns_family, This->icns_type, handle);
 435     DisposeHandle(handle);
 436
 437     if (ret != noErr)
 438         {
 439         WARN("SetIconFamilyData failed for image with error %d\n", ret);
 440         hr = E_FAIL;
 441         goto end;
 442         }
 443
 444     This->committed = TRUE;
 445     This->encoder->any_frame_committed = TRUE;
 446     This->encoder->outstanding_commits--;
 447
 448 end:
 449     LeaveCriticalSection(&This->encoder->lock);
 450     return hr;
 451 }
 452
 453 static HRESULT WINAPI IcnsFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
 454     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 455 {
 456     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
 457     return E_NOTIMPL;
 458 }
 459
 460 static const IWICBitmapFrameEncodeVtbl IcnsEncoder_FrameVtbl = {
 461     IcnsFrameEncode_QueryInterface,
 462     IcnsFrameEncode_AddRef,
 463     IcnsFrameEncode_Release,
 464     IcnsFrameEncode_Initialize,
 465     IcnsFrameEncode_SetSize,
 466     IcnsFrameEncode_SetResolution,
 467     IcnsFrameEncode_SetPixelFormat,
 468     IcnsFrameEncode_SetColorContexts,
 469     IcnsFrameEncode_SetPalette,
 470     IcnsFrameEncode_SetThumbnail,
 471     IcnsFrameEncode_WritePixels,
 472     IcnsFrameEncode_WriteSource,
 473     IcnsFrameEncode_Commit,
 474     IcnsFrameEncode_GetMetadataQueryWriter
 475 };
 476
 477 static HRESULT WINAPI IcnsEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
 478     void **ppv)
 479 {
 480     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 481     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 482
 483     if (!ppv) return E_INVALIDARG;
 484
 485     if (IsEqualIID(&IID_IUnknown, iid) ||
 486         IsEqualIID(&IID_IWICBitmapEncoder, iid))
 487     {
 488         *ppv = &This->IWICBitmapEncoder_iface;
 489     }
 490     else
 491     {
 492         *ppv = NULL;
 493         return E_NOINTERFACE;
 494     }
 495
 496     IUnknown_AddRef((IUnknown*)*ppv);
 497     return S_OK;
 498 }
 499
 500 static ULONG WINAPI IcnsEncoder_AddRef(IWICBitmapEncoder *iface)
 501 {
 502     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 503     ULONG ref = InterlockedIncrement(&This->ref);
 504
 505     TRACE("(%p) refcount=%u\n", iface, ref);
 506
 507     return ref;
 508 }
 509
 510 static ULONG WINAPI IcnsEncoder_Release(IWICBitmapEncoder *iface)
 511 {
 512     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 513     ULONG ref = InterlockedDecrement(&This->ref);
 514
 515     TRACE("(%p) refcount=%u\n", iface, ref);
 516
 517     if (ref == 0)
 518     {
 519         This->lock.DebugInfo->Spare[0] = 0;
 520         DeleteCriticalSection(&This->lock);
 521         if (This->icns_family)
 522             DisposeHandle((Handle)This->icns_family);
 523         if (This->stream)
 524             IStream_Release(This->stream);
 525         HeapFree(GetProcessHeap(), 0, This);
 526     }
 527
 528     return ref;
 529 }
 530
 531 static HRESULT WINAPI IcnsEncoder_Initialize(IWICBitmapEncoder *iface,
 532     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
 533 {
 534     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 535     HRESULT hr = S_OK;
 536
 537     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
 538
 539     EnterCriticalSection(&This->lock);
 540
 541     if (This->icns_family)
 542     {
 543         hr = WINCODEC_ERR_WRONGSTATE;
 544         goto end;
 545     }
 546     This->icns_family = (IconFamilyHandle)NewHandle(0);
 547     if (!This->icns_family)
 548     {
 549         WARN("error creating icns family\n");
 550         hr = E_FAIL;
 551         goto end;
 552     }
 553     IStream_AddRef(pIStream);
 554     This->stream = pIStream;
 555
 556 end:
 557     LeaveCriticalSection(&This->lock);
 558
 559     return hr;
 560 }
 561
 562 static HRESULT WINAPI IcnsEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
 563     GUID *pguidContainerFormat)
 564 {
 565     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
 566     return E_NOTIMPL;
 567 }
 568
 569 static HRESULT WINAPI IcnsEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
 570     IWICBitmapEncoderInfo **ppIEncoderInfo)
 571 {
 572     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI IcnsEncoder_SetColorContexts(IWICBitmapEncoder *iface,
 577     UINT cCount, IWICColorContext **ppIColorContext)
 578 {
 579     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI IcnsEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
 584 {
 585     TRACE("(%p,%p)\n", iface, pIPalette);
 586     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 587 }
 588
 589 static HRESULT WINAPI IcnsEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
 590 {
 591     TRACE("(%p,%p)\n", iface, pIThumbnail);
 592     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 593 }
 594
 595 static HRESULT WINAPI IcnsEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
 596 {
 597     TRACE("(%p,%p)\n", iface, pIPreview);
 598     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 599 }
 600
 601 static HRESULT WINAPI IcnsEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
 602     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
 603 {
 604     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 605     HRESULT hr = S_OK;
 606     IcnsFrameEncode *frameEncode = NULL;
 607
 608     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
 609
 610     EnterCriticalSection(&This->lock);
 611
 612     if (!This->icns_family)
 613     {
 614         hr = WINCODEC_ERR_NOTINITIALIZED;
 615         goto end;
 616     }
 617
 618     if (ppIEncoderOptions)
 619     {
 620         hr = CreatePropertyBag2(NULL, 0, ppIEncoderOptions);
 621         if (FAILED(hr))
 622             goto end;
 623     }
 624
 625     frameEncode = HeapAlloc(GetProcessHeap(), 0, sizeof(IcnsFrameEncode));
 626     if (frameEncode == NULL)
 627     {
 628         hr = E_OUTOFMEMORY;
 629         goto end;
 630     }
 631     frameEncode->IWICBitmapFrameEncode_iface.lpVtbl = &IcnsEncoder_FrameVtbl;
 632     frameEncode->encoder = This;
 633     frameEncode->ref = 1;
 634     frameEncode->initialized = FALSE;
 635     frameEncode->size = 0;
 636     frameEncode->icns_image = NULL;
 637     frameEncode->lines_written = 0;
 638     frameEncode->committed = FALSE;
 639     *ppIFrameEncode = &frameEncode->IWICBitmapFrameEncode_iface;
 640     This->outstanding_commits++;
 641     IWICBitmapEncoder_AddRef(&This->IWICBitmapEncoder_iface);
 642
 643 end:
 644     LeaveCriticalSection(&This->lock);
 645
 646     return hr;
 647 }
 648
 649 static HRESULT WINAPI IcnsEncoder_Commit(IWICBitmapEncoder *iface)
 650 {
 651     IcnsEncoder *This = impl_from_IWICBitmapEncoder(iface);
 652     size_t buffer_size;
 653     HRESULT hr = S_OK;
 654     ULONG byteswritten;
 655
 656     TRACE("(%p)\n", iface);
 657
 658     EnterCriticalSection(&This->lock);
 659
 660     if (!This->any_frame_committed || This->outstanding_commits > 0 || This->committed)
 661     {
 662         hr = WINCODEC_ERR_WRONGSTATE;
 663         goto end;
 664     }
 665
 666     buffer_size = GetHandleSize((Handle)This->icns_family);
 667     hr = IStream_Write(This->stream, *This->icns_family, buffer_size, &byteswritten);
 668     if (FAILED(hr) || byteswritten != buffer_size)
 669     {
 670         WARN("writing file failed, hr = 0x%08X\n", hr);
 671         hr = E_FAIL;
 672         goto end;
 673     }
 674
 675     This->committed = TRUE;
 676
 677 end:
 678     LeaveCriticalSection(&This->lock);
 679     return hr;
 680 }
 681
 682 static HRESULT WINAPI IcnsEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
 683     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 684 {
 685     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
 686     return E_NOTIMPL;
 687 }
 688
 689 static const IWICBitmapEncoderVtbl IcnsEncoder_Vtbl = {
 690     IcnsEncoder_QueryInterface,
 691     IcnsEncoder_AddRef,
 692     IcnsEncoder_Release,
 693     IcnsEncoder_Initialize,
 694     IcnsEncoder_GetContainerFormat,
 695     IcnsEncoder_GetEncoderInfo,
 696     IcnsEncoder_SetColorContexts,
 697     IcnsEncoder_SetPalette,
 698     IcnsEncoder_SetThumbnail,
 699     IcnsEncoder_SetPreview,
 700     IcnsEncoder_CreateNewFrame,
 701     IcnsEncoder_Commit,
 702     IcnsEncoder_GetMetadataQueryWriter
 703 };
 704
 705 HRESULT IcnsEncoder_CreateInstance(REFIID iid, void** ppv)
 706 {
 707     IcnsEncoder *This;
 708     HRESULT ret;
 709
 710     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 711
 712     *ppv = NULL;
 713
 714     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IcnsEncoder));
 715     if (!This) return E_OUTOFMEMORY;
 716
 717     This->IWICBitmapEncoder_iface.lpVtbl = &IcnsEncoder_Vtbl;
 718     This->ref = 1;
 719     This->stream = NULL;
 720     This->icns_family = NULL;
 721     This->any_frame_committed = FALSE;
 722     This->outstanding_commits = 0;
 723     This->committed = FALSE;
 724     InitializeCriticalSection(&This->lock);
 725     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IcnsEncoder.lock");
 726
 727     ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
 728     IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
 729
 730     return ret;
 731 }
 732
 733 #else /* !defined(HAVE_APPLICATIONSERVICES_APPLICATIONSERVICES_H) ||
 734          MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4 */
 735
 736 HRESULT IcnsEncoder_CreateInstance(REFIID iid, void** ppv)
 737 {
 738     ERR("Trying to save ICNS picture, but ICNS support is not compiled in.\n");
 739     return E_FAIL;
 740 }
 741
 742 #endif