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
20 #include "wine/port.h"
31 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
33 #define UINT8 JPEG_UINT8
34 #define UINT16 JPEG_UINT16
35 #define boolean jpeg_boolean
39 #define HAVE_STDLIB_H 1
51 #include "wincodecs_private.h"
53 #include "wine/debug.h"
54 #include "wine/library.h"
56 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
59 WINE_DECLARE_DEBUG_CHANNEL(jpeg
);
61 static void *libjpeg_handle
;
63 static const WCHAR wszImageQuality
[] = {'I','m','a','g','e','Q','u','a','l','i','t','y',0};
64 static const WCHAR wszBitmapTransform
[] = {'B','i','t','m','a','p','T','r','a','n','s','f','o','r','m',0};
65 static const WCHAR wszLuminance
[] = {'L','u','m','i','n','a','n','c','e',0};
66 static const WCHAR wszChrominance
[] = {'C','h','r','o','m','i','n','a','n','c','e',0};
67 static const WCHAR wszJpegYCrCbSubsampling
[] = {'J','p','e','g','Y','C','r','C','b','S','u','b','s','a','m','p','l','i','n','g',0};
68 static const WCHAR wszSuppressApp0
[] = {'S','u','p','p','r','e','s','s','A','p','p','0',0};
70 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
71 MAKE_FUNCPTR(jpeg_CreateCompress
);
72 MAKE_FUNCPTR(jpeg_CreateDecompress
);
73 MAKE_FUNCPTR(jpeg_destroy_compress
);
74 MAKE_FUNCPTR(jpeg_destroy_decompress
);
75 MAKE_FUNCPTR(jpeg_finish_compress
);
76 MAKE_FUNCPTR(jpeg_read_header
);
77 MAKE_FUNCPTR(jpeg_read_scanlines
);
78 MAKE_FUNCPTR(jpeg_resync_to_restart
);
79 MAKE_FUNCPTR(jpeg_set_defaults
);
80 MAKE_FUNCPTR(jpeg_start_compress
);
81 MAKE_FUNCPTR(jpeg_start_decompress
);
82 MAKE_FUNCPTR(jpeg_std_error
);
83 MAKE_FUNCPTR(jpeg_write_scanlines
);
86 static void *load_libjpeg(void)
88 if((libjpeg_handle
= wine_dlopen(SONAME_LIBJPEG
, RTLD_NOW
, NULL
, 0)) != NULL
) {
90 #define LOAD_FUNCPTR(f) \
91 if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
92 libjpeg_handle = NULL; \
96 LOAD_FUNCPTR(jpeg_CreateCompress
);
97 LOAD_FUNCPTR(jpeg_CreateDecompress
);
98 LOAD_FUNCPTR(jpeg_destroy_compress
);
99 LOAD_FUNCPTR(jpeg_destroy_decompress
);
100 LOAD_FUNCPTR(jpeg_finish_compress
);
101 LOAD_FUNCPTR(jpeg_read_header
);
102 LOAD_FUNCPTR(jpeg_read_scanlines
);
103 LOAD_FUNCPTR(jpeg_resync_to_restart
);
104 LOAD_FUNCPTR(jpeg_set_defaults
);
105 LOAD_FUNCPTR(jpeg_start_compress
);
106 LOAD_FUNCPTR(jpeg_start_decompress
);
107 LOAD_FUNCPTR(jpeg_std_error
);
108 LOAD_FUNCPTR(jpeg_write_scanlines
);
111 return libjpeg_handle
;
114 static void error_exit_fn(j_common_ptr cinfo
)
116 char message
[JMSG_LENGTH_MAX
];
119 cinfo
->err
->format_message(cinfo
, message
);
120 ERR_(jpeg
)("%s\n", message
);
122 longjmp(*(jmp_buf*)cinfo
->client_data
, 1);
125 static void emit_message_fn(j_common_ptr cinfo
, int msg_level
)
127 char message
[JMSG_LENGTH_MAX
];
129 if (msg_level
< 0 && ERR_ON(jpeg
))
131 cinfo
->err
->format_message(cinfo
, message
);
132 ERR_(jpeg
)("%s\n", message
);
134 else if (msg_level
== 0 && WARN_ON(jpeg
))
136 cinfo
->err
->format_message(cinfo
, message
);
137 WARN_(jpeg
)("%s\n", message
);
139 else if (msg_level
> 0 && TRACE_ON(jpeg
))
141 cinfo
->err
->format_message(cinfo
, message
);
142 TRACE_(jpeg
)("%s\n", message
);
147 IWICBitmapDecoder IWICBitmapDecoder_iface
;
148 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
149 IWICMetadataBlockReader IWICMetadataBlockReader_iface
;
152 BOOL cinfo_initialized
;
154 struct jpeg_decompress_struct cinfo
;
155 struct jpeg_error_mgr jerr
;
156 struct jpeg_source_mgr source_mgr
;
157 BYTE source_buffer
[1024];
159 CRITICAL_SECTION lock
;
162 static inline JpegDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
164 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapDecoder_iface
);
167 static inline JpegDecoder
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
169 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapFrameDecode_iface
);
172 static inline JpegDecoder
*decoder_from_decompress(j_decompress_ptr decompress
)
174 return CONTAINING_RECORD(decompress
, JpegDecoder
, cinfo
);
177 static inline JpegDecoder
*impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader
*iface
)
179 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICMetadataBlockReader_iface
);
182 static HRESULT WINAPI
JpegDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
185 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
186 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
188 if (!ppv
) return E_INVALIDARG
;
190 if (IsEqualIID(&IID_IUnknown
, iid
) ||
191 IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
193 *ppv
= &This
->IWICBitmapDecoder_iface
;
198 return E_NOINTERFACE
;
201 IUnknown_AddRef((IUnknown
*)*ppv
);
205 static ULONG WINAPI
JpegDecoder_AddRef(IWICBitmapDecoder
*iface
)
207 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
208 ULONG ref
= InterlockedIncrement(&This
->ref
);
210 TRACE("(%p) refcount=%u\n", iface
, ref
);
215 static ULONG WINAPI
JpegDecoder_Release(IWICBitmapDecoder
*iface
)
217 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
218 ULONG ref
= InterlockedDecrement(&This
->ref
);
220 TRACE("(%p) refcount=%u\n", iface
, ref
);
224 This
->lock
.DebugInfo
->Spare
[0] = 0;
225 DeleteCriticalSection(&This
->lock
);
226 if (This
->cinfo_initialized
) pjpeg_destroy_decompress(&This
->cinfo
);
227 if (This
->stream
) IStream_Release(This
->stream
);
228 HeapFree(GetProcessHeap(), 0, This
->image_data
);
229 HeapFree(GetProcessHeap(), 0, This
);
235 static HRESULT WINAPI
JpegDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*stream
,
240 TRACE("(%p,%p,%p)\n", iface
, stream
, capability
);
242 if (!stream
|| !capability
) return E_INVALIDARG
;
244 hr
= IWICBitmapDecoder_Initialize(iface
, stream
, WICDecodeMetadataCacheOnDemand
);
245 if (hr
!= S_OK
) return hr
;
247 *capability
= WICBitmapDecoderCapabilityCanDecodeAllImages
|
248 WICBitmapDecoderCapabilityCanDecodeSomeImages
;
249 /* FIXME: WICBitmapDecoderCapabilityCanEnumerateMetadata */
253 static void source_mgr_init_source(j_decompress_ptr cinfo
)
257 static jpeg_boolean
source_mgr_fill_input_buffer(j_decompress_ptr cinfo
)
259 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
263 hr
= IStream_Read(This
->stream
, This
->source_buffer
, 1024, &bytesread
);
265 if (FAILED(hr
) || bytesread
== 0)
271 This
->source_mgr
.next_input_byte
= This
->source_buffer
;
272 This
->source_mgr
.bytes_in_buffer
= bytesread
;
277 static void source_mgr_skip_input_data(j_decompress_ptr cinfo
, long num_bytes
)
279 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
282 if (num_bytes
> This
->source_mgr
.bytes_in_buffer
)
284 seek
.QuadPart
= num_bytes
- This
->source_mgr
.bytes_in_buffer
;
285 IStream_Seek(This
->stream
, seek
, STREAM_SEEK_CUR
, NULL
);
286 This
->source_mgr
.bytes_in_buffer
= 0;
288 else if (num_bytes
> 0)
290 This
->source_mgr
.next_input_byte
+= num_bytes
;
291 This
->source_mgr
.bytes_in_buffer
-= num_bytes
;
295 static void source_mgr_term_source(j_decompress_ptr cinfo
)
299 static HRESULT WINAPI
JpegDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
300 WICDecodeOptions cacheOptions
)
302 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
306 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOptions
);
308 EnterCriticalSection(&This
->lock
);
310 if (This
->cinfo_initialized
)
312 LeaveCriticalSection(&This
->lock
);
313 return WINCODEC_ERR_WRONGSTATE
;
316 pjpeg_std_error(&This
->jerr
);
318 This
->jerr
.error_exit
= error_exit_fn
;
319 This
->jerr
.emit_message
= emit_message_fn
;
321 This
->cinfo
.err
= &This
->jerr
;
323 This
->cinfo
.client_data
= jmpbuf
;
327 LeaveCriticalSection(&This
->lock
);
331 pjpeg_CreateDecompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_decompress_struct
));
333 This
->cinfo_initialized
= TRUE
;
335 This
->stream
= pIStream
;
336 IStream_AddRef(pIStream
);
339 IStream_Seek(This
->stream
, seek
, STREAM_SEEK_SET
, NULL
);
341 This
->source_mgr
.bytes_in_buffer
= 0;
342 This
->source_mgr
.init_source
= source_mgr_init_source
;
343 This
->source_mgr
.fill_input_buffer
= source_mgr_fill_input_buffer
;
344 This
->source_mgr
.skip_input_data
= source_mgr_skip_input_data
;
345 This
->source_mgr
.resync_to_restart
= pjpeg_resync_to_restart
;
346 This
->source_mgr
.term_source
= source_mgr_term_source
;
348 This
->cinfo
.src
= &This
->source_mgr
;
350 ret
= pjpeg_read_header(&This
->cinfo
, TRUE
);
352 if (ret
!= JPEG_HEADER_OK
) {
353 WARN("Jpeg image in stream has bad format, read header returned %d.\n",ret
);
354 LeaveCriticalSection(&This
->lock
);
358 switch (This
->cinfo
.jpeg_color_space
)
361 This
->cinfo
.out_color_space
= JCS_GRAYSCALE
;
365 This
->cinfo
.out_color_space
= JCS_RGB
;
369 This
->cinfo
.out_color_space
= JCS_CMYK
;
372 ERR("Unknown JPEG color space %i\n", This
->cinfo
.jpeg_color_space
);
373 LeaveCriticalSection(&This
->lock
);
377 if (!pjpeg_start_decompress(&This
->cinfo
))
379 ERR("jpeg_start_decompress failed\n");
380 LeaveCriticalSection(&This
->lock
);
384 This
->initialized
= TRUE
;
386 LeaveCriticalSection(&This
->lock
);
391 static HRESULT WINAPI
JpegDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
392 GUID
*pguidContainerFormat
)
394 memcpy(pguidContainerFormat
, &GUID_ContainerFormatJpeg
, sizeof(GUID
));
398 static HRESULT WINAPI
JpegDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
399 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
401 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
403 return get_decoder_info(&CLSID_WICJpegDecoder
, ppIDecoderInfo
);
406 static HRESULT WINAPI
JpegDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
407 IWICPalette
*pIPalette
)
409 TRACE("(%p,%p)\n", iface
, pIPalette
);
411 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
414 static HRESULT WINAPI
JpegDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
415 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
417 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
421 static HRESULT WINAPI
JpegDecoder_GetPreview(IWICBitmapDecoder
*iface
,
422 IWICBitmapSource
**ppIBitmapSource
)
424 FIXME("(%p,%p): stub\n", iface
, ppIBitmapSource
);
425 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
428 static HRESULT WINAPI
JpegDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
429 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
431 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
432 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
435 static HRESULT WINAPI
JpegDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
436 IWICBitmapSource
**ppIThumbnail
)
438 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
439 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
442 static HRESULT WINAPI
JpegDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
445 if (!pCount
) return E_INVALIDARG
;
451 static HRESULT WINAPI
JpegDecoder_GetFrame(IWICBitmapDecoder
*iface
,
452 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
454 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
455 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
457 if (!This
->initialized
) return WINCODEC_ERR_FRAMEMISSING
;
459 if (index
!= 0) return E_INVALIDARG
;
461 IWICBitmapDecoder_AddRef(iface
);
462 *ppIBitmapFrame
= &This
->IWICBitmapFrameDecode_iface
;
467 static const IWICBitmapDecoderVtbl JpegDecoder_Vtbl
= {
468 JpegDecoder_QueryInterface
,
471 JpegDecoder_QueryCapability
,
472 JpegDecoder_Initialize
,
473 JpegDecoder_GetContainerFormat
,
474 JpegDecoder_GetDecoderInfo
,
475 JpegDecoder_CopyPalette
,
476 JpegDecoder_GetMetadataQueryReader
,
477 JpegDecoder_GetPreview
,
478 JpegDecoder_GetColorContexts
,
479 JpegDecoder_GetThumbnail
,
480 JpegDecoder_GetFrameCount
,
484 static HRESULT WINAPI
JpegDecoder_Frame_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
487 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
489 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
491 if (!ppv
) return E_INVALIDARG
;
493 if (IsEqualIID(&IID_IUnknown
, iid
) ||
494 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
495 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
497 *ppv
= &This
->IWICBitmapFrameDecode_iface
;
502 return E_NOINTERFACE
;
505 IUnknown_AddRef((IUnknown
*)*ppv
);
509 static ULONG WINAPI
JpegDecoder_Frame_AddRef(IWICBitmapFrameDecode
*iface
)
511 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
512 return IWICBitmapDecoder_AddRef(&This
->IWICBitmapDecoder_iface
);
515 static ULONG WINAPI
JpegDecoder_Frame_Release(IWICBitmapFrameDecode
*iface
)
517 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
518 return IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
521 static HRESULT WINAPI
JpegDecoder_Frame_GetSize(IWICBitmapFrameDecode
*iface
,
522 UINT
*puiWidth
, UINT
*puiHeight
)
524 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
525 *puiWidth
= This
->cinfo
.output_width
;
526 *puiHeight
= This
->cinfo
.output_height
;
527 TRACE("(%p)->(%u,%u)\n", iface
, *puiWidth
, *puiHeight
);
531 static HRESULT WINAPI
JpegDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
532 WICPixelFormatGUID
*pPixelFormat
)
534 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
535 TRACE("(%p,%p)\n", iface
, pPixelFormat
);
536 if (This
->cinfo
.out_color_space
== JCS_RGB
)
537 memcpy(pPixelFormat
, &GUID_WICPixelFormat24bppBGR
, sizeof(GUID
));
538 else if (This
->cinfo
.out_color_space
== JCS_CMYK
)
539 memcpy(pPixelFormat
, &GUID_WICPixelFormat32bppCMYK
, sizeof(GUID
));
540 else /* This->cinfo.out_color_space == JCS_GRAYSCALE */
541 memcpy(pPixelFormat
, &GUID_WICPixelFormat8bppGray
, sizeof(GUID
));
545 static HRESULT WINAPI
JpegDecoder_Frame_GetResolution(IWICBitmapFrameDecode
*iface
,
546 double *pDpiX
, double *pDpiY
)
548 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
550 EnterCriticalSection(&This
->lock
);
552 switch (This
->cinfo
.density_unit
)
554 case 2: /* pixels per centimeter */
555 *pDpiX
= This
->cinfo
.X_density
* 2.54;
556 *pDpiY
= This
->cinfo
.Y_density
* 2.54;
559 case 1: /* pixels per inch */
560 *pDpiX
= This
->cinfo
.X_density
;
561 *pDpiY
= This
->cinfo
.Y_density
;
564 case 0: /* unknown */
571 LeaveCriticalSection(&This
->lock
);
573 TRACE("(%p)->(%0.2f,%0.2f)\n", iface
, *pDpiX
, *pDpiY
);
578 static HRESULT WINAPI
JpegDecoder_Frame_CopyPalette(IWICBitmapFrameDecode
*iface
,
579 IWICPalette
*pIPalette
)
581 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
585 static HRESULT WINAPI
JpegDecoder_Frame_CopyPixels(IWICBitmapFrameDecode
*iface
,
586 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
588 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
595 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
601 rect
.Width
= This
->cinfo
.output_width
;
602 rect
.Height
= This
->cinfo
.output_height
;
607 if (prc
->X
< 0 || prc
->Y
< 0 || prc
->X
+prc
->Width
> This
->cinfo
.output_width
||
608 prc
->Y
+prc
->Height
> This
->cinfo
.output_height
)
612 if (This
->cinfo
.out_color_space
== JCS_GRAYSCALE
) bpp
= 8;
613 else if (This
->cinfo
.out_color_space
== JCS_CMYK
) bpp
= 32;
616 stride
= (bpp
* This
->cinfo
.output_width
+ 7) / 8;
617 data_size
= stride
* This
->cinfo
.output_height
;
619 max_row_needed
= prc
->Y
+ prc
->Height
;
620 if (max_row_needed
> This
->cinfo
.output_height
) return E_INVALIDARG
;
622 EnterCriticalSection(&This
->lock
);
624 if (!This
->image_data
)
626 This
->image_data
= HeapAlloc(GetProcessHeap(), 0, data_size
);
627 if (!This
->image_data
)
629 LeaveCriticalSection(&This
->lock
);
630 return E_OUTOFMEMORY
;
634 This
->cinfo
.client_data
= jmpbuf
;
638 LeaveCriticalSection(&This
->lock
);
642 while (max_row_needed
> This
->cinfo
.output_scanline
)
644 UINT first_scanline
= This
->cinfo
.output_scanline
;
646 JSAMPROW out_rows
[4];
650 max_rows
= min(This
->cinfo
.output_height
-first_scanline
, 4);
651 for (i
=0; i
<max_rows
; i
++)
652 out_rows
[i
] = This
->image_data
+ stride
* (first_scanline
+i
);
654 ret
= pjpeg_read_scanlines(&This
->cinfo
, out_rows
, max_rows
);
658 ERR("read_scanlines failed\n");
659 LeaveCriticalSection(&This
->lock
);
665 /* libjpeg gives us RGB data and we want BGR, so byteswap the data */
666 reverse_bgr8(3, This
->image_data
+ stride
* first_scanline
,
667 This
->cinfo
.output_width
, This
->cinfo
.output_scanline
- first_scanline
,
671 if (This
->cinfo
.out_color_space
== JCS_CMYK
&& This
->cinfo
.saw_Adobe_marker
)
673 DWORD
*pDwordData
= (DWORD
*) (This
->image_data
+ stride
* first_scanline
);
674 DWORD
*pDwordDataEnd
= (DWORD
*) (This
->image_data
+ This
->cinfo
.output_scanline
* stride
);
676 /* Adobe JPEG's have inverted CMYK data. */
677 while(pDwordData
< pDwordDataEnd
)
678 *pDwordData
++ ^= 0xffffffff;
683 LeaveCriticalSection(&This
->lock
);
685 return copy_pixels(bpp
, This
->image_data
,
686 This
->cinfo
.output_width
, This
->cinfo
.output_height
, stride
,
687 prc
, cbStride
, cbBufferSize
, pbBuffer
);
690 static HRESULT WINAPI
JpegDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
691 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
693 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
695 TRACE("(%p,%p)\n", iface
, ppIMetadataQueryReader
);
697 if (!ppIMetadataQueryReader
)
700 return MetadataQueryReader_CreateInstance(&This
->IWICMetadataBlockReader_iface
, NULL
, ppIMetadataQueryReader
);
703 static HRESULT WINAPI
JpegDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode
*iface
,
704 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
706 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
707 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
710 static HRESULT WINAPI
JpegDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode
*iface
,
711 IWICBitmapSource
**ppIThumbnail
)
713 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
714 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
717 static const IWICBitmapFrameDecodeVtbl JpegDecoder_Frame_Vtbl
= {
718 JpegDecoder_Frame_QueryInterface
,
719 JpegDecoder_Frame_AddRef
,
720 JpegDecoder_Frame_Release
,
721 JpegDecoder_Frame_GetSize
,
722 JpegDecoder_Frame_GetPixelFormat
,
723 JpegDecoder_Frame_GetResolution
,
724 JpegDecoder_Frame_CopyPalette
,
725 JpegDecoder_Frame_CopyPixels
,
726 JpegDecoder_Frame_GetMetadataQueryReader
,
727 JpegDecoder_Frame_GetColorContexts
,
728 JpegDecoder_Frame_GetThumbnail
731 static HRESULT WINAPI
JpegDecoder_Block_QueryInterface(IWICMetadataBlockReader
*iface
, REFIID iid
,
734 JpegDecoder
*This
= impl_from_IWICMetadataBlockReader(iface
);
735 return IWICBitmapFrameDecode_QueryInterface(&This
->IWICBitmapFrameDecode_iface
, iid
, ppv
);
738 static ULONG WINAPI
JpegDecoder_Block_AddRef(IWICMetadataBlockReader
*iface
)
740 JpegDecoder
*This
= impl_from_IWICMetadataBlockReader(iface
);
741 return IWICBitmapDecoder_AddRef(&This
->IWICBitmapDecoder_iface
);
744 static ULONG WINAPI
JpegDecoder_Block_Release(IWICMetadataBlockReader
*iface
)
746 JpegDecoder
*This
= impl_from_IWICMetadataBlockReader(iface
);
747 return IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
750 static HRESULT WINAPI
JpegDecoder_Block_GetContainerFormat(IWICMetadataBlockReader
*iface
,
751 GUID
*pguidContainerFormat
)
753 TRACE("%p,%p\n", iface
, pguidContainerFormat
);
755 if (!pguidContainerFormat
) return E_INVALIDARG
;
757 memcpy(pguidContainerFormat
, &GUID_ContainerFormatJpeg
, sizeof(GUID
));
762 static HRESULT WINAPI
JpegDecoder_Block_GetCount(IWICMetadataBlockReader
*iface
,
765 FIXME("%p,%p\n", iface
, pcCount
);
767 if (!pcCount
) return E_INVALIDARG
;
774 static HRESULT WINAPI
JpegDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader
*iface
,
775 UINT nIndex
, IWICMetadataReader
**ppIMetadataReader
)
777 FIXME("%p,%d,%p\n", iface
, nIndex
, ppIMetadataReader
);
781 static HRESULT WINAPI
JpegDecoder_Block_GetEnumerator(IWICMetadataBlockReader
*iface
,
782 IEnumUnknown
**ppIEnumMetadata
)
784 FIXME("%p,%p\n", iface
, ppIEnumMetadata
);
788 static const IWICMetadataBlockReaderVtbl JpegDecoder_Block_Vtbl
= {
789 JpegDecoder_Block_QueryInterface
,
790 JpegDecoder_Block_AddRef
,
791 JpegDecoder_Block_Release
,
792 JpegDecoder_Block_GetContainerFormat
,
793 JpegDecoder_Block_GetCount
,
794 JpegDecoder_Block_GetReaderByIndex
,
795 JpegDecoder_Block_GetEnumerator
,
798 HRESULT
JpegDecoder_CreateInstance(REFIID iid
, void** ppv
)
803 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
805 if (!libjpeg_handle
&& !load_libjpeg())
807 ERR("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG
);
813 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegDecoder
));
814 if (!This
) return E_OUTOFMEMORY
;
816 This
->IWICBitmapDecoder_iface
.lpVtbl
= &JpegDecoder_Vtbl
;
817 This
->IWICBitmapFrameDecode_iface
.lpVtbl
= &JpegDecoder_Frame_Vtbl
;
818 This
->IWICMetadataBlockReader_iface
.lpVtbl
= &JpegDecoder_Block_Vtbl
;
820 This
->initialized
= FALSE
;
821 This
->cinfo_initialized
= FALSE
;
823 This
->image_data
= NULL
;
824 InitializeCriticalSection(&This
->lock
);
825 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegDecoder.lock");
827 ret
= IWICBitmapDecoder_QueryInterface(&This
->IWICBitmapDecoder_iface
, iid
, ppv
);
828 IWICBitmapDecoder_Release(&This
->IWICBitmapDecoder_iface
);
833 typedef struct jpeg_compress_format
{
834 const WICPixelFormatGUID
*guid
;
837 J_COLOR_SPACE color_space
;
839 } jpeg_compress_format
;
841 static const jpeg_compress_format compress_formats
[] = {
842 { &GUID_WICPixelFormat24bppBGR
, 24, 3, JCS_RGB
, 1 },
843 { &GUID_WICPixelFormat32bppCMYK
, 32, 4, JCS_CMYK
},
844 { &GUID_WICPixelFormat8bppGray
, 8, 1, JCS_GRAYSCALE
},
848 typedef struct JpegEncoder
{
849 IWICBitmapEncoder IWICBitmapEncoder_iface
;
850 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
852 struct jpeg_compress_struct cinfo
;
853 struct jpeg_error_mgr jerr
;
854 struct jpeg_destination_mgr dest_mgr
;
857 BOOL frame_initialized
;
858 BOOL started_compress
;
860 BOOL frame_committed
;
864 const jpeg_compress_format
*format
;
866 WICColor palette
[256];
868 CRITICAL_SECTION lock
;
869 BYTE dest_buffer
[1024];
872 static inline JpegEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
874 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapEncoder_iface
);
877 static inline JpegEncoder
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
879 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapFrameEncode_iface
);
882 static inline JpegEncoder
*encoder_from_compress(j_compress_ptr compress
)
884 return CONTAINING_RECORD(compress
, JpegEncoder
, cinfo
);
887 static void dest_mgr_init_destination(j_compress_ptr cinfo
)
889 JpegEncoder
*This
= encoder_from_compress(cinfo
);
891 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
892 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
895 static jpeg_boolean
dest_mgr_empty_output_buffer(j_compress_ptr cinfo
)
897 JpegEncoder
*This
= encoder_from_compress(cinfo
);
901 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
902 sizeof(This
->dest_buffer
), &byteswritten
);
904 if (hr
!= S_OK
|| byteswritten
== 0)
906 ERR("Failed writing data, hr=%x\n", hr
);
910 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
911 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
915 static void dest_mgr_term_destination(j_compress_ptr cinfo
)
917 JpegEncoder
*This
= encoder_from_compress(cinfo
);
921 if (This
->dest_mgr
.free_in_buffer
!= sizeof(This
->dest_buffer
))
923 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
924 sizeof(This
->dest_buffer
) - This
->dest_mgr
.free_in_buffer
, &byteswritten
);
926 if (hr
!= S_OK
|| byteswritten
== 0)
927 ERR("Failed writing data, hr=%x\n", hr
);
931 static HRESULT WINAPI
JpegEncoder_Frame_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
934 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
935 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
937 if (!ppv
) return E_INVALIDARG
;
939 if (IsEqualIID(&IID_IUnknown
, iid
) ||
940 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
942 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
947 return E_NOINTERFACE
;
950 IUnknown_AddRef((IUnknown
*)*ppv
);
954 static ULONG WINAPI
JpegEncoder_Frame_AddRef(IWICBitmapFrameEncode
*iface
)
956 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
957 return IWICBitmapEncoder_AddRef(&This
->IWICBitmapEncoder_iface
);
960 static ULONG WINAPI
JpegEncoder_Frame_Release(IWICBitmapFrameEncode
*iface
)
962 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
963 return IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
966 static HRESULT WINAPI
JpegEncoder_Frame_Initialize(IWICBitmapFrameEncode
*iface
,
967 IPropertyBag2
*pIEncoderOptions
)
969 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
970 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
972 EnterCriticalSection(&This
->lock
);
974 if (This
->frame_initialized
)
976 LeaveCriticalSection(&This
->lock
);
977 return WINCODEC_ERR_WRONGSTATE
;
980 This
->frame_initialized
= TRUE
;
982 LeaveCriticalSection(&This
->lock
);
987 static HRESULT WINAPI
JpegEncoder_Frame_SetSize(IWICBitmapFrameEncode
*iface
,
988 UINT uiWidth
, UINT uiHeight
)
990 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
991 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
993 EnterCriticalSection(&This
->lock
);
995 if (!This
->frame_initialized
|| This
->started_compress
)
997 LeaveCriticalSection(&This
->lock
);
998 return WINCODEC_ERR_WRONGSTATE
;
1001 This
->width
= uiWidth
;
1002 This
->height
= uiHeight
;
1004 LeaveCriticalSection(&This
->lock
);
1009 static HRESULT WINAPI
JpegEncoder_Frame_SetResolution(IWICBitmapFrameEncode
*iface
,
1010 double dpiX
, double dpiY
)
1012 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1013 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
1015 EnterCriticalSection(&This
->lock
);
1017 if (!This
->frame_initialized
|| This
->started_compress
)
1019 LeaveCriticalSection(&This
->lock
);
1020 return WINCODEC_ERR_WRONGSTATE
;
1026 LeaveCriticalSection(&This
->lock
);
1031 static HRESULT WINAPI
JpegEncoder_Frame_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
1032 WICPixelFormatGUID
*pPixelFormat
)
1034 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1036 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
1038 EnterCriticalSection(&This
->lock
);
1040 if (!This
->frame_initialized
|| This
->started_compress
)
1042 LeaveCriticalSection(&This
->lock
);
1043 return WINCODEC_ERR_WRONGSTATE
;
1046 for (i
=0; compress_formats
[i
].guid
; i
++)
1048 if (memcmp(compress_formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
1052 if (!compress_formats
[i
].guid
) i
= 0;
1054 This
->format
= &compress_formats
[i
];
1055 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
1057 LeaveCriticalSection(&This
->lock
);
1062 static HRESULT WINAPI
JpegEncoder_Frame_SetColorContexts(IWICBitmapFrameEncode
*iface
,
1063 UINT cCount
, IWICColorContext
**ppIColorContext
)
1065 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1069 static HRESULT WINAPI
JpegEncoder_Frame_SetPalette(IWICBitmapFrameEncode
*iface
,
1070 IWICPalette
*palette
)
1072 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1075 TRACE("(%p,%p)\n", iface
, palette
);
1077 if (!palette
) return E_INVALIDARG
;
1079 EnterCriticalSection(&This
->lock
);
1081 if (This
->frame_initialized
)
1082 hr
= IWICPalette_GetColors(palette
, 256, This
->palette
, &This
->colors
);
1084 hr
= WINCODEC_ERR_NOTINITIALIZED
;
1086 LeaveCriticalSection(&This
->lock
);
1090 static HRESULT WINAPI
JpegEncoder_Frame_SetThumbnail(IWICBitmapFrameEncode
*iface
,
1091 IWICBitmapSource
*pIThumbnail
)
1093 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
1094 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1097 static HRESULT WINAPI
JpegEncoder_Frame_WritePixels(IWICBitmapFrameEncode
*iface
,
1098 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
1100 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1102 BYTE
*swapped_data
= NULL
, *current_row
;
1105 TRACE("(%p,%u,%u,%u,%p)\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
1107 EnterCriticalSection(&This
->lock
);
1109 if (!This
->frame_initialized
|| !This
->width
|| !This
->height
|| !This
->format
)
1111 LeaveCriticalSection(&This
->lock
);
1112 return WINCODEC_ERR_WRONGSTATE
;
1115 if (lineCount
== 0 || lineCount
+ This
->lines_written
> This
->height
)
1117 LeaveCriticalSection(&This
->lock
);
1118 return E_INVALIDARG
;
1121 /* set up setjmp/longjmp error handling */
1124 LeaveCriticalSection(&This
->lock
);
1125 HeapFree(GetProcessHeap(), 0, swapped_data
);
1128 This
->cinfo
.client_data
= jmpbuf
;
1130 if (!This
->started_compress
)
1132 This
->cinfo
.image_width
= This
->width
;
1133 This
->cinfo
.image_height
= This
->height
;
1134 This
->cinfo
.input_components
= This
->format
->num_components
;
1135 This
->cinfo
.in_color_space
= This
->format
->color_space
;
1137 pjpeg_set_defaults(&This
->cinfo
);
1139 if (This
->xres
!= 0.0 && This
->yres
!= 0.0)
1141 This
->cinfo
.density_unit
= 1; /* dots per inch */
1142 This
->cinfo
.X_density
= This
->xres
;
1143 This
->cinfo
.Y_density
= This
->yres
;
1146 pjpeg_start_compress(&This
->cinfo
, TRUE
);
1148 This
->started_compress
= TRUE
;
1151 row_size
= This
->format
->bpp
/ 8 * This
->width
;
1153 if (This
->format
->swap_rgb
)
1155 swapped_data
= HeapAlloc(GetProcessHeap(), 0, row_size
);
1158 LeaveCriticalSection(&This
->lock
);
1159 return E_OUTOFMEMORY
;
1163 for (line
=0; line
< lineCount
; line
++)
1165 if (This
->format
->swap_rgb
)
1169 memcpy(swapped_data
, pbPixels
+ (cbStride
* line
), row_size
);
1171 for (x
=0; x
< This
->width
; x
++)
1175 b
= swapped_data
[x
*3];
1176 swapped_data
[x
*3] = swapped_data
[x
*3+2];
1177 swapped_data
[x
*3+2] = b
;
1180 current_row
= swapped_data
;
1183 current_row
= pbPixels
+ (cbStride
* line
);
1185 if (!pjpeg_write_scanlines(&This
->cinfo
, ¤t_row
, 1))
1187 ERR("failed writing scanlines\n");
1188 LeaveCriticalSection(&This
->lock
);
1189 HeapFree(GetProcessHeap(), 0, swapped_data
);
1193 This
->lines_written
++;
1196 LeaveCriticalSection(&This
->lock
);
1197 HeapFree(GetProcessHeap(), 0, swapped_data
);
1202 static HRESULT WINAPI
JpegEncoder_Frame_WriteSource(IWICBitmapFrameEncode
*iface
,
1203 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
1205 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1207 TRACE("(%p,%p,%p)\n", iface
, pIBitmapSource
, prc
);
1209 if (!This
->frame_initialized
)
1210 return WINCODEC_ERR_WRONGSTATE
;
1212 hr
= configure_write_source(iface
, pIBitmapSource
, prc
,
1213 This
->format
? This
->format
->guid
: NULL
, This
->width
, This
->height
,
1214 This
->xres
, This
->yres
);
1218 hr
= write_source(iface
, pIBitmapSource
, prc
,
1219 This
->format
->guid
, This
->format
->bpp
, This
->width
, This
->height
);
1225 static HRESULT WINAPI
JpegEncoder_Frame_Commit(IWICBitmapFrameEncode
*iface
)
1227 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
1229 TRACE("(%p)\n", iface
);
1231 EnterCriticalSection(&This
->lock
);
1233 if (!This
->started_compress
|| This
->lines_written
!= This
->height
|| This
->frame_committed
)
1235 LeaveCriticalSection(&This
->lock
);
1236 return WINCODEC_ERR_WRONGSTATE
;
1239 /* set up setjmp/longjmp error handling */
1242 LeaveCriticalSection(&This
->lock
);
1245 This
->cinfo
.client_data
= jmpbuf
;
1247 pjpeg_finish_compress(&This
->cinfo
);
1249 This
->frame_committed
= TRUE
;
1251 LeaveCriticalSection(&This
->lock
);
1256 static HRESULT WINAPI
JpegEncoder_Frame_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
1257 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1259 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
1263 static const IWICBitmapFrameEncodeVtbl JpegEncoder_FrameVtbl
= {
1264 JpegEncoder_Frame_QueryInterface
,
1265 JpegEncoder_Frame_AddRef
,
1266 JpegEncoder_Frame_Release
,
1267 JpegEncoder_Frame_Initialize
,
1268 JpegEncoder_Frame_SetSize
,
1269 JpegEncoder_Frame_SetResolution
,
1270 JpegEncoder_Frame_SetPixelFormat
,
1271 JpegEncoder_Frame_SetColorContexts
,
1272 JpegEncoder_Frame_SetPalette
,
1273 JpegEncoder_Frame_SetThumbnail
,
1274 JpegEncoder_Frame_WritePixels
,
1275 JpegEncoder_Frame_WriteSource
,
1276 JpegEncoder_Frame_Commit
,
1277 JpegEncoder_Frame_GetMetadataQueryWriter
1280 static HRESULT WINAPI
JpegEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
1283 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1284 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
1286 if (!ppv
) return E_INVALIDARG
;
1288 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1289 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1291 *ppv
= &This
->IWICBitmapEncoder_iface
;
1296 return E_NOINTERFACE
;
1299 IUnknown_AddRef((IUnknown
*)*ppv
);
1303 static ULONG WINAPI
JpegEncoder_AddRef(IWICBitmapEncoder
*iface
)
1305 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1306 ULONG ref
= InterlockedIncrement(&This
->ref
);
1308 TRACE("(%p) refcount=%u\n", iface
, ref
);
1313 static ULONG WINAPI
JpegEncoder_Release(IWICBitmapEncoder
*iface
)
1315 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1316 ULONG ref
= InterlockedDecrement(&This
->ref
);
1318 TRACE("(%p) refcount=%u\n", iface
, ref
);
1322 This
->lock
.DebugInfo
->Spare
[0] = 0;
1323 DeleteCriticalSection(&This
->lock
);
1324 if (This
->initialized
) pjpeg_destroy_compress(&This
->cinfo
);
1325 if (This
->stream
) IStream_Release(This
->stream
);
1326 HeapFree(GetProcessHeap(), 0, This
);
1332 static HRESULT WINAPI
JpegEncoder_Initialize(IWICBitmapEncoder
*iface
,
1333 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1335 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1338 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1340 EnterCriticalSection(&This
->lock
);
1342 if (This
->initialized
)
1344 LeaveCriticalSection(&This
->lock
);
1345 return WINCODEC_ERR_WRONGSTATE
;
1348 pjpeg_std_error(&This
->jerr
);
1350 This
->jerr
.error_exit
= error_exit_fn
;
1351 This
->jerr
.emit_message
= emit_message_fn
;
1353 This
->cinfo
.err
= &This
->jerr
;
1355 This
->cinfo
.client_data
= jmpbuf
;
1359 LeaveCriticalSection(&This
->lock
);
1363 pjpeg_CreateCompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_compress_struct
));
1365 This
->stream
= pIStream
;
1366 IStream_AddRef(pIStream
);
1368 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
1369 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
1371 This
->dest_mgr
.init_destination
= dest_mgr_init_destination
;
1372 This
->dest_mgr
.empty_output_buffer
= dest_mgr_empty_output_buffer
;
1373 This
->dest_mgr
.term_destination
= dest_mgr_term_destination
;
1375 This
->cinfo
.dest
= &This
->dest_mgr
;
1377 This
->initialized
= TRUE
;
1379 LeaveCriticalSection(&This
->lock
);
1384 static HRESULT WINAPI
JpegEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1385 GUID
*pguidContainerFormat
)
1387 FIXME("(%p,%s): stub\n", iface
, debugstr_guid(pguidContainerFormat
));
1391 static HRESULT WINAPI
JpegEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1392 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1394 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1398 static HRESULT WINAPI
JpegEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1399 UINT cCount
, IWICColorContext
**ppIColorContext
)
1401 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1405 static HRESULT WINAPI
JpegEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1407 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1410 TRACE("(%p,%p)\n", iface
, pIPalette
);
1412 EnterCriticalSection(&This
->lock
);
1414 hr
= This
->initialized
? WINCODEC_ERR_UNSUPPORTEDOPERATION
: WINCODEC_ERR_NOTINITIALIZED
;
1416 LeaveCriticalSection(&This
->lock
);
1421 static HRESULT WINAPI
JpegEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1423 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1424 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1427 static HRESULT WINAPI
JpegEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1429 TRACE("(%p,%p)\n", iface
, pIPreview
);
1430 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1433 static HRESULT WINAPI
JpegEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1434 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1436 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1438 static const PROPBAG2 opts
[6] =
1440 { PROPBAG2_TYPE_DATA
, VT_R4
, 0, 0, (LPOLESTR
)wszImageQuality
},
1441 { PROPBAG2_TYPE_DATA
, VT_UI1
, 0, 0, (LPOLESTR
)wszBitmapTransform
},
1442 { PROPBAG2_TYPE_DATA
, VT_I4
| VT_ARRAY
, 0, 0, (LPOLESTR
)wszLuminance
},
1443 { PROPBAG2_TYPE_DATA
, VT_I4
| VT_ARRAY
, 0, 0, (LPOLESTR
)wszChrominance
},
1444 { PROPBAG2_TYPE_DATA
, VT_UI1
, 0, 0, (LPOLESTR
)wszJpegYCrCbSubsampling
},
1445 { PROPBAG2_TYPE_DATA
, VT_BOOL
, 0, 0, (LPOLESTR
)wszSuppressApp0
},
1448 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1450 EnterCriticalSection(&This
->lock
);
1452 if (This
->frame_count
!= 0)
1454 LeaveCriticalSection(&This
->lock
);
1455 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1458 if (!This
->initialized
)
1460 LeaveCriticalSection(&This
->lock
);
1461 return WINCODEC_ERR_NOTINITIALIZED
;
1464 if (ppIEncoderOptions
)
1466 hr
= CreatePropertyBag2(opts
, sizeof(opts
)/sizeof(opts
[0]), ppIEncoderOptions
);
1469 LeaveCriticalSection(&This
->lock
);
1474 This
->frame_count
= 1;
1476 LeaveCriticalSection(&This
->lock
);
1478 IWICBitmapEncoder_AddRef(iface
);
1479 *ppIFrameEncode
= &This
->IWICBitmapFrameEncode_iface
;
1484 static HRESULT WINAPI
JpegEncoder_Commit(IWICBitmapEncoder
*iface
)
1486 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1487 TRACE("(%p)\n", iface
);
1489 EnterCriticalSection(&This
->lock
);
1491 if (!This
->frame_committed
|| This
->committed
)
1493 LeaveCriticalSection(&This
->lock
);
1494 return WINCODEC_ERR_WRONGSTATE
;
1497 This
->committed
= TRUE
;
1499 LeaveCriticalSection(&This
->lock
);
1504 static HRESULT WINAPI
JpegEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
1505 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1507 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
1511 static const IWICBitmapEncoderVtbl JpegEncoder_Vtbl
= {
1512 JpegEncoder_QueryInterface
,
1514 JpegEncoder_Release
,
1515 JpegEncoder_Initialize
,
1516 JpegEncoder_GetContainerFormat
,
1517 JpegEncoder_GetEncoderInfo
,
1518 JpegEncoder_SetColorContexts
,
1519 JpegEncoder_SetPalette
,
1520 JpegEncoder_SetThumbnail
,
1521 JpegEncoder_SetPreview
,
1522 JpegEncoder_CreateNewFrame
,
1524 JpegEncoder_GetMetadataQueryWriter
1527 HRESULT
JpegEncoder_CreateInstance(REFIID iid
, void** ppv
)
1532 TRACE("(%s,%p)\n", debugstr_guid(iid
), ppv
);
1536 if (!libjpeg_handle
&& !load_libjpeg())
1538 ERR("Failed writing JPEG because unable to find %s\n",SONAME_LIBJPEG
);
1542 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegEncoder
));
1543 if (!This
) return E_OUTOFMEMORY
;
1545 This
->IWICBitmapEncoder_iface
.lpVtbl
= &JpegEncoder_Vtbl
;
1546 This
->IWICBitmapFrameEncode_iface
.lpVtbl
= &JpegEncoder_FrameVtbl
;
1548 This
->initialized
= FALSE
;
1549 This
->frame_count
= 0;
1550 This
->frame_initialized
= FALSE
;
1551 This
->started_compress
= FALSE
;
1552 This
->lines_written
= 0;
1553 This
->frame_committed
= FALSE
;
1554 This
->committed
= FALSE
;
1555 This
->width
= This
->height
= 0;
1556 This
->xres
= This
->yres
= 0.0;
1557 This
->format
= NULL
;
1558 This
->stream
= NULL
;
1560 InitializeCriticalSection(&This
->lock
);
1561 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegEncoder.lock");
1563 ret
= IWICBitmapEncoder_QueryInterface(&This
->IWICBitmapEncoder_iface
, iid
, ppv
);
1564 IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
1569 #else /* !defined(SONAME_LIBJPEG) */
1571 HRESULT
JpegDecoder_CreateInstance(REFIID iid
, void** ppv
)
1573 ERR("Trying to load JPEG picture, but JPEG support is not compiled in.\n");
1577 HRESULT
JpegEncoder_CreateInstance(REFIID iid
, void** ppv
)
1579 ERR("Trying to save JPEG picture, but JPEG support is not compiled in.\n");