dlls/windowscodecs/jpegformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #ifdef HAVE_UNISTD_H
  23 # include <unistd.h>
  24 #endif
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <setjmp.h>
  29
  30 #ifdef SONAME_LIBJPEG
  31 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
  32 #define XMD_H
  33 #define UINT8 JPEG_UINT8
  34 #define UINT16 JPEG_UINT16
  35 #define boolean jpeg_boolean
  36 #undef HAVE_STDLIB_H
  37 # include <jpeglib.h>
  38 #undef HAVE_STDLIB_H
  39 #define HAVE_STDLIB_H 1
  40 #undef UINT8
  41 #undef UINT16
  42 #undef boolean
  43 #endif
  44
  45 #define COBJMACROS
  46
  47 #include "windef.h"
  48 #include "winbase.h"
  49 #include "objbase.h"
  50 #include "wincodec.h"
  51
  52 #include "wincodecs_private.h"
  53
  54 #include "wine/debug.h"
  55 #include "wine/library.h"
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  58
  59 #ifdef SONAME_LIBJPEG
  60 WINE_DECLARE_DEBUG_CHANNEL(jpeg);
  61
  62 static void *libjpeg_handle;
  63
  64 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  65 MAKE_FUNCPTR(jpeg_CreateCompress);
  66 MAKE_FUNCPTR(jpeg_CreateDecompress);
  67 MAKE_FUNCPTR(jpeg_destroy_compress);
  68 MAKE_FUNCPTR(jpeg_destroy_decompress);
  69 MAKE_FUNCPTR(jpeg_read_header);
  70 MAKE_FUNCPTR(jpeg_read_scanlines);
  71 MAKE_FUNCPTR(jpeg_resync_to_restart);
  72 MAKE_FUNCPTR(jpeg_start_decompress);
  73 MAKE_FUNCPTR(jpeg_std_error);
  74 #undef MAKE_FUNCPTR
  75
  76 static void *load_libjpeg(void)
  77 {
  78     if((libjpeg_handle = wine_dlopen(SONAME_LIBJPEG, RTLD_NOW, NULL, 0)) != NULL) {
  79
  80 #define LOAD_FUNCPTR(f) \
  81     if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
  82         libjpeg_handle = NULL; \
  83         return NULL; \
  84     }
  85
  86         LOAD_FUNCPTR(jpeg_CreateCompress);
  87         LOAD_FUNCPTR(jpeg_CreateDecompress);
  88         LOAD_FUNCPTR(jpeg_destroy_compress);
  89         LOAD_FUNCPTR(jpeg_destroy_decompress);
  90         LOAD_FUNCPTR(jpeg_read_header);
  91         LOAD_FUNCPTR(jpeg_read_scanlines);
  92         LOAD_FUNCPTR(jpeg_resync_to_restart);
  93         LOAD_FUNCPTR(jpeg_start_decompress);
  94         LOAD_FUNCPTR(jpeg_std_error);
  95 #undef LOAD_FUNCPTR
  96     }
  97     return libjpeg_handle;
  98 }
  99
 100 static void error_exit_fn(j_common_ptr cinfo)
 101 {
 102     char message[JMSG_LENGTH_MAX];
 103     if (ERR_ON(jpeg))
 104     {
 105         cinfo->err->format_message(cinfo, message);
 106         ERR_(jpeg)("%s\n", message);
 107     }
 108     longjmp(*(jmp_buf*)cinfo->client_data, 1);
 109 }
 110
 111 static void emit_message_fn(j_common_ptr cinfo, int msg_level)
 112 {
 113     char message[JMSG_LENGTH_MAX];
 114
 115     if (msg_level < 0 && ERR_ON(jpeg))
 116     {
 117         cinfo->err->format_message(cinfo, message);
 118         ERR_(jpeg)("%s\n", message);
 119     }
 120     else if (msg_level == 0 && WARN_ON(jpeg))
 121     {
 122         cinfo->err->format_message(cinfo, message);
 123         WARN_(jpeg)("%s\n", message);
 124     }
 125     else if (msg_level > 0 && TRACE_ON(jpeg))
 126     {
 127         cinfo->err->format_message(cinfo, message);
 128         TRACE_(jpeg)("%s\n", message);
 129     }
 130 }
 131
 132 typedef struct {
 133     IWICBitmapDecoder IWICBitmapDecoder_iface;
 134     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 135     LONG ref;
 136     BOOL initialized;
 137     BOOL cinfo_initialized;
 138     IStream *stream;
 139     struct jpeg_decompress_struct cinfo;
 140     struct jpeg_error_mgr jerr;
 141     struct jpeg_source_mgr source_mgr;
 142     BYTE source_buffer[1024];
 143     BYTE *image_data;
 144     CRITICAL_SECTION lock;
 145 } JpegDecoder;
 146
 147 static inline JpegDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 148 {
 149     return CONTAINING_RECORD(iface, JpegDecoder, IWICBitmapDecoder_iface);
 150 }
 151
 152 static inline JpegDecoder *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 153 {
 154     return CONTAINING_RECORD(iface, JpegDecoder, IWICBitmapFrameDecode_iface);
 155 }
 156
 157 static inline JpegDecoder *decoder_from_decompress(j_decompress_ptr decompress)
 158 {
 159     return CONTAINING_RECORD(decompress, JpegDecoder, cinfo);
 160 }
 161
 162 static HRESULT WINAPI JpegDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 163     void **ppv)
 164 {
 165     JpegDecoder *This = impl_from_IWICBitmapDecoder(iface);
 166     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 167
 168     if (!ppv) return E_INVALIDARG;
 169
 170     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
 171     {
 172         *ppv = This;
 173     }
 174     else
 175     {
 176         *ppv = NULL;
 177         return E_NOINTERFACE;
 178     }
 179
 180     IUnknown_AddRef((IUnknown*)*ppv);
 181     return S_OK;
 182 }
 183
 184 static ULONG WINAPI JpegDecoder_AddRef(IWICBitmapDecoder *iface)
 185 {
 186     JpegDecoder *This = impl_from_IWICBitmapDecoder(iface);
 187     ULONG ref = InterlockedIncrement(&This->ref);
 188
 189     TRACE("(%p) refcount=%u\n", iface, ref);
 190
 191     return ref;
 192 }
 193
 194 static ULONG WINAPI JpegDecoder_Release(IWICBitmapDecoder *iface)
 195 {
 196     JpegDecoder *This = impl_from_IWICBitmapDecoder(iface);
 197     ULONG ref = InterlockedDecrement(&This->ref);
 198
 199     TRACE("(%p) refcount=%u\n", iface, ref);
 200
 201     if (ref == 0)
 202     {
 203         This->lock.DebugInfo->Spare[0] = 0;
 204         DeleteCriticalSection(&This->lock);
 205         if (This->cinfo_initialized) pjpeg_destroy_decompress(&This->cinfo);
 206         if (This->stream) IStream_Release(This->stream);
 207         HeapFree(GetProcessHeap(), 0, This->image_data);
 208         HeapFree(GetProcessHeap(), 0, This);
 209     }
 210
 211     return ref;
 212 }
 213
 214 static HRESULT WINAPI JpegDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
 215     DWORD *pdwCapability)
 216 {
 217     FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
 218     return E_NOTIMPL;
 219 }
 220
 221 static void source_mgr_init_source(j_decompress_ptr cinfo)
 222 {
 223 }
 224
 225 static jpeg_boolean source_mgr_fill_input_buffer(j_decompress_ptr cinfo)
 226 {
 227     JpegDecoder *This = decoder_from_decompress(cinfo);
 228     HRESULT hr;
 229     ULONG bytesread;
 230
 231     hr = IStream_Read(This->stream, This->source_buffer, 1024, &bytesread);
 232
 233     if (hr != S_OK || bytesread == 0)
 234     {
 235         return FALSE;
 236     }
 237     else
 238     {
 239         This->source_mgr.next_input_byte = This->source_buffer;
 240         This->source_mgr.bytes_in_buffer = bytesread;
 241         return TRUE;
 242     }
 243 }
 244
 245 static void source_mgr_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
 246 {
 247     JpegDecoder *This = decoder_from_decompress(cinfo);
 248     LARGE_INTEGER seek;
 249
 250     if (num_bytes > This->source_mgr.bytes_in_buffer)
 251     {
 252         seek.QuadPart = num_bytes - This->source_mgr.bytes_in_buffer;
 253         IStream_Seek(This->stream, seek, STREAM_SEEK_CUR, NULL);
 254         This->source_mgr.bytes_in_buffer = 0;
 255     }
 256     else if (num_bytes > 0)
 257     {
 258         This->source_mgr.next_input_byte += num_bytes;
 259         This->source_mgr.bytes_in_buffer -= num_bytes;
 260     }
 261 }
 262
 263 static void source_mgr_term_source(j_decompress_ptr cinfo)
 264 {
 265 }
 266
 267 static HRESULT WINAPI JpegDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 268     WICDecodeOptions cacheOptions)
 269 {
 270     JpegDecoder *This = impl_from_IWICBitmapDecoder(iface);
 271     int ret;
 272     LARGE_INTEGER seek;
 273     jmp_buf jmpbuf;
 274     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOptions);
 275
 276     EnterCriticalSection(&This->lock);
 277
 278     if (This->cinfo_initialized)
 279     {
 280         LeaveCriticalSection(&This->lock);
 281         return WINCODEC_ERR_WRONGSTATE;
 282     }
 283
 284     pjpeg_std_error(&This->jerr);
 285
 286     This->jerr.error_exit = error_exit_fn;
 287     This->jerr.emit_message = emit_message_fn;
 288
 289     This->cinfo.err = &This->jerr;
 290
 291     This->cinfo.client_data = jmpbuf;
 292
 293     if (setjmp(jmpbuf))
 294     {
 295         LeaveCriticalSection(&This->lock);
 296         return E_FAIL;
 297     }
 298
 299     pjpeg_CreateDecompress(&This->cinfo, JPEG_LIB_VERSION, sizeof(struct jpeg_decompress_struct));
 300
 301     This->cinfo_initialized = TRUE;
 302
 303     This->stream = pIStream;
 304     IStream_AddRef(pIStream);
 305
 306     seek.QuadPart = 0;
 307     IStream_Seek(This->stream, seek, STREAM_SEEK_SET, NULL);
 308
 309     This->source_mgr.bytes_in_buffer = 0;
 310     This->source_mgr.init_source = source_mgr_init_source;
 311     This->source_mgr.fill_input_buffer = source_mgr_fill_input_buffer;
 312     This->source_mgr.skip_input_data = source_mgr_skip_input_data;
 313     This->source_mgr.resync_to_restart = pjpeg_resync_to_restart;
 314     This->source_mgr.term_source = source_mgr_term_source;
 315
 316     This->cinfo.src = &This->source_mgr;
 317
 318     ret = pjpeg_read_header(&This->cinfo, TRUE);
 319
 320     if (ret != JPEG_HEADER_OK) {
 321         WARN("Jpeg image in stream has bad format, read header returned %d.\n",ret);
 322         LeaveCriticalSection(&This->lock);
 323         return E_FAIL;
 324     }
 325
 326     switch (This->cinfo.jpeg_color_space)
 327     {
 328     case JCS_GRAYSCALE:
 329         This->cinfo.out_color_space = JCS_GRAYSCALE;
 330         break;
 331     case JCS_RGB:
 332     case JCS_YCbCr:
 333         This->cinfo.out_color_space = JCS_RGB;
 334         break;
 335     case JCS_CMYK:
 336     case JCS_YCCK:
 337         This->cinfo.out_color_space = JCS_CMYK;
 338         break;
 339     default:
 340         ERR("Unknown JPEG color space %i\n", This->cinfo.jpeg_color_space);
 341         LeaveCriticalSection(&This->lock);
 342         return E_FAIL;
 343     }
 344
 345     if (!pjpeg_start_decompress(&This->cinfo))
 346     {
 347         ERR("jpeg_start_decompress failed\n");
 348         LeaveCriticalSection(&This->lock);
 349         return E_FAIL;
 350     }
 351
 352     This->initialized = TRUE;
 353
 354     LeaveCriticalSection(&This->lock);
 355
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI JpegDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 360     GUID *pguidContainerFormat)
 361 {
 362     memcpy(pguidContainerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID));
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI JpegDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 367     IWICBitmapDecoderInfo **ppIDecoderInfo)
 368 {
 369     HRESULT hr;
 370     IWICComponentInfo *compinfo;
 371
 372     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 373
 374     hr = CreateComponentInfo(&CLSID_WICJpegDecoder, &compinfo);
 375     if (FAILED(hr)) return hr;
 376
 377     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
 378         (void**)ppIDecoderInfo);
 379
 380     IWICComponentInfo_Release(compinfo);
 381
 382     return hr;
 383 }
 384
 385 static HRESULT WINAPI JpegDecoder_CopyPalette(IWICBitmapDecoder *iface,
 386     IWICPalette *pIPalette)
 387 {
 388     TRACE("(%p,%p)\n", iface, pIPalette);
 389
 390     return WINCODEC_ERR_PALETTEUNAVAILABLE;
 391 }
 392
 393 static HRESULT WINAPI JpegDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 394     IWICMetadataQueryReader **ppIMetadataQueryReader)
 395 {
 396     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI JpegDecoder_GetPreview(IWICBitmapDecoder *iface,
 401     IWICBitmapSource **ppIBitmapSource)
 402 {
 403     FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
 404     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 405 }
 406
 407 static HRESULT WINAPI JpegDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 408     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 409 {
 410     FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
 411     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 412 }
 413
 414 static HRESULT WINAPI JpegDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 415     IWICBitmapSource **ppIThumbnail)
 416 {
 417     FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
 418     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 419 }
 420
 421 static HRESULT WINAPI JpegDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 422     UINT *pCount)
 423 {
 424     *pCount = 1;
 425     return S_OK;
 426 }
 427
 428 static HRESULT WINAPI JpegDecoder_GetFrame(IWICBitmapDecoder *iface,
 429     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 430 {
 431     JpegDecoder *This = impl_from_IWICBitmapDecoder(iface);
 432     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 433
 434     if (!This->initialized) return WINCODEC_ERR_NOTINITIALIZED;
 435
 436     if (index != 0) return E_INVALIDARG;
 437
 438     IWICBitmapDecoder_AddRef(iface);
 439     *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
 440
 441     return S_OK;
 442 }
 443
 444 static const IWICBitmapDecoderVtbl JpegDecoder_Vtbl = {
 445     JpegDecoder_QueryInterface,
 446     JpegDecoder_AddRef,
 447     JpegDecoder_Release,
 448     JpegDecoder_QueryCapability,
 449     JpegDecoder_Initialize,
 450     JpegDecoder_GetContainerFormat,
 451     JpegDecoder_GetDecoderInfo,
 452     JpegDecoder_CopyPalette,
 453     JpegDecoder_GetMetadataQueryReader,
 454     JpegDecoder_GetPreview,
 455     JpegDecoder_GetColorContexts,
 456     JpegDecoder_GetThumbnail,
 457     JpegDecoder_GetFrameCount,
 458     JpegDecoder_GetFrame
 459 };
 460
 461 static HRESULT WINAPI JpegDecoder_Frame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 462     void **ppv)
 463 {
 464     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 465
 466     if (!ppv) return E_INVALIDARG;
 467
 468     if (IsEqualIID(&IID_IUnknown, iid) ||
 469         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 470         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
 471     {
 472         *ppv = iface;
 473     }
 474     else
 475     {
 476         *ppv = NULL;
 477         return E_NOINTERFACE;
 478     }
 479
 480     IUnknown_AddRef((IUnknown*)*ppv);
 481     return S_OK;
 482 }
 483
 484 static ULONG WINAPI JpegDecoder_Frame_AddRef(IWICBitmapFrameDecode *iface)
 485 {
 486     JpegDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 487     return IUnknown_AddRef((IUnknown*)This);
 488 }
 489
 490 static ULONG WINAPI JpegDecoder_Frame_Release(IWICBitmapFrameDecode *iface)
 491 {
 492     JpegDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 493     return IUnknown_Release((IUnknown*)This);
 494 }
 495
 496 static HRESULT WINAPI JpegDecoder_Frame_GetSize(IWICBitmapFrameDecode *iface,
 497     UINT *puiWidth, UINT *puiHeight)
 498 {
 499     JpegDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 500     *puiWidth = This->cinfo.output_width;
 501     *puiHeight = This->cinfo.output_height;
 502     TRACE("(%p)->(%u,%u)\n", iface, *puiWidth, *puiHeight);
 503     return S_OK;
 504 }
 505
 506 static HRESULT WINAPI JpegDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode *iface,
 507     WICPixelFormatGUID *pPixelFormat)
 508 {
 509     JpegDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 510     TRACE("(%p,%p)\n", iface, pPixelFormat);
 511     if (This->cinfo.out_color_space == JCS_RGB)
 512         memcpy(pPixelFormat, &GUID_WICPixelFormat24bppBGR, sizeof(GUID));
 513     else if (This->cinfo.out_color_space == JCS_CMYK)
 514         memcpy(pPixelFormat, &GUID_WICPixelFormat32bppCMYK, sizeof(GUID));
 515     else /* This->cinfo.out_color_space == JCS_GRAYSCALE */
 516         memcpy(pPixelFormat, &GUID_WICPixelFormat8bppGray, sizeof(GUID));
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI JpegDecoder_Frame_GetResolution(IWICBitmapFrameDecode *iface,
 521     double *pDpiX, double *pDpiY)
 522 {
 523     FIXME("(%p,%p,%p): stub\n", iface, pDpiX, pDpiY);
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI JpegDecoder_Frame_CopyPalette(IWICBitmapFrameDecode *iface,
 528     IWICPalette *pIPalette)
 529 {
 530     FIXME("(%p,%p): stub\n", iface, pIPalette);
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT WINAPI JpegDecoder_Frame_CopyPixels(IWICBitmapFrameDecode *iface,
 535     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 536 {
 537     JpegDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 538     UINT bpp;
 539     UINT stride;
 540     UINT data_size;
 541     UINT max_row_needed;
 542     jmp_buf jmpbuf;
 543     WICRect rect;
 544     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
 545
 546     if (!prc)
 547     {
 548         rect.X = 0;
 549         rect.Y = 0;
 550         rect.Width = This->cinfo.output_width;
 551         rect.Height = This->cinfo.output_height;
 552         prc = &rect;
 553     }
 554     else
 555     {
 556         if (prc->X < 0 || prc->Y < 0 || prc->X+prc->Width > This->cinfo.output_width ||
 557             prc->Y+prc->Height > This->cinfo.output_height)
 558             return E_INVALIDARG;
 559     }
 560
 561     if (This->cinfo.out_color_space == JCS_GRAYSCALE) bpp = 8;
 562     else if (This->cinfo.out_color_space == JCS_CMYK) bpp = 32;
 563     else bpp = 24;
 564
 565     stride = bpp * This->cinfo.output_width;
 566     data_size = stride * This->cinfo.output_height;
 567
 568     max_row_needed = prc->Y + prc->Height;
 569     if (max_row_needed > This->cinfo.output_height) return E_INVALIDARG;
 570
 571     EnterCriticalSection(&This->lock);
 572
 573     if (!This->image_data)
 574     {
 575         This->image_data = HeapAlloc(GetProcessHeap(), 0, data_size);
 576         if (!This->image_data)
 577         {
 578             LeaveCriticalSection(&This->lock);
 579             return E_OUTOFMEMORY;
 580         }
 581     }
 582
 583     This->cinfo.client_data = jmpbuf;
 584
 585     if (setjmp(jmpbuf))
 586     {
 587         LeaveCriticalSection(&This->lock);
 588         return E_FAIL;
 589     }
 590
 591     while (max_row_needed > This->cinfo.output_scanline)
 592     {
 593         UINT first_scanline = This->cinfo.output_scanline;
 594         UINT max_rows;
 595         JSAMPROW out_rows[4];
 596         UINT i;
 597         JDIMENSION ret;
 598
 599         max_rows = min(This->cinfo.output_height-first_scanline, 4);
 600         for (i=0; i<max_rows; i++)
 601             out_rows[i] = This->image_data + stride * (first_scanline+i);
 602
 603         ret = pjpeg_read_scanlines(&This->cinfo, out_rows, max_rows);
 604
 605         if (ret == 0)
 606         {
 607             ERR("read_scanlines failed\n");
 608             LeaveCriticalSection(&This->lock);
 609             return E_FAIL;
 610         }
 611
 612         if (bpp == 24)
 613         {
 614             /* libjpeg gives us RGB data and we want BGR, so byteswap the data */
 615             reverse_bgr8(3, This->image_data + stride * first_scanline,
 616                 This->cinfo.output_width, This->cinfo.output_scanline - first_scanline,
 617                 stride);
 618         }
 619
 620         if (This->cinfo.out_color_space == JCS_CMYK && This->cinfo.saw_Adobe_marker)
 621             /* Adobe JPEG's have inverted CMYK data. */
 622             for (i=0; i<data_size; i++)
 623                 This->image_data[i] ^= 0xff;
 624     }
 625
 626     LeaveCriticalSection(&This->lock);
 627
 628     return copy_pixels(bpp, This->image_data,
 629         This->cinfo.output_width, This->cinfo.output_height, stride,
 630         prc, cbStride, cbBufferSize, pbBuffer);
 631 }
 632
 633 static HRESULT WINAPI JpegDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 634     IWICMetadataQueryReader **ppIMetadataQueryReader)
 635 {
 636     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 637     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 638 }
 639
 640 static HRESULT WINAPI JpegDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode *iface,
 641     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 642 {
 643     FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
 644     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 645 }
 646
 647 static HRESULT WINAPI JpegDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode *iface,
 648     IWICBitmapSource **ppIThumbnail)
 649 {
 650     FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
 651     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 652 }
 653
 654 static const IWICBitmapFrameDecodeVtbl JpegDecoder_Frame_Vtbl = {
 655     JpegDecoder_Frame_QueryInterface,
 656     JpegDecoder_Frame_AddRef,
 657     JpegDecoder_Frame_Release,
 658     JpegDecoder_Frame_GetSize,
 659     JpegDecoder_Frame_GetPixelFormat,
 660     JpegDecoder_Frame_GetResolution,
 661     JpegDecoder_Frame_CopyPalette,
 662     JpegDecoder_Frame_CopyPixels,
 663     JpegDecoder_Frame_GetMetadataQueryReader,
 664     JpegDecoder_Frame_GetColorContexts,
 665     JpegDecoder_Frame_GetThumbnail
 666 };
 667
 668 HRESULT JpegDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 669 {
 670     JpegDecoder *This;
 671     HRESULT ret;
 672
 673     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
 674
 675     if (!libjpeg_handle && !load_libjpeg())
 676     {
 677         ERR("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG);
 678         return E_FAIL;
 679     }
 680
 681     *ppv = NULL;
 682
 683     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 684
 685     This = HeapAlloc(GetProcessHeap(), 0, sizeof(JpegDecoder));
 686     if (!This) return E_OUTOFMEMORY;
 687
 688     This->IWICBitmapDecoder_iface.lpVtbl = &JpegDecoder_Vtbl;
 689     This->IWICBitmapFrameDecode_iface.lpVtbl = &JpegDecoder_Frame_Vtbl;
 690     This->ref = 1;
 691     This->initialized = FALSE;
 692     This->cinfo_initialized = FALSE;
 693     This->stream = NULL;
 694     This->image_data = NULL;
 695     InitializeCriticalSection(&This->lock);
 696     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JpegDecoder.lock");
 697
 698     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
 699     IUnknown_Release((IUnknown*)This);
 700
 701     return ret;
 702 }
 703
 704 typedef struct JpegEncoder {
 705     IWICBitmapEncoder IWICBitmapEncoder_iface;
 706     IWICBitmapFrameEncode IWICBitmapFrameEncode_iface;
 707     LONG ref;
 708     struct jpeg_compress_struct cinfo;
 709     struct jpeg_error_mgr jerr;
 710     struct jpeg_destination_mgr dest_mgr;
 711     int initialized;
 712     int frame_count;
 713     int frame_initialized;
 714     IStream *stream;
 715     CRITICAL_SECTION lock;
 716     BYTE dest_buffer[1024];
 717 } JpegEncoder;
 718
 719 static inline JpegEncoder *impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
 720 {
 721     return CONTAINING_RECORD(iface, JpegEncoder, IWICBitmapEncoder_iface);
 722 }
 723
 724 static inline JpegEncoder *impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
 725 {
 726     return CONTAINING_RECORD(iface, JpegEncoder, IWICBitmapFrameEncode_iface);
 727 }
 728
 729 static inline JpegEncoder *encoder_from_compress(j_compress_ptr compress)
 730 {
 731     return CONTAINING_RECORD(compress, JpegEncoder, cinfo);
 732 }
 733
 734 static void dest_mgr_init_destination(j_compress_ptr cinfo)
 735 {
 736     JpegEncoder *This = encoder_from_compress(cinfo);
 737
 738     This->dest_mgr.next_output_byte = This->dest_buffer;
 739     This->dest_mgr.free_in_buffer = sizeof(This->dest_buffer);
 740 }
 741
 742 static jpeg_boolean dest_mgr_empty_output_buffer(j_compress_ptr cinfo)
 743 {
 744     JpegEncoder *This = encoder_from_compress(cinfo);
 745     HRESULT hr;
 746     ULONG byteswritten;
 747
 748     hr = IStream_Write(This->stream, This->dest_buffer,
 749         sizeof(This->dest_buffer), &byteswritten);
 750
 751     if (hr != S_OK || byteswritten == 0)
 752     {
 753         ERR("Failed writing data, hr=%x\n", hr);
 754         return FALSE;
 755     }
 756
 757     This->dest_mgr.next_output_byte = This->dest_buffer;
 758     This->dest_mgr.free_in_buffer = sizeof(This->dest_buffer);
 759     return TRUE;
 760 }
 761
 762 static void dest_mgr_term_destination(j_compress_ptr cinfo)
 763 {
 764     JpegEncoder *This = encoder_from_compress(cinfo);
 765     ULONG byteswritten;
 766     HRESULT hr;
 767
 768     if (This->dest_mgr.free_in_buffer != sizeof(This->dest_buffer))
 769     {
 770         hr = IStream_Write(This->stream, This->dest_buffer,
 771             sizeof(This->dest_buffer) - This->dest_mgr.free_in_buffer, &byteswritten);
 772
 773         if (hr != S_OK || byteswritten == 0)
 774             ERR("Failed writing data, hr=%x\n", hr);
 775     }
 776 }
 777
 778 static HRESULT WINAPI JpegEncoder_Frame_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid,
 779     void **ppv)
 780 {
 781     JpegEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 782     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 783
 784     if (!ppv) return E_INVALIDARG;
 785
 786     if (IsEqualIID(&IID_IUnknown, iid) ||
 787         IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
 788     {
 789         *ppv = &This->IWICBitmapFrameEncode_iface;
 790     }
 791     else
 792     {
 793         *ppv = NULL;
 794         return E_NOINTERFACE;
 795     }
 796
 797     IUnknown_AddRef((IUnknown*)*ppv);
 798     return S_OK;
 799 }
 800
 801 static ULONG WINAPI JpegEncoder_Frame_AddRef(IWICBitmapFrameEncode *iface)
 802 {
 803     JpegEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 804     return IWICBitmapEncoder_AddRef(&This->IWICBitmapEncoder_iface);
 805 }
 806
 807 static ULONG WINAPI JpegEncoder_Frame_Release(IWICBitmapFrameEncode *iface)
 808 {
 809     JpegEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 810     return IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
 811 }
 812
 813 static HRESULT WINAPI JpegEncoder_Frame_Initialize(IWICBitmapFrameEncode *iface,
 814     IPropertyBag2 *pIEncoderOptions)
 815 {
 816     JpegEncoder *This = impl_from_IWICBitmapFrameEncode(iface);
 817     TRACE("(%p,%p)\n", iface, pIEncoderOptions);
 818
 819     EnterCriticalSection(&This->lock);
 820
 821     if (This->frame_initialized)
 822     {
 823         LeaveCriticalSection(&This->lock);
 824         return WINCODEC_ERR_WRONGSTATE;
 825     }
 826
 827     This->frame_initialized = TRUE;
 828
 829     LeaveCriticalSection(&This->lock);
 830
 831     return S_OK;
 832 }
 833
 834 static HRESULT WINAPI JpegEncoder_Frame_SetSize(IWICBitmapFrameEncode *iface,
 835     UINT uiWidth, UINT uiHeight)
 836 {
 837     FIXME("(%p,%u,%u): stub\n", iface, uiWidth, uiHeight);
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI JpegEncoder_Frame_SetResolution(IWICBitmapFrameEncode *iface,
 842     double dpiX, double dpiY)
 843 {
 844     FIXME("(%p,%0.2f,%0.2f): stub\n", iface, dpiX, dpiY);
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI JpegEncoder_Frame_SetPixelFormat(IWICBitmapFrameEncode *iface,
 849     WICPixelFormatGUID *pPixelFormat)
 850 {
 851     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pPixelFormat));
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI JpegEncoder_Frame_SetColorContexts(IWICBitmapFrameEncode *iface,
 856     UINT cCount, IWICColorContext **ppIColorContext)
 857 {
 858     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI JpegEncoder_Frame_SetPalette(IWICBitmapFrameEncode *iface,
 863     IWICPalette *pIPalette)
 864 {
 865     FIXME("(%p,%p): stub\n", iface, pIPalette);
 866     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 867 }
 868
 869 static HRESULT WINAPI JpegEncoder_Frame_SetThumbnail(IWICBitmapFrameEncode *iface,
 870     IWICBitmapSource *pIThumbnail)
 871 {
 872     FIXME("(%p,%p): stub\n", iface, pIThumbnail);
 873     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 874 }
 875
 876 static HRESULT WINAPI JpegEncoder_Frame_WritePixels(IWICBitmapFrameEncode *iface,
 877     UINT lineCount, UINT cbStride, UINT cbBufferSize, BYTE *pbPixels)
 878 {
 879     FIXME("(%p,%u,%u,%u,%p): stub\n", iface, lineCount, cbStride, cbBufferSize, pbPixels);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI JpegEncoder_Frame_WriteSource(IWICBitmapFrameEncode *iface,
 884     IWICBitmapSource *pIBitmapSource, WICRect *prc)
 885 {
 886     FIXME("(%p,%p,%p): stub\n", iface, pIBitmapSource, prc);
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI JpegEncoder_Frame_Commit(IWICBitmapFrameEncode *iface)
 891 {
 892     FIXME("(%p): stub\n", iface);
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT WINAPI JpegEncoder_Frame_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface,
 897     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 898 {
 899     FIXME("(%p, %p): stub\n", iface, ppIMetadataQueryWriter);
 900     return E_NOTIMPL;
 901 }
 902
 903 static const IWICBitmapFrameEncodeVtbl JpegEncoder_FrameVtbl = {
 904     JpegEncoder_Frame_QueryInterface,
 905     JpegEncoder_Frame_AddRef,
 906     JpegEncoder_Frame_Release,
 907     JpegEncoder_Frame_Initialize,
 908     JpegEncoder_Frame_SetSize,
 909     JpegEncoder_Frame_SetResolution,
 910     JpegEncoder_Frame_SetPixelFormat,
 911     JpegEncoder_Frame_SetColorContexts,
 912     JpegEncoder_Frame_SetPalette,
 913     JpegEncoder_Frame_SetThumbnail,
 914     JpegEncoder_Frame_WritePixels,
 915     JpegEncoder_Frame_WriteSource,
 916     JpegEncoder_Frame_Commit,
 917     JpegEncoder_Frame_GetMetadataQueryWriter
 918 };
 919
 920 static HRESULT WINAPI JpegEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid,
 921     void **ppv)
 922 {
 923     JpegEncoder *This = impl_from_IWICBitmapEncoder(iface);
 924     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 925
 926     if (!ppv) return E_INVALIDARG;
 927
 928     if (IsEqualIID(&IID_IUnknown, iid) ||
 929         IsEqualIID(&IID_IWICBitmapEncoder, iid))
 930     {
 931         *ppv = This;
 932     }
 933     else
 934     {
 935         *ppv = NULL;
 936         return E_NOINTERFACE;
 937     }
 938
 939     IUnknown_AddRef((IUnknown*)*ppv);
 940     return S_OK;
 941 }
 942
 943 static ULONG WINAPI JpegEncoder_AddRef(IWICBitmapEncoder *iface)
 944 {
 945     JpegEncoder *This = impl_from_IWICBitmapEncoder(iface);
 946     ULONG ref = InterlockedIncrement(&This->ref);
 947
 948     TRACE("(%p) refcount=%u\n", iface, ref);
 949
 950     return ref;
 951 }
 952
 953 static ULONG WINAPI JpegEncoder_Release(IWICBitmapEncoder *iface)
 954 {
 955     JpegEncoder *This = impl_from_IWICBitmapEncoder(iface);
 956     ULONG ref = InterlockedDecrement(&This->ref);
 957
 958     TRACE("(%p) refcount=%u\n", iface, ref);
 959
 960     if (ref == 0)
 961     {
 962         This->lock.DebugInfo->Spare[0] = 0;
 963         DeleteCriticalSection(&This->lock);
 964         if (This->initialized) pjpeg_destroy_compress(&This->cinfo);
 965         if (This->stream) IStream_Release(This->stream);
 966         HeapFree(GetProcessHeap(), 0, This);
 967     }
 968
 969     return ref;
 970 }
 971
 972 static HRESULT WINAPI JpegEncoder_Initialize(IWICBitmapEncoder *iface,
 973     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
 974 {
 975     JpegEncoder *This = impl_from_IWICBitmapEncoder(iface);
 976     jmp_buf jmpbuf;
 977
 978     TRACE("(%p,%p,%u)\n", iface, pIStream, cacheOption);
 979
 980     EnterCriticalSection(&This->lock);
 981
 982     if (This->initialized)
 983     {
 984         LeaveCriticalSection(&This->lock);
 985         return WINCODEC_ERR_WRONGSTATE;
 986     }
 987
 988     pjpeg_std_error(&This->jerr);
 989
 990     This->jerr.error_exit = error_exit_fn;
 991     This->jerr.emit_message = emit_message_fn;
 992
 993     This->cinfo.err = &This->jerr;
 994
 995     This->cinfo.client_data = &jmpbuf;
 996
 997     if (setjmp(jmpbuf))
 998     {
 999         LeaveCriticalSection(&This->lock);
1000         return E_FAIL;
1001     }
1002
1003     pjpeg_CreateCompress(&This->cinfo, JPEG_LIB_VERSION, sizeof(struct jpeg_compress_struct));
1004
1005     This->stream = pIStream;
1006     IStream_AddRef(pIStream);
1007
1008     This->dest_mgr.next_output_byte = This->dest_buffer;
1009     This->dest_mgr.free_in_buffer = sizeof(This->dest_buffer);
1010
1011     This->dest_mgr.init_destination = dest_mgr_init_destination;
1012     This->dest_mgr.empty_output_buffer = dest_mgr_empty_output_buffer;
1013     This->dest_mgr.term_destination = dest_mgr_term_destination;
1014
1015     This->cinfo.dest = &This->dest_mgr;
1016
1017     This->initialized = TRUE;
1018
1019     LeaveCriticalSection(&This->lock);
1020
1021     return S_OK;
1022 }
1023
1024 static HRESULT WINAPI JpegEncoder_GetContainerFormat(IWICBitmapEncoder *iface,
1025     GUID *pguidContainerFormat)
1026 {
1027     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidContainerFormat));
1028     return E_NOTIMPL;
1029 }
1030
1031 static HRESULT WINAPI JpegEncoder_GetEncoderInfo(IWICBitmapEncoder *iface,
1032     IWICBitmapEncoderInfo **ppIEncoderInfo)
1033 {
1034     FIXME("(%p,%p): stub\n", iface, ppIEncoderInfo);
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI JpegEncoder_SetColorContexts(IWICBitmapEncoder *iface,
1039     UINT cCount, IWICColorContext **ppIColorContext)
1040 {
1041     FIXME("(%p,%u,%p): stub\n", iface, cCount, ppIColorContext);
1042     return E_NOTIMPL;
1043 }
1044
1045 static HRESULT WINAPI JpegEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *pIPalette)
1046 {
1047     TRACE("(%p,%p)\n", iface, pIPalette);
1048     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1049 }
1050
1051 static HRESULT WINAPI JpegEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *pIThumbnail)
1052 {
1053     TRACE("(%p,%p)\n", iface, pIThumbnail);
1054     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1055 }
1056
1057 static HRESULT WINAPI JpegEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *pIPreview)
1058 {
1059     TRACE("(%p,%p)\n", iface, pIPreview);
1060     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1061 }
1062
1063 static HRESULT WINAPI JpegEncoder_CreateNewFrame(IWICBitmapEncoder *iface,
1064     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
1065 {
1066     JpegEncoder *This = impl_from_IWICBitmapEncoder(iface);
1067     HRESULT hr;
1068
1069     TRACE("(%p,%p,%p)\n", iface, ppIFrameEncode, ppIEncoderOptions);
1070
1071     EnterCriticalSection(&This->lock);
1072
1073     if (This->frame_count != 0)
1074     {
1075         LeaveCriticalSection(&This->lock);
1076         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1077     }
1078
1079     if (!This->initialized)
1080     {
1081         LeaveCriticalSection(&This->lock);
1082         return WINCODEC_ERR_NOTINITIALIZED;
1083     }
1084
1085     hr = CreatePropertyBag2(ppIEncoderOptions);
1086     if (FAILED(hr))
1087     {
1088         LeaveCriticalSection(&This->lock);
1089         return hr;
1090     }
1091
1092     This->frame_count = 1;
1093
1094     LeaveCriticalSection(&This->lock);
1095
1096     IWICBitmapEncoder_AddRef(iface);
1097     *ppIFrameEncode = &This->IWICBitmapFrameEncode_iface;
1098
1099     return S_OK;
1100 }
1101
1102 static HRESULT WINAPI JpegEncoder_Commit(IWICBitmapEncoder *iface)
1103 {
1104     FIXME("(%p): stub\n", iface);
1105     return E_NOTIMPL;
1106 }
1107
1108 static HRESULT WINAPI JpegEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface,
1109     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
1110 {
1111     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryWriter);
1112     return E_NOTIMPL;
1113 }
1114
1115 static const IWICBitmapEncoderVtbl JpegEncoder_Vtbl = {
1116     JpegEncoder_QueryInterface,
1117     JpegEncoder_AddRef,
1118     JpegEncoder_Release,
1119     JpegEncoder_Initialize,
1120     JpegEncoder_GetContainerFormat,
1121     JpegEncoder_GetEncoderInfo,
1122     JpegEncoder_SetColorContexts,
1123     JpegEncoder_SetPalette,
1124     JpegEncoder_SetThumbnail,
1125     JpegEncoder_SetPreview,
1126     JpegEncoder_CreateNewFrame,
1127     JpegEncoder_Commit,
1128     JpegEncoder_GetMetadataQueryWriter
1129 };
1130
1131 HRESULT JpegEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1132 {
1133     JpegEncoder *This;
1134     HRESULT ret;
1135
1136     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
1137
1138     *ppv = NULL;
1139
1140     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1141
1142     if (!libjpeg_handle && !load_libjpeg())
1143     {
1144         ERR("Failed writing JPEG because unable to find %s\n",SONAME_LIBJPEG);
1145         return E_FAIL;
1146     }
1147
1148     This = HeapAlloc(GetProcessHeap(), 0, sizeof(JpegEncoder));
1149     if (!This) return E_OUTOFMEMORY;
1150
1151     This->IWICBitmapEncoder_iface.lpVtbl = &JpegEncoder_Vtbl;
1152     This->IWICBitmapFrameEncode_iface.lpVtbl = &JpegEncoder_FrameVtbl;
1153     This->ref = 1;
1154     This->initialized = 0;
1155     This->frame_count = 0;
1156     This->frame_initialized = 0;
1157     This->stream = NULL;
1158     InitializeCriticalSection(&This->lock);
1159     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JpegEncoder.lock");
1160
1161     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
1162     IUnknown_Release((IUnknown*)This);
1163
1164     return ret;
1165 }
1166
1167 #else /* !defined(SONAME_LIBJPEG) */
1168
1169 HRESULT JpegDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1170 {
1171     ERR("Trying to load JPEG picture, but JPEG support is not compiled in.\n");
1172     return E_FAIL;
1173 }
1174
1175 HRESULT JpegEncoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
1176 {
1177     ERR("Trying to save JPEG picture, but JPEG support is not compiled in.\n");
1178     return E_FAIL;
1179 }
1180
1181 #endif