2 * Copyright 2009 Vincent Povirk for CodeWeavers
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.
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.
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
19 #include "wincodecs_private.h"
26 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
28 #define UINT8 JPEG_UINT8
29 #define UINT16 JPEG_UINT16
30 #define boolean jpeg_boolean
34 #define HAVE_STDLIB_H 1
41 WINE_DECLARE_DEBUG_CHANNEL(jpeg
);
43 static void *libjpeg_handle
;
45 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
46 MAKE_FUNCPTR(jpeg_CreateCompress
);
47 MAKE_FUNCPTR(jpeg_CreateDecompress
);
48 MAKE_FUNCPTR(jpeg_destroy_compress
);
49 MAKE_FUNCPTR(jpeg_destroy_decompress
);
50 MAKE_FUNCPTR(jpeg_finish_compress
);
51 MAKE_FUNCPTR(jpeg_read_header
);
52 MAKE_FUNCPTR(jpeg_read_scanlines
);
53 MAKE_FUNCPTR(jpeg_resync_to_restart
);
54 MAKE_FUNCPTR(jpeg_set_defaults
);
55 MAKE_FUNCPTR(jpeg_start_compress
);
56 MAKE_FUNCPTR(jpeg_start_decompress
);
57 MAKE_FUNCPTR(jpeg_std_error
);
58 MAKE_FUNCPTR(jpeg_write_scanlines
);
61 static void *load_libjpeg(void)
63 if((libjpeg_handle
= wine_dlopen(SONAME_LIBJPEG
, RTLD_NOW
, NULL
, 0)) != NULL
) {
65 #define LOAD_FUNCPTR(f) \
66 if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
67 libjpeg_handle = NULL; \
71 LOAD_FUNCPTR(jpeg_CreateCompress
);
72 LOAD_FUNCPTR(jpeg_CreateDecompress
);
73 LOAD_FUNCPTR(jpeg_destroy_compress
);
74 LOAD_FUNCPTR(jpeg_destroy_decompress
);
75 LOAD_FUNCPTR(jpeg_finish_compress
);
76 LOAD_FUNCPTR(jpeg_read_header
);
77 LOAD_FUNCPTR(jpeg_read_scanlines
);
78 LOAD_FUNCPTR(jpeg_resync_to_restart
);
79 LOAD_FUNCPTR(jpeg_set_defaults
);
80 LOAD_FUNCPTR(jpeg_start_compress
);
81 LOAD_FUNCPTR(jpeg_start_decompress
);
82 LOAD_FUNCPTR(jpeg_std_error
);
83 LOAD_FUNCPTR(jpeg_write_scanlines
);
86 return libjpeg_handle
;
89 static void error_exit_fn(j_common_ptr cinfo
)
91 char message
[JMSG_LENGTH_MAX
];
94 cinfo
->err
->format_message(cinfo
, message
);
95 ERR_(jpeg
)("%s\n", message
);
97 longjmp(*(jmp_buf*)cinfo
->client_data
, 1);
100 static void emit_message_fn(j_common_ptr cinfo
, int msg_level
)
102 char message
[JMSG_LENGTH_MAX
];
104 if (msg_level
< 0 && ERR_ON(jpeg
))
106 cinfo
->err
->format_message(cinfo
, message
);
107 ERR_(jpeg
)("%s\n", message
);
109 else if (msg_level
== 0 && WARN_ON(jpeg
))
111 cinfo
->err
->format_message(cinfo
, message
);
112 WARN_(jpeg
)("%s\n", message
);
114 else if (msg_level
> 0 && TRACE_ON(jpeg
))
116 cinfo
->err
->format_message(cinfo
, message
);
117 TRACE_(jpeg
)("%s\n", message
);
122 IWICBitmapDecoder IWICBitmapDecoder_iface
;
123 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
126 BOOL cinfo_initialized
;
128 struct jpeg_decompress_struct cinfo
;
129 struct jpeg_error_mgr jerr
;
130 struct jpeg_source_mgr source_mgr
;
131 BYTE source_buffer
[1024];
133 CRITICAL_SECTION lock
;
136 static inline JpegDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
138 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapDecoder_iface
);
141 static inline JpegDecoder
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
143 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapFrameDecode_iface
);
146 static inline JpegDecoder
*decoder_from_decompress(j_decompress_ptr decompress
)
148 return CONTAINING_RECORD(decompress
, JpegDecoder
, cinfo
);
151 static HRESULT WINAPI
JpegDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
154 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
155 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
157 if (!ppv
) return E_INVALIDARG
;
159 if (IsEqualIID(&IID_IUnknown
, iid
) ||
160 IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
162 *ppv
= &This
->IWICBitmapDecoder_iface
;
167 return E_NOINTERFACE
;
170 IUnknown_AddRef((IUnknown
*)*ppv
);
174 static ULONG WINAPI
JpegDecoder_AddRef(IWICBitmapDecoder
*iface
)
176 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
177 ULONG ref
= InterlockedIncrement(&This
->ref
);
179 TRACE("(%p) refcount=%u\n", iface
, ref
);
184 static ULONG WINAPI
JpegDecoder_Release(IWICBitmapDecoder
*iface
)
186 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
187 ULONG ref
= InterlockedDecrement(&This
->ref
);
189 TRACE("(%p) refcount=%u\n", iface
, ref
);
193 This
->lock
.DebugInfo
->Spare
[0] = 0;
194 DeleteCriticalSection(&This
->lock
);
195 if (This
->cinfo_initialized
) pjpeg_destroy_decompress(&This
->cinfo
);
196 if (This
->stream
) IStream_Release(This
->stream
);
197 HeapFree(GetProcessHeap(), 0, This
->image_data
);
198 HeapFree(GetProcessHeap(), 0, This
);
204 static HRESULT WINAPI
JpegDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*stream
,
209 TRACE("(%p,%p,%p)\n", iface
, stream
, capability
);
211 if (!stream
|| !capability
) return E_INVALIDARG
;
213 hr
= IWICBitmapDecoder_Initialize(iface
, stream
, WICDecodeMetadataCacheOnDemand
);
214 if (hr
!= S_OK
) return hr
;
216 *capability
= WICBitmapDecoderCapabilityCanDecodeAllImages
|
217 WICBitmapDecoderCapabilityCanDecodeSomeImages
;
218 /* FIXME: WICBitmapDecoderCapabilityCanEnumerateMetadata */
222 static void source_mgr_init_source(j_decompress_ptr cinfo
)
226 static jpeg_boolean
source_mgr_fill_input_buffer(j_decompress_ptr cinfo
)
228 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
232 hr
= IStream_Read(This
->stream
, This
->source_buffer
, 1024, &bytesread
);
234 if (FAILED(hr
) || bytesread
== 0)
240 This
->source_mgr
.next_input_byte
= This
->source_buffer
;
241 This
->source_mgr
.bytes_in_buffer
= bytesread
;
246 static void source_mgr_skip_input_data(j_decompress_ptr cinfo
, long num_bytes
)
248 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
251 if (num_bytes
> This
->source_mgr
.bytes_in_buffer
)
253 seek
.QuadPart
= num_bytes
- This
->source_mgr
.bytes_in_buffer
;
254 IStream_Seek(This
->stream
, seek
, STREAM_SEEK_CUR
, NULL
);
255 This
->source_mgr
.bytes_in_buffer
= 0;
257 else if (num_bytes
> 0)
259 This
->source_mgr
.next_input_byte
+= num_bytes
;
260 This
->source_mgr
.bytes_in_buffer
-= num_bytes
;
264 static void source_mgr_term_source(j_decompress_ptr cinfo
)
268 static HRESULT WINAPI
JpegDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
269 WICDecodeOptions cacheOptions
)
271 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
275 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOptions
);
277 EnterCriticalSection(&This
->lock
);
279 if (This
->cinfo_initialized
)
281 LeaveCriticalSection(&This
->lock
);
282 return WINCODEC_ERR_WRONGSTATE
;
285 pjpeg_std_error(&This
->jerr
);
287 This
->jerr
.error_exit
= error_exit_fn
;
288 This
->jerr
.emit_message
= emit_message_fn
;
290 This
->cinfo
.err
= &This
->jerr
;
292 This
->cinfo
.client_data
= jmpbuf
;
296 LeaveCriticalSection(&This
->lock
);
300 pjpeg_CreateDecompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_decompress_struct
));
302 This
->cinfo_initialized
= TRUE
;
304 This
->stream
= pIStream
;
305 IStream_AddRef(pIStream
);
308 IStream_Seek(This
->stream
, seek
, STREAM_SEEK_SET
, NULL
);
310 This
->source_mgr
.bytes_in_buffer
= 0;
311 This
->source_mgr
.init_source
= source_mgr_init_source
;
312 This
->source_mgr
.fill_input_buffer
= source_mgr_fill_input_buffer
;
313 This
->source_mgr
.skip_input_data
= source_mgr_skip_input_data
;
314 This
->source_mgr
.resync_to_restart
= pjpeg_resync_to_restart
;
315 This
->source_mgr
.term_source
= source_mgr_term_source
;
317 This
->cinfo
.src
= &This
->source_mgr
;
319 ret
= pjpeg_read_header(&This
->cinfo
, TRUE
);
321 if (ret
!= JPEG_HEADER_OK
) {
322 WARN("Jpeg image in stream has bad format, read header returned %d.\n",ret
);
323 LeaveCriticalSection(&This
->lock
);
327 switch (This
->cinfo
.jpeg_color_space
)
330 This
->cinfo
.out_color_space
= JCS_GRAYSCALE
;
334 This
->cinfo
.out_color_space
= JCS_RGB
;
338 This
->cinfo
.out_color_space
= JCS_CMYK
;
341 ERR("Unknown JPEG color space %i\n", This
->cinfo
.jpeg_color_space
);
342 LeaveCriticalSection(&This
->lock
);
346 if (!pjpeg_start_decompress(&This
->cinfo
))
348 ERR("jpeg_start_decompress failed\n");
349 LeaveCriticalSection(&This
->lock
);
353 This
->initialized
= TRUE
;
355 LeaveCriticalSection(&This
->lock
);
360 static HRESULT WINAPI
JpegDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
361 GUID
*pguidContainerFormat
)
363 memcpy(pguidContainerFormat
, &GUID_ContainerFormatJpeg
, sizeof(GUID
));
367 static HRESULT WINAPI
JpegDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
368 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
371 IWICComponentInfo
*compinfo
;
373 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
375 hr
= CreateComponentInfo(&CLSID_WICJpegDecoder
, &compinfo
);
376 if (FAILED(hr
)) return hr
;
378 hr
= IWICComponentInfo_QueryInterface(compinfo
, &IID_IWICBitmapDecoderInfo
,
379 (void**)ppIDecoderInfo
);
381 IWICComponentInfo_Release(compinfo
);
386 static HRESULT WINAPI
JpegDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
387 IWICPalette
*pIPalette
)
389 TRACE("(%p,%p)\n", iface
, pIPalette
);
391 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
394 static HRESULT WINAPI
JpegDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
395 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
397 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
401 static HRESULT WINAPI
JpegDecoder_GetPreview(IWICBitmapDecoder
*iface
,
402 IWICBitmapSource
**ppIBitmapSource
)
404 FIXME("(%p,%p): stub\n", iface
, ppIBitmapSource
);
405 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
408 static HRESULT WINAPI
JpegDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
409 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
411 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
412 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
415 static HRESULT WINAPI
JpegDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
416 IWICBitmapSource
**ppIThumbnail
)
418 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
419 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
422 static HRESULT WINAPI
JpegDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
425 if (!pCount
) return E_INVALIDARG
;
431 static HRESULT WINAPI
JpegDecoder_GetFrame(IWICBitmapDecoder
*iface
,
432 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
434 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
435 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
437 if (!This
->initialized
) return WINCODEC_ERR_FRAMEMISSING
;
439 if (index
!= 0) return E_INVALIDARG
;
441 IWICBitmapDecoder_AddRef(iface
);
442 *ppIBitmapFrame
= &This
->IWICBitmapFrameDecode_iface
;
447 static const IWICBitmapDecoderVtbl JpegDecoder_Vtbl
= {
448 JpegDecoder_QueryInterface
,
451 JpegDecoder_QueryCapability
,
452 JpegDecoder_Initialize
,
453 JpegDecoder_GetContainerFormat
,
454 JpegDecoder_GetDecoderInfo
,
455 JpegDecoder_CopyPalette
,
456 JpegDecoder_GetMetadataQueryReader
,
457 JpegDecoder_GetPreview
,
458 JpegDecoder_GetColorContexts
,
459 JpegDecoder_GetThumbnail
,
460 JpegDecoder_GetFrameCount
,
464 static HRESULT WINAPI
JpegDecoder_Frame_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
467 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
469 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
471 if (!ppv
) return E_INVALIDARG
;
473 if (IsEqualIID(&IID_IUnknown
, iid
) ||
474 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
475 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
477 *ppv
= &This
->IWICBitmapFrameDecode_iface
;
482 return E_NOINTERFACE
;
485 IUnknown_AddRef((IUnknown
*)*ppv
);
489 static ULONG WINAPI
JpegDecoder_Frame_AddRef(IWICBitmapFrameDecode
*iface
)
491 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
492 return IWICBitmapDecoder_AddRef(&This
->IWICBitmapDecoder_iface
);
495 static ULONG WINAPI
JpegDecoder_Frame_Release(IWICBitmapFrameDecode
*iface
)
497 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
498 return IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
501 static HRESULT WINAPI
JpegDecoder_Frame_GetSize(IWICBitmapFrameDecode
*iface
,
502 UINT
*puiWidth
, UINT
*puiHeight
)
504 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
505 *puiWidth
= This
->cinfo
.output_width
;
506 *puiHeight
= This
->cinfo
.output_height
;
507 TRACE("(%p)->(%u,%u)\n", iface
, *puiWidth
, *puiHeight
);
511 static HRESULT WINAPI
JpegDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
512 WICPixelFormatGUID
*pPixelFormat
)
514 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
515 TRACE("(%p,%p)\n", iface
, pPixelFormat
);
516 if (This
->cinfo
.out_color_space
== JCS_RGB
)
517 memcpy(pPixelFormat
, &GUID_WICPixelFormat24bppBGR
, sizeof(GUID
));
518 else if (This
->cinfo
.out_color_space
== JCS_CMYK
)
519 memcpy(pPixelFormat
, &GUID_WICPixelFormat32bppCMYK
, sizeof(GUID
));
520 else /* This->cinfo.out_color_space == JCS_GRAYSCALE */
521 memcpy(pPixelFormat
, &GUID_WICPixelFormat8bppGray
, sizeof(GUID
));
525 static HRESULT WINAPI
JpegDecoder_Frame_GetResolution(IWICBitmapFrameDecode
*iface
,
526 double *pDpiX
, double *pDpiY
)
528 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
530 EnterCriticalSection(&This
->lock
);
532 switch (This
->cinfo
.density_unit
)
534 case 2: /* pixels per centimeter */
535 *pDpiX
= This
->cinfo
.X_density
* 2.54;
536 *pDpiY
= This
->cinfo
.Y_density
* 2.54;
539 case 1: /* pixels per inch */
540 *pDpiX
= This
->cinfo
.X_density
;
541 *pDpiY
= This
->cinfo
.Y_density
;
544 case 0: /* unknown */
551 LeaveCriticalSection(&This
->lock
);
553 TRACE("(%p)->(%0.2f,%0.2f)\n", iface
, *pDpiX
, *pDpiY
);
558 static HRESULT WINAPI
JpegDecoder_Frame_CopyPalette(IWICBitmapFrameDecode
*iface
,
559 IWICPalette
*pIPalette
)
561 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
565 static HRESULT WINAPI
JpegDecoder_Frame_CopyPixels(IWICBitmapFrameDecode
*iface
,
566 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
568 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
575 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
581 rect
.Width
= This
->cinfo
.output_width
;
582 rect
.Height
= This
->cinfo
.output_height
;
587 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->cinfo
.output_width
||
588 prc
->Y
+prc
->Height
> This
->cinfo
.output_height
)
592 if (This
->cinfo
.out_color_space
== JCS_GRAYSCALE
) bpp
= 8;
593 else if (This
->cinfo
.out_color_space
== JCS_CMYK
) bpp
= 32;
596 stride
= bpp
* This
->cinfo
.output_width
;
597 data_size
= stride
* This
->cinfo
.output_height
;
599 max_row_needed
= prc
->Y
+ prc
->Height
;
600 if (max_row_needed
> This
->cinfo
.output_height
) return E_INVALIDARG
;
602 EnterCriticalSection(&This
->lock
);
604 if (!This
->image_data
)
606 This
->image_data
= HeapAlloc(GetProcessHeap(), 0, data_size
);
607 if (!This
->image_data
)
609 LeaveCriticalSection(&This
->lock
);
610 return E_OUTOFMEMORY
;
614 This
->cinfo
.client_data
= jmpbuf
;
618 LeaveCriticalSection(&This
->lock
);
622 while (max_row_needed
> This
->cinfo
.output_scanline
)
624 UINT first_scanline
= This
->cinfo
.output_scanline
;
626 JSAMPROW out_rows
[4];
630 max_rows
= min(This
->cinfo
.output_height
-first_scanline
, 4);
631 for (i
=0; i
<max_rows
; i
++)
632 out_rows
[i
] = This
->image_data
+ stride
* (first_scanline
+i
);
634 ret
= pjpeg_read_scanlines(&This
->cinfo
, out_rows
, max_rows
);
638 ERR("read_scanlines failed\n");
639 LeaveCriticalSection(&This
->lock
);
645 /* libjpeg gives us RGB data and we want BGR, so byteswap the data */
646 reverse_bgr8(3, This
->image_data
+ stride
* first_scanline
,
647 This
->cinfo
.output_width
, This
->cinfo
.output_scanline
- first_scanline
,
651 if (This
->cinfo
.out_color_space
== JCS_CMYK
&& This
->cinfo
.saw_Adobe_marker
)
652 /* Adobe JPEG's have inverted CMYK data. */
653 for (i
=0; i
<data_size
; i
++)
654 This
->image_data
[i
] ^= 0xff;
657 LeaveCriticalSection(&This
->lock
);
659 return copy_pixels(bpp
, This
->image_data
,
660 This
->cinfo
.output_width
, This
->cinfo
.output_height
, stride
,
661 prc
, cbStride
, cbBufferSize
, pbBuffer
);
664 static HRESULT WINAPI
JpegDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
665 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
667 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
668 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
671 static HRESULT WINAPI
JpegDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode
*iface
,
672 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
674 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
675 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
678 static HRESULT WINAPI
JpegDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode
*iface
,
679 IWICBitmapSource
**ppIThumbnail
)
681 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
682 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
685 static const IWICBitmapFrameDecodeVtbl JpegDecoder_Frame_Vtbl
= {
686 JpegDecoder_Frame_QueryInterface
,
687 JpegDecoder_Frame_AddRef
,
688 JpegDecoder_Frame_Release
,
689 JpegDecoder_Frame_GetSize
,
690 JpegDecoder_Frame_GetPixelFormat
,
691 JpegDecoder_Frame_GetResolution
,
692 JpegDecoder_Frame_CopyPalette
,
693 JpegDecoder_Frame_CopyPixels
,
694 JpegDecoder_Frame_GetMetadataQueryReader
,
695 JpegDecoder_Frame_GetColorContexts
,
696 JpegDecoder_Frame_GetThumbnail
699 HRESULT
JpegDecoder_CreateInstance(REFIID iid
, void** ppv
)
704 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
706 if (!libjpeg_handle
&& !load_libjpeg())
708 ERR("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG
);
714 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegDecoder
));
715 if (!This
) return E_OUTOFMEMORY
;
717 This
->IWICBitmapDecoder_iface
.lpVtbl
= &JpegDecoder_Vtbl
;
718 This
->IWICBitmapFrameDecode_iface
.lpVtbl
= &JpegDecoder_Frame_Vtbl
;
720 This
->initialized
= FALSE
;
721 This
->cinfo_initialized
= FALSE
;
723 This
->image_data
= NULL
;
724 InitializeCriticalSection(&This
->lock
);
725 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegDecoder.lock");
727 ret
= IWICBitmapDecoder_QueryInterface(&This
->IWICBitmapDecoder_iface
, iid
, ppv
);
728 IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
733 typedef struct jpeg_compress_format
{
734 const WICPixelFormatGUID
*guid
;
737 J_COLOR_SPACE color_space
;
739 } jpeg_compress_format
;
741 static const jpeg_compress_format compress_formats
[] = {
742 { &GUID_WICPixelFormat24bppBGR
, 24, 3, JCS_RGB
, 1 },
743 { &GUID_WICPixelFormat32bppCMYK
, 32, 4, JCS_CMYK
},
744 { &GUID_WICPixelFormat8bppGray
, 8, 1, JCS_GRAYSCALE
},
748 typedef struct JpegEncoder
{
749 IWICBitmapEncoder IWICBitmapEncoder_iface
;
750 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
752 struct jpeg_compress_struct cinfo
;
753 struct jpeg_error_mgr jerr
;
754 struct jpeg_destination_mgr dest_mgr
;
757 BOOL frame_initialized
;
758 BOOL started_compress
;
760 BOOL frame_committed
;
764 const jpeg_compress_format
*format
;
766 CRITICAL_SECTION lock
;
767 BYTE dest_buffer
[1024];
770 static inline JpegEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
772 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapEncoder_iface
);
775 static inline JpegEncoder
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
777 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapFrameEncode_iface
);
780 static inline JpegEncoder
*encoder_from_compress(j_compress_ptr compress
)
782 return CONTAINING_RECORD(compress
, JpegEncoder
, cinfo
);
785 static void dest_mgr_init_destination(j_compress_ptr cinfo
)
787 JpegEncoder
*This
= encoder_from_compress(cinfo
);
789 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
790 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
793 static jpeg_boolean
dest_mgr_empty_output_buffer(j_compress_ptr cinfo
)
795 JpegEncoder
*This
= encoder_from_compress(cinfo
);
799 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
800 sizeof(This
->dest_buffer
), &byteswritten
);
802 if (hr
!= S_OK
|| byteswritten
== 0)
804 ERR("Failed writing data, hr=%x\n", hr
);
808 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
809 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
813 static void dest_mgr_term_destination(j_compress_ptr cinfo
)
815 JpegEncoder
*This
= encoder_from_compress(cinfo
);
819 if (This
->dest_mgr
.free_in_buffer
!= sizeof(This
->dest_buffer
))
821 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
822 sizeof(This
->dest_buffer
) - This
->dest_mgr
.free_in_buffer
, &byteswritten
);
824 if (hr
!= S_OK
|| byteswritten
== 0)
825 ERR("Failed writing data, hr=%x\n", hr
);
829 static HRESULT WINAPI
JpegEncoder_Frame_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
832 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
833 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
835 if (!ppv
) return E_INVALIDARG
;
837 if (IsEqualIID(&IID_IUnknown
, iid
) ||
838 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
840 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
845 return E_NOINTERFACE
;
848 IUnknown_AddRef((IUnknown
*)*ppv
);
852 static ULONG WINAPI
JpegEncoder_Frame_AddRef(IWICBitmapFrameEncode
*iface
)
854 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
855 return IWICBitmapEncoder_AddRef(&This
->IWICBitmapEncoder_iface
);
858 static ULONG WINAPI
JpegEncoder_Frame_Release(IWICBitmapFrameEncode
*iface
)
860 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
861 return IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
864 static HRESULT WINAPI
JpegEncoder_Frame_Initialize(IWICBitmapFrameEncode
*iface
,
865 IPropertyBag2
*pIEncoderOptions
)
867 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
868 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
870 EnterCriticalSection(&This
->lock
);
872 if (This
->frame_initialized
)
874 LeaveCriticalSection(&This
->lock
);
875 return WINCODEC_ERR_WRONGSTATE
;
878 This
->frame_initialized
= TRUE
;
880 LeaveCriticalSection(&This
->lock
);
885 static HRESULT WINAPI
JpegEncoder_Frame_SetSize(IWICBitmapFrameEncode
*iface
,
886 UINT uiWidth
, UINT uiHeight
)
888 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
889 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
891 EnterCriticalSection(&This
->lock
);
893 if (!This
->frame_initialized
|| This
->started_compress
)
895 LeaveCriticalSection(&This
->lock
);
896 return WINCODEC_ERR_WRONGSTATE
;
899 This
->width
= uiWidth
;
900 This
->height
= uiHeight
;
902 LeaveCriticalSection(&This
->lock
);
907 static HRESULT WINAPI
JpegEncoder_Frame_SetResolution(IWICBitmapFrameEncode
*iface
,
908 double dpiX
, double dpiY
)
910 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
911 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
913 EnterCriticalSection(&This
->lock
);
915 if (!This
->frame_initialized
|| This
->started_compress
)
917 LeaveCriticalSection(&This
->lock
);
918 return WINCODEC_ERR_WRONGSTATE
;
924 LeaveCriticalSection(&This
->lock
);
929 static HRESULT WINAPI
JpegEncoder_Frame_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
930 WICPixelFormatGUID
*pPixelFormat
)
932 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
934 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
936 EnterCriticalSection(&This
->lock
);
938 if (!This
->frame_initialized
|| This
->started_compress
)
940 LeaveCriticalSection(&This
->lock
);
941 return WINCODEC_ERR_WRONGSTATE
;
944 for (i
=0; compress_formats
[i
].guid
; i
++)
946 if (memcmp(compress_formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
950 if (!compress_formats
[i
].guid
) i
= 0;
952 This
->format
= &compress_formats
[i
];
953 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
955 LeaveCriticalSection(&This
->lock
);
960 static HRESULT WINAPI
JpegEncoder_Frame_SetColorContexts(IWICBitmapFrameEncode
*iface
,
961 UINT cCount
, IWICColorContext
**ppIColorContext
)
963 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
967 static HRESULT WINAPI
JpegEncoder_Frame_SetPalette(IWICBitmapFrameEncode
*iface
,
968 IWICPalette
*pIPalette
)
970 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
971 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
974 static HRESULT WINAPI
JpegEncoder_Frame_SetThumbnail(IWICBitmapFrameEncode
*iface
,
975 IWICBitmapSource
*pIThumbnail
)
977 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
978 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
981 static HRESULT WINAPI
JpegEncoder_Frame_WritePixels(IWICBitmapFrameEncode
*iface
,
982 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
984 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
986 BYTE
*swapped_data
= NULL
, *current_row
;
989 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
991 EnterCriticalSection(&This
->lock
);
993 if (!This
->frame_initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
995 LeaveCriticalSection(&This
->lock
);
996 return WINCODEC_ERR_WRONGSTATE
;
999 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1001 LeaveCriticalSection(&This
->lock
);
1002 return E_INVALIDARG
;
1005 /* set up setjmp/longjmp error handling */
1008 LeaveCriticalSection(&This
->lock
);
1009 HeapFree(GetProcessHeap(), 0, swapped_data
);
1012 This
->cinfo
.client_data
= jmpbuf
;
1014 if (!This
->started_compress
)
1016 This
->cinfo
.image_width
= This
->width
;
1017 This
->cinfo
.image_height
= This
->height
;
1018 This
->cinfo
.input_components
= This
->format
->num_components
;
1019 This
->cinfo
.in_color_space
= This
->format
->color_space
;
1021 pjpeg_set_defaults(&This
->cinfo
);
1023 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1025 This
->cinfo
.density_unit
= 1; /* dots per inch */
1026 This
->cinfo
.X_density
= This
->xres
;
1027 This
->cinfo
.Y_density
= This
->yres
;
1030 pjpeg_start_compress(&This
->cinfo
, TRUE
);
1032 This
->started_compress
= TRUE
;
1035 row_size
= This
->format
->bpp
/ 8 * This
->width
;
1037 if (This
->format
->swap_rgb
)
1039 swapped_data
= HeapAlloc(GetProcessHeap(), 0, row_size
);
1042 LeaveCriticalSection(&This
->lock
);
1043 return E_OUTOFMEMORY
;
1047 for (line
=0; line
< lineCount
; line
++)
1049 if (This
->format
->swap_rgb
)
1053 memcpy(swapped_data
, pbPixels
+ (cbStride
* line
), row_size
);
1055 for (x
=0; x
< This
->width
; x
++)
1059 b
= swapped_data
[x
*3];
1060 swapped_data
[x
*3] = swapped_data
[x
*3+2];
1061 swapped_data
[x
*3+2] = b
;
1064 current_row
= swapped_data
;
1067 current_row
= pbPixels
+ (cbStride
* line
);
1069 if (!pjpeg_write_scanlines(&This
->cinfo
, ¤t_row
, 1))
1071 ERR("failed writing scanlines\n");
1072 LeaveCriticalSection(&This
->lock
);
1073 HeapFree(GetProcessHeap(), 0, swapped_data
);
1077 This
->lines_written
++;
1080 LeaveCriticalSection(&This
->lock
);
1081 HeapFree(GetProcessHeap(), 0, swapped_data
);
1086 static HRESULT WINAPI
JpegEncoder_Frame_WriteSource(IWICBitmapFrameEncode
*iface
,
1087 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1089 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1092 WICPixelFormatGUID guid
;
1095 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1097 if (!This
->frame_initialized
|| !This
->width
|| !This
->height
)
1098 return WINCODEC_ERR_WRONGSTATE
;
1102 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1103 if (FAILED(hr
)) return hr
;
1104 hr
= IWICBitmapFrameEncode_SetPixelFormat(iface
, &guid
);
1105 if (FAILED(hr
)) return hr
;
1108 hr
= IWICBitmapSource_GetPixelFormat(pIBitmapSource
, &guid
);
1109 if (FAILED(hr
)) return hr
;
1110 if (memcmp(&guid
, This
->format
->guid
, sizeof(GUID
)) != 0)
1112 /* FIXME: should use WICConvertBitmapSource to convert */
1113 ERR("format %s unsupported\n", debugstr_guid(&guid
));
1117 if (This
->xres
== 0.0 || This
->yres
== 0.0)
1120 hr
= IWICBitmapSource_GetResolution(pIBitmapSource
, &xres
, &yres
);
1121 if (FAILED(hr
)) return hr
;
1122 hr
= IWICBitmapFrameEncode_SetResolution(iface
, xres
, yres
);
1123 if (FAILED(hr
)) return hr
;
1129 hr
= IWICBitmapSource_GetSize(pIBitmapSource
, &width
, &height
);
1130 if (FAILED(hr
)) return hr
;
1138 if (prc
->Width
!= This
->width
) return E_INVALIDARG
;
1140 stride
= (This
->format
->bpp
* This
->width
+ 7)/8;
1142 pixeldata
= HeapAlloc(GetProcessHeap(), 0, stride
* prc
->Height
);
1143 if (!pixeldata
) return E_OUTOFMEMORY
;
1145 hr
= IWICBitmapSource_CopyPixels(pIBitmapSource
, prc
, stride
,
1146 stride
*prc
->Height
, pixeldata
);
1150 hr
= IWICBitmapFrameEncode_WritePixels(iface
, prc
->Height
, stride
,
1151 stride
*prc
->Height
, pixeldata
);
1154 HeapFree(GetProcessHeap(), 0, pixeldata
);
1159 static HRESULT WINAPI
JpegEncoder_Frame_Commit(IWICBitmapFrameEncode
*iface
)
1161 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1163 TRACE("(%p)\n", iface
);
1165 EnterCriticalSection(&This
->lock
);
1167 if (!This
->started_compress
|| This
->lines_written
!= This
->height
|| This
->frame_committed
)
1169 LeaveCriticalSection(&This
->lock
);
1170 return WINCODEC_ERR_WRONGSTATE
;
1173 /* set up setjmp/longjmp error handling */
1176 LeaveCriticalSection(&This
->lock
);
1179 This
->cinfo
.client_data
= jmpbuf
;
1181 pjpeg_finish_compress(&This
->cinfo
);
1183 This
->frame_committed
= TRUE
;
1185 LeaveCriticalSection(&This
->lock
);
1190 static HRESULT WINAPI
JpegEncoder_Frame_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1191 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1193 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1197 static const IWICBitmapFrameEncodeVtbl JpegEncoder_FrameVtbl
= {
1198 JpegEncoder_Frame_QueryInterface
,
1199 JpegEncoder_Frame_AddRef
,
1200 JpegEncoder_Frame_Release
,
1201 JpegEncoder_Frame_Initialize
,
1202 JpegEncoder_Frame_SetSize
,
1203 JpegEncoder_Frame_SetResolution
,
1204 JpegEncoder_Frame_SetPixelFormat
,
1205 JpegEncoder_Frame_SetColorContexts
,
1206 JpegEncoder_Frame_SetPalette
,
1207 JpegEncoder_Frame_SetThumbnail
,
1208 JpegEncoder_Frame_WritePixels
,
1209 JpegEncoder_Frame_WriteSource
,
1210 JpegEncoder_Frame_Commit
,
1211 JpegEncoder_Frame_GetMetadataQueryWriter
1214 static HRESULT WINAPI
JpegEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1217 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1218 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1220 if (!ppv
) return E_INVALIDARG
;
1222 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1223 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1225 *ppv
= &This
->IWICBitmapEncoder_iface
;
1230 return E_NOINTERFACE
;
1233 IUnknown_AddRef((IUnknown
*)*ppv
);
1237 static ULONG WINAPI
JpegEncoder_AddRef(IWICBitmapEncoder
*iface
)
1239 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1240 ULONG ref
= InterlockedIncrement(&This
->ref
);
1242 TRACE("(%p) refcount=%u\n", iface
, ref
);
1247 static ULONG WINAPI
JpegEncoder_Release(IWICBitmapEncoder
*iface
)
1249 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1250 ULONG ref
= InterlockedDecrement(&This
->ref
);
1252 TRACE("(%p) refcount=%u\n", iface
, ref
);
1256 This
->lock
.DebugInfo
->Spare
[0] = 0;
1257 DeleteCriticalSection(&This
->lock
);
1258 if (This
->initialized
) pjpeg_destroy_compress(&This
->cinfo
);
1259 if (This
->stream
) IStream_Release(This
->stream
);
1260 HeapFree(GetProcessHeap(), 0, This
);
1266 static HRESULT WINAPI
JpegEncoder_Initialize(IWICBitmapEncoder
*iface
,
1267 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1269 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1272 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1274 EnterCriticalSection(&This
->lock
);
1276 if (This
->initialized
)
1278 LeaveCriticalSection(&This
->lock
);
1279 return WINCODEC_ERR_WRONGSTATE
;
1282 pjpeg_std_error(&This
->jerr
);
1284 This
->jerr
.error_exit
= error_exit_fn
;
1285 This
->jerr
.emit_message
= emit_message_fn
;
1287 This
->cinfo
.err
= &This
->jerr
;
1289 This
->cinfo
.client_data
= jmpbuf
;
1293 LeaveCriticalSection(&This
->lock
);
1297 pjpeg_CreateCompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_compress_struct
));
1299 This
->stream
= pIStream
;
1300 IStream_AddRef(pIStream
);
1302 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
1303 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
1305 This
->dest_mgr
.init_destination
= dest_mgr_init_destination
;
1306 This
->dest_mgr
.empty_output_buffer
= dest_mgr_empty_output_buffer
;
1307 This
->dest_mgr
.term_destination
= dest_mgr_term_destination
;
1309 This
->cinfo
.dest
= &This
->dest_mgr
;
1311 This
->initialized
= TRUE
;
1313 LeaveCriticalSection(&This
->lock
);
1318 static HRESULT WINAPI
JpegEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1319 GUID
*pguidContainerFormat
)
1321 FIXME("(%p,%s): stub\n", iface
, debugstr_guid(pguidContainerFormat
));
1325 static HRESULT WINAPI
JpegEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1326 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1328 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1332 static HRESULT WINAPI
JpegEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1333 UINT cCount
, IWICColorContext
**ppIColorContext
)
1335 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1339 static HRESULT WINAPI
JpegEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1341 TRACE("(%p,%p)\n", iface
, pIPalette
);
1342 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1345 static HRESULT WINAPI
JpegEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1347 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1348 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1351 static HRESULT WINAPI
JpegEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1353 TRACE("(%p,%p)\n", iface
, pIPreview
);
1354 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1357 static HRESULT WINAPI
JpegEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1358 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1360 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1363 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1365 EnterCriticalSection(&This
->lock
);
1367 if (This
->frame_count
!= 0)
1369 LeaveCriticalSection(&This
->lock
);
1370 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1373 if (!This
->initialized
)
1375 LeaveCriticalSection(&This
->lock
);
1376 return WINCODEC_ERR_NOTINITIALIZED
;
1379 hr
= CreatePropertyBag2(NULL
, 0, ppIEncoderOptions
);
1382 LeaveCriticalSection(&This
->lock
);
1386 This
->frame_count
= 1;
1388 LeaveCriticalSection(&This
->lock
);
1390 IWICBitmapEncoder_AddRef(iface
);
1391 *ppIFrameEncode
= &This
->IWICBitmapFrameEncode_iface
;
1396 static HRESULT WINAPI
JpegEncoder_Commit(IWICBitmapEncoder
*iface
)
1398 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1399 TRACE("(%p)\n", iface
);
1401 EnterCriticalSection(&This
->lock
);
1403 if (!This
->frame_committed
|| This
->committed
)
1405 LeaveCriticalSection(&This
->lock
);
1406 return WINCODEC_ERR_WRONGSTATE
;
1409 This
->committed
= TRUE
;
1411 LeaveCriticalSection(&This
->lock
);
1416 static HRESULT WINAPI
JpegEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
1417 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1419 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
1423 static const IWICBitmapEncoderVtbl JpegEncoder_Vtbl
= {
1424 JpegEncoder_QueryInterface
,
1426 JpegEncoder_Release
,
1427 JpegEncoder_Initialize
,
1428 JpegEncoder_GetContainerFormat
,
1429 JpegEncoder_GetEncoderInfo
,
1430 JpegEncoder_SetColorContexts
,
1431 JpegEncoder_SetPalette
,
1432 JpegEncoder_SetThumbnail
,
1433 JpegEncoder_SetPreview
,
1434 JpegEncoder_CreateNewFrame
,
1436 JpegEncoder_GetMetadataQueryWriter
1439 HRESULT
JpegEncoder_CreateInstance(REFIID iid
, void** ppv
)
1444 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
1448 if (!libjpeg_handle
&& !load_libjpeg())
1450 ERR("Failed writing JPEG because unable to find %s\n",SONAME_LIBJPEG
);
1454 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegEncoder
));
1455 if (!This
) return E_OUTOFMEMORY
;
1457 This
->IWICBitmapEncoder_iface
.lpVtbl
= &JpegEncoder_Vtbl
;
1458 This
->IWICBitmapFrameEncode_iface
.lpVtbl
= &JpegEncoder_FrameVtbl
;
1460 This
->initialized
= FALSE
;
1461 This
->frame_count
= 0;
1462 This
->frame_initialized
= FALSE
;
1463 This
->started_compress
= FALSE
;
1464 This
->lines_written
= 0;
1465 This
->frame_committed
= FALSE
;
1466 This
->committed
= FALSE
;
1467 This
->width
= This
->height
= 0;
1468 This
->xres
= This
->yres
= 0.0;
1469 This
->format
= NULL
;
1470 This
->stream
= NULL
;
1471 InitializeCriticalSection(&This
->lock
);
1472 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegEncoder.lock");
1474 ret
= IWICBitmapEncoder_QueryInterface(&This
->IWICBitmapEncoder_iface
, iid
, ppv
);
1475 IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
1480 #else /* !defined(SONAME_LIBJPEG) */
1482 HRESULT
JpegDecoder_CreateInstance(REFIID iid
, void** ppv
)
1484 ERR("Trying to load JPEG picture, but JPEG support is not compiled in.\n");
1488 HRESULT
JpegEncoder_CreateInstance(REFIID iid
, void** ppv
)
1490 ERR("Trying to save JPEG picture, but JPEG support is not compiled in.\n");