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