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
52 #include "wincodecs_private.h"
54 #include "wine/debug.h"
55 #include "wine/library.h"
57 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
60 WINE_DECLARE_DEBUG_CHANNEL(jpeg
);
62 static void *libjpeg_handle
;
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
);
76 static void *load_libjpeg(void)
78 if((libjpeg_handle
= wine_dlopen(SONAME_LIBJPEG
, RTLD_NOW
, NULL
, 0)) != NULL
) {
80 #define LOAD_FUNCPTR(f) \
81 if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
82 libjpeg_handle = NULL; \
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
);
97 return libjpeg_handle
;
100 static void error_exit_fn(j_common_ptr cinfo
)
102 char message
[JMSG_LENGTH_MAX
];
105 cinfo
->err
->format_message(cinfo
, message
);
106 ERR_(jpeg
)("%s\n", message
);
108 longjmp(*(jmp_buf*)cinfo
->client_data
, 1);
111 static void emit_message_fn(j_common_ptr cinfo
, int msg_level
)
113 char message
[JMSG_LENGTH_MAX
];
115 if (msg_level
< 0 && ERR_ON(jpeg
))
117 cinfo
->err
->format_message(cinfo
, message
);
118 ERR_(jpeg
)("%s\n", message
);
120 else if (msg_level
== 0 && WARN_ON(jpeg
))
122 cinfo
->err
->format_message(cinfo
, message
);
123 WARN_(jpeg
)("%s\n", message
);
125 else if (msg_level
> 0 && TRACE_ON(jpeg
))
127 cinfo
->err
->format_message(cinfo
, message
);
128 TRACE_(jpeg
)("%s\n", message
);
133 IWICBitmapDecoder IWICBitmapDecoder_iface
;
134 IWICBitmapFrameDecode IWICBitmapFrameDecode_iface
;
137 BOOL cinfo_initialized
;
139 struct jpeg_decompress_struct cinfo
;
140 struct jpeg_error_mgr jerr
;
141 struct jpeg_source_mgr source_mgr
;
142 BYTE source_buffer
[1024];
144 CRITICAL_SECTION lock
;
147 static inline JpegDecoder
*impl_from_IWICBitmapDecoder(IWICBitmapDecoder
*iface
)
149 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapDecoder_iface
);
152 static inline JpegDecoder
*impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode
*iface
)
154 return CONTAINING_RECORD(iface
, JpegDecoder
, IWICBitmapFrameDecode_iface
);
157 static inline JpegDecoder
*decoder_from_decompress(j_decompress_ptr decompress
)
159 return CONTAINING_RECORD(decompress
, JpegDecoder
, cinfo
);
162 static HRESULT WINAPI
JpegDecoder_QueryInterface(IWICBitmapDecoder
*iface
, REFIID iid
,
165 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
166 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
168 if (!ppv
) return E_INVALIDARG
;
170 if (IsEqualIID(&IID_IUnknown
, iid
) || IsEqualIID(&IID_IWICBitmapDecoder
, iid
))
177 return E_NOINTERFACE
;
180 IUnknown_AddRef((IUnknown
*)*ppv
);
184 static ULONG WINAPI
JpegDecoder_AddRef(IWICBitmapDecoder
*iface
)
186 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
187 ULONG ref
= InterlockedIncrement(&This
->ref
);
189 TRACE("(%p) refcount=%u\n", iface
, ref
);
194 static ULONG WINAPI
JpegDecoder_Release(IWICBitmapDecoder
*iface
)
196 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
197 ULONG ref
= InterlockedDecrement(&This
->ref
);
199 TRACE("(%p) refcount=%u\n", iface
, ref
);
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
);
214 static HRESULT WINAPI
JpegDecoder_QueryCapability(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
215 DWORD
*pdwCapability
)
217 FIXME("(%p,%p,%p): stub\n", iface
, pIStream
, pdwCapability
);
221 static void source_mgr_init_source(j_decompress_ptr cinfo
)
225 static jpeg_boolean
source_mgr_fill_input_buffer(j_decompress_ptr cinfo
)
227 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
231 hr
= IStream_Read(This
->stream
, This
->source_buffer
, 1024, &bytesread
);
233 if (hr
!= S_OK
|| bytesread
== 0)
239 This
->source_mgr
.next_input_byte
= This
->source_buffer
;
240 This
->source_mgr
.bytes_in_buffer
= bytesread
;
245 static void source_mgr_skip_input_data(j_decompress_ptr cinfo
, long num_bytes
)
247 JpegDecoder
*This
= decoder_from_decompress(cinfo
);
250 if (num_bytes
> This
->source_mgr
.bytes_in_buffer
)
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;
256 else if (num_bytes
> 0)
258 This
->source_mgr
.next_input_byte
+= num_bytes
;
259 This
->source_mgr
.bytes_in_buffer
-= num_bytes
;
263 static void source_mgr_term_source(j_decompress_ptr cinfo
)
267 static HRESULT WINAPI
JpegDecoder_Initialize(IWICBitmapDecoder
*iface
, IStream
*pIStream
,
268 WICDecodeOptions cacheOptions
)
270 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
274 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOptions
);
276 EnterCriticalSection(&This
->lock
);
278 if (This
->cinfo_initialized
)
280 LeaveCriticalSection(&This
->lock
);
281 return WINCODEC_ERR_WRONGSTATE
;
284 pjpeg_std_error(&This
->jerr
);
286 This
->jerr
.error_exit
= error_exit_fn
;
287 This
->jerr
.emit_message
= emit_message_fn
;
289 This
->cinfo
.err
= &This
->jerr
;
291 This
->cinfo
.client_data
= jmpbuf
;
295 LeaveCriticalSection(&This
->lock
);
299 pjpeg_CreateDecompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_decompress_struct
));
301 This
->cinfo_initialized
= TRUE
;
303 This
->stream
= pIStream
;
304 IStream_AddRef(pIStream
);
307 IStream_Seek(This
->stream
, seek
, STREAM_SEEK_SET
, NULL
);
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
;
316 This
->cinfo
.src
= &This
->source_mgr
;
318 ret
= pjpeg_read_header(&This
->cinfo
, TRUE
);
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
);
326 switch (This
->cinfo
.jpeg_color_space
)
329 This
->cinfo
.out_color_space
= JCS_GRAYSCALE
;
333 This
->cinfo
.out_color_space
= JCS_RGB
;
337 This
->cinfo
.out_color_space
= JCS_CMYK
;
340 ERR("Unknown JPEG color space %i\n", This
->cinfo
.jpeg_color_space
);
341 LeaveCriticalSection(&This
->lock
);
345 if (!pjpeg_start_decompress(&This
->cinfo
))
347 ERR("jpeg_start_decompress failed\n");
348 LeaveCriticalSection(&This
->lock
);
352 This
->initialized
= TRUE
;
354 LeaveCriticalSection(&This
->lock
);
359 static HRESULT WINAPI
JpegDecoder_GetContainerFormat(IWICBitmapDecoder
*iface
,
360 GUID
*pguidContainerFormat
)
362 memcpy(pguidContainerFormat
, &GUID_ContainerFormatJpeg
, sizeof(GUID
));
366 static HRESULT WINAPI
JpegDecoder_GetDecoderInfo(IWICBitmapDecoder
*iface
,
367 IWICBitmapDecoderInfo
**ppIDecoderInfo
)
370 IWICComponentInfo
*compinfo
;
372 TRACE("(%p,%p)\n", iface
, ppIDecoderInfo
);
374 hr
= CreateComponentInfo(&CLSID_WICJpegDecoder
, &compinfo
);
375 if (FAILED(hr
)) return hr
;
377 hr
= IWICComponentInfo_QueryInterface(compinfo
, &IID_IWICBitmapDecoderInfo
,
378 (void**)ppIDecoderInfo
);
380 IWICComponentInfo_Release(compinfo
);
385 static HRESULT WINAPI
JpegDecoder_CopyPalette(IWICBitmapDecoder
*iface
,
386 IWICPalette
*pIPalette
)
388 TRACE("(%p,%p)\n", iface
, pIPalette
);
390 return WINCODEC_ERR_PALETTEUNAVAILABLE
;
393 static HRESULT WINAPI
JpegDecoder_GetMetadataQueryReader(IWICBitmapDecoder
*iface
,
394 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
396 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
400 static HRESULT WINAPI
JpegDecoder_GetPreview(IWICBitmapDecoder
*iface
,
401 IWICBitmapSource
**ppIBitmapSource
)
403 FIXME("(%p,%p): stub\n", iface
, ppIBitmapSource
);
404 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
407 static HRESULT WINAPI
JpegDecoder_GetColorContexts(IWICBitmapDecoder
*iface
,
408 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
410 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
411 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
414 static HRESULT WINAPI
JpegDecoder_GetThumbnail(IWICBitmapDecoder
*iface
,
415 IWICBitmapSource
**ppIThumbnail
)
417 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
418 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
421 static HRESULT WINAPI
JpegDecoder_GetFrameCount(IWICBitmapDecoder
*iface
,
428 static HRESULT WINAPI
JpegDecoder_GetFrame(IWICBitmapDecoder
*iface
,
429 UINT index
, IWICBitmapFrameDecode
**ppIBitmapFrame
)
431 JpegDecoder
*This
= impl_from_IWICBitmapDecoder(iface
);
432 TRACE("(%p,%u,%p)\n", iface
, index
, ppIBitmapFrame
);
434 if (!This
->initialized
) return WINCODEC_ERR_NOTINITIALIZED
;
436 if (index
!= 0) return E_INVALIDARG
;
438 IWICBitmapDecoder_AddRef(iface
);
439 *ppIBitmapFrame
= &This
->IWICBitmapFrameDecode_iface
;
444 static const IWICBitmapDecoderVtbl JpegDecoder_Vtbl
= {
445 JpegDecoder_QueryInterface
,
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
,
461 static HRESULT WINAPI
JpegDecoder_Frame_QueryInterface(IWICBitmapFrameDecode
*iface
, REFIID iid
,
464 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
466 if (!ppv
) return E_INVALIDARG
;
468 if (IsEqualIID(&IID_IUnknown
, iid
) ||
469 IsEqualIID(&IID_IWICBitmapSource
, iid
) ||
470 IsEqualIID(&IID_IWICBitmapFrameDecode
, iid
))
477 return E_NOINTERFACE
;
480 IUnknown_AddRef((IUnknown
*)*ppv
);
484 static ULONG WINAPI
JpegDecoder_Frame_AddRef(IWICBitmapFrameDecode
*iface
)
486 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
487 return IUnknown_AddRef((IUnknown
*)This
);
490 static ULONG WINAPI
JpegDecoder_Frame_Release(IWICBitmapFrameDecode
*iface
)
492 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
493 return IUnknown_Release((IUnknown
*)This
);
496 static HRESULT WINAPI
JpegDecoder_Frame_GetSize(IWICBitmapFrameDecode
*iface
,
497 UINT
*puiWidth
, UINT
*puiHeight
)
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
);
506 static HRESULT WINAPI
JpegDecoder_Frame_GetPixelFormat(IWICBitmapFrameDecode
*iface
,
507 WICPixelFormatGUID
*pPixelFormat
)
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
));
520 static HRESULT WINAPI
JpegDecoder_Frame_GetResolution(IWICBitmapFrameDecode
*iface
,
521 double *pDpiX
, double *pDpiY
)
523 FIXME("(%p,%p,%p): stub\n", iface
, pDpiX
, pDpiY
);
527 static HRESULT WINAPI
JpegDecoder_Frame_CopyPalette(IWICBitmapFrameDecode
*iface
,
528 IWICPalette
*pIPalette
)
530 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
534 static HRESULT WINAPI
JpegDecoder_Frame_CopyPixels(IWICBitmapFrameDecode
*iface
,
535 const WICRect
*prc
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbBuffer
)
537 JpegDecoder
*This
= impl_from_IWICBitmapFrameDecode(iface
);
544 TRACE("(%p,%p,%u,%u,%p)\n", iface
, prc
, cbStride
, cbBufferSize
, pbBuffer
);
550 rect
.Width
= This
->cinfo
.output_width
;
551 rect
.Height
= This
->cinfo
.output_height
;
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
)
561 if (This
->cinfo
.out_color_space
== JCS_GRAYSCALE
) bpp
= 8;
562 else if (This
->cinfo
.out_color_space
== JCS_CMYK
) bpp
= 32;
565 stride
= bpp
* This
->cinfo
.output_width
;
566 data_size
= stride
* This
->cinfo
.output_height
;
568 max_row_needed
= prc
->Y
+ prc
->Height
;
569 if (max_row_needed
> This
->cinfo
.output_height
) return E_INVALIDARG
;
571 EnterCriticalSection(&This
->lock
);
573 if (!This
->image_data
)
575 This
->image_data
= HeapAlloc(GetProcessHeap(), 0, data_size
);
576 if (!This
->image_data
)
578 LeaveCriticalSection(&This
->lock
);
579 return E_OUTOFMEMORY
;
583 This
->cinfo
.client_data
= jmpbuf
;
587 LeaveCriticalSection(&This
->lock
);
591 while (max_row_needed
> This
->cinfo
.output_scanline
)
593 UINT first_scanline
= This
->cinfo
.output_scanline
;
595 JSAMPROW out_rows
[4];
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
);
603 ret
= pjpeg_read_scanlines(&This
->cinfo
, out_rows
, max_rows
);
607 ERR("read_scanlines failed\n");
608 LeaveCriticalSection(&This
->lock
);
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
,
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;
626 LeaveCriticalSection(&This
->lock
);
628 return copy_pixels(bpp
, This
->image_data
,
629 This
->cinfo
.output_width
, This
->cinfo
.output_height
, stride
,
630 prc
, cbStride
, cbBufferSize
, pbBuffer
);
633 static HRESULT WINAPI
JpegDecoder_Frame_GetMetadataQueryReader(IWICBitmapFrameDecode
*iface
,
634 IWICMetadataQueryReader
**ppIMetadataQueryReader
)
636 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryReader
);
637 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
640 static HRESULT WINAPI
JpegDecoder_Frame_GetColorContexts(IWICBitmapFrameDecode
*iface
,
641 UINT cCount
, IWICColorContext
**ppIColorContexts
, UINT
*pcActualCount
)
643 FIXME("(%p,%u,%p,%p): stub\n", iface
, cCount
, ppIColorContexts
, pcActualCount
);
644 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
647 static HRESULT WINAPI
JpegDecoder_Frame_GetThumbnail(IWICBitmapFrameDecode
*iface
,
648 IWICBitmapSource
**ppIThumbnail
)
650 FIXME("(%p,%p): stub\n", iface
, ppIThumbnail
);
651 return WINCODEC_ERR_CODECNOTHUMBNAIL
;
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
668 HRESULT
JpegDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
673 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
675 if (!libjpeg_handle
&& !load_libjpeg())
677 ERR("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG
);
683 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
685 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegDecoder
));
686 if (!This
) return E_OUTOFMEMORY
;
688 This
->IWICBitmapDecoder_iface
.lpVtbl
= &JpegDecoder_Vtbl
;
689 This
->IWICBitmapFrameDecode_iface
.lpVtbl
= &JpegDecoder_Frame_Vtbl
;
691 This
->initialized
= FALSE
;
692 This
->cinfo_initialized
= FALSE
;
694 This
->image_data
= NULL
;
695 InitializeCriticalSection(&This
->lock
);
696 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegDecoder.lock");
698 ret
= IUnknown_QueryInterface((IUnknown
*)This
, iid
, ppv
);
699 IUnknown_Release((IUnknown
*)This
);
704 typedef struct jpeg_compress_format
{
705 const WICPixelFormatGUID
*guid
;
708 J_COLOR_SPACE color_space
;
710 } jpeg_compress_format
;
712 static const jpeg_compress_format compress_formats
[] = {
713 { &GUID_WICPixelFormat24bppBGR
, 24, 3, JCS_RGB
, 1 },
714 { &GUID_WICPixelFormat32bppCMYK
, 32, 4, JCS_CMYK
},
715 { &GUID_WICPixelFormat8bppGray
, 8, 1, JCS_GRAYSCALE
},
719 typedef struct JpegEncoder
{
720 IWICBitmapEncoder IWICBitmapEncoder_iface
;
721 IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
;
723 struct jpeg_compress_struct cinfo
;
724 struct jpeg_error_mgr jerr
;
725 struct jpeg_destination_mgr dest_mgr
;
728 int frame_initialized
;
729 int started_compress
;
732 const jpeg_compress_format
*format
;
734 CRITICAL_SECTION lock
;
735 BYTE dest_buffer
[1024];
738 static inline JpegEncoder
*impl_from_IWICBitmapEncoder(IWICBitmapEncoder
*iface
)
740 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapEncoder_iface
);
743 static inline JpegEncoder
*impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode
*iface
)
745 return CONTAINING_RECORD(iface
, JpegEncoder
, IWICBitmapFrameEncode_iface
);
748 static inline JpegEncoder
*encoder_from_compress(j_compress_ptr compress
)
750 return CONTAINING_RECORD(compress
, JpegEncoder
, cinfo
);
753 static void dest_mgr_init_destination(j_compress_ptr cinfo
)
755 JpegEncoder
*This
= encoder_from_compress(cinfo
);
757 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
758 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
761 static jpeg_boolean
dest_mgr_empty_output_buffer(j_compress_ptr cinfo
)
763 JpegEncoder
*This
= encoder_from_compress(cinfo
);
767 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
768 sizeof(This
->dest_buffer
), &byteswritten
);
770 if (hr
!= S_OK
|| byteswritten
== 0)
772 ERR("Failed writing data, hr=%x\n", hr
);
776 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
777 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
781 static void dest_mgr_term_destination(j_compress_ptr cinfo
)
783 JpegEncoder
*This
= encoder_from_compress(cinfo
);
787 if (This
->dest_mgr
.free_in_buffer
!= sizeof(This
->dest_buffer
))
789 hr
= IStream_Write(This
->stream
, This
->dest_buffer
,
790 sizeof(This
->dest_buffer
) - This
->dest_mgr
.free_in_buffer
, &byteswritten
);
792 if (hr
!= S_OK
|| byteswritten
== 0)
793 ERR("Failed writing data, hr=%x\n", hr
);
797 static HRESULT WINAPI
JpegEncoder_Frame_QueryInterface(IWICBitmapFrameEncode
*iface
, REFIID iid
,
800 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
801 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
803 if (!ppv
) return E_INVALIDARG
;
805 if (IsEqualIID(&IID_IUnknown
, iid
) ||
806 IsEqualIID(&IID_IWICBitmapFrameEncode
, iid
))
808 *ppv
= &This
->IWICBitmapFrameEncode_iface
;
813 return E_NOINTERFACE
;
816 IUnknown_AddRef((IUnknown
*)*ppv
);
820 static ULONG WINAPI
JpegEncoder_Frame_AddRef(IWICBitmapFrameEncode
*iface
)
822 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
823 return IWICBitmapEncoder_AddRef(&This
->IWICBitmapEncoder_iface
);
826 static ULONG WINAPI
JpegEncoder_Frame_Release(IWICBitmapFrameEncode
*iface
)
828 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
829 return IWICBitmapEncoder_Release(&This
->IWICBitmapEncoder_iface
);
832 static HRESULT WINAPI
JpegEncoder_Frame_Initialize(IWICBitmapFrameEncode
*iface
,
833 IPropertyBag2
*pIEncoderOptions
)
835 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
836 TRACE("(%p,%p)\n", iface
, pIEncoderOptions
);
838 EnterCriticalSection(&This
->lock
);
840 if (This
->frame_initialized
)
842 LeaveCriticalSection(&This
->lock
);
843 return WINCODEC_ERR_WRONGSTATE
;
846 This
->frame_initialized
= TRUE
;
848 LeaveCriticalSection(&This
->lock
);
853 static HRESULT WINAPI
JpegEncoder_Frame_SetSize(IWICBitmapFrameEncode
*iface
,
854 UINT uiWidth
, UINT uiHeight
)
856 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
857 TRACE("(%p,%u,%u)\n", iface
, uiWidth
, uiHeight
);
859 EnterCriticalSection(&This
->lock
);
861 if (!This
->frame_initialized
|| This
->started_compress
)
863 LeaveCriticalSection(&This
->lock
);
864 return WINCODEC_ERR_WRONGSTATE
;
867 This
->width
= uiWidth
;
868 This
->height
= uiHeight
;
870 LeaveCriticalSection(&This
->lock
);
875 static HRESULT WINAPI
JpegEncoder_Frame_SetResolution(IWICBitmapFrameEncode
*iface
,
876 double dpiX
, double dpiY
)
878 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
879 TRACE("(%p,%0.2f,%0.2f)\n", iface
, dpiX
, dpiY
);
881 EnterCriticalSection(&This
->lock
);
883 if (!This
->frame_initialized
|| This
->started_compress
)
885 LeaveCriticalSection(&This
->lock
);
886 return WINCODEC_ERR_WRONGSTATE
;
892 LeaveCriticalSection(&This
->lock
);
897 static HRESULT WINAPI
JpegEncoder_Frame_SetPixelFormat(IWICBitmapFrameEncode
*iface
,
898 WICPixelFormatGUID
*pPixelFormat
)
900 JpegEncoder
*This
= impl_from_IWICBitmapFrameEncode(iface
);
902 TRACE("(%p,%s)\n", iface
, debugstr_guid(pPixelFormat
));
904 EnterCriticalSection(&This
->lock
);
906 if (!This
->frame_initialized
|| This
->started_compress
)
908 LeaveCriticalSection(&This
->lock
);
909 return WINCODEC_ERR_WRONGSTATE
;
912 for (i
=0; compress_formats
[i
].guid
; i
++)
914 if (memcmp(compress_formats
[i
].guid
, pPixelFormat
, sizeof(GUID
)) == 0)
918 if (!compress_formats
[i
].guid
) i
= 0;
920 This
->format
= &compress_formats
[i
];
921 memcpy(pPixelFormat
, This
->format
->guid
, sizeof(GUID
));
923 LeaveCriticalSection(&This
->lock
);
928 static HRESULT WINAPI
JpegEncoder_Frame_SetColorContexts(IWICBitmapFrameEncode
*iface
,
929 UINT cCount
, IWICColorContext
**ppIColorContext
)
931 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
935 static HRESULT WINAPI
JpegEncoder_Frame_SetPalette(IWICBitmapFrameEncode
*iface
,
936 IWICPalette
*pIPalette
)
938 FIXME("(%p,%p): stub\n", iface
, pIPalette
);
939 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
942 static HRESULT WINAPI
JpegEncoder_Frame_SetThumbnail(IWICBitmapFrameEncode
*iface
,
943 IWICBitmapSource
*pIThumbnail
)
945 FIXME("(%p,%p): stub\n", iface
, pIThumbnail
);
946 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
949 static HRESULT WINAPI
JpegEncoder_Frame_WritePixels(IWICBitmapFrameEncode
*iface
,
950 UINT lineCount
, UINT cbStride
, UINT cbBufferSize
, BYTE
*pbPixels
)
952 FIXME("(%p,%u,%u,%u,%p): stub\n", iface
, lineCount
, cbStride
, cbBufferSize
, pbPixels
);
956 static HRESULT WINAPI
JpegEncoder_Frame_WriteSource(IWICBitmapFrameEncode
*iface
,
957 IWICBitmapSource
*pIBitmapSource
, WICRect
*prc
)
959 FIXME("(%p,%p,%p): stub\n", iface
, pIBitmapSource
, prc
);
963 static HRESULT WINAPI
JpegEncoder_Frame_Commit(IWICBitmapFrameEncode
*iface
)
965 FIXME("(%p): stub\n", iface
);
969 static HRESULT WINAPI
JpegEncoder_Frame_GetMetadataQueryWriter(IWICBitmapFrameEncode
*iface
,
970 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
972 FIXME("(%p, %p): stub\n", iface
, ppIMetadataQueryWriter
);
976 static const IWICBitmapFrameEncodeVtbl JpegEncoder_FrameVtbl
= {
977 JpegEncoder_Frame_QueryInterface
,
978 JpegEncoder_Frame_AddRef
,
979 JpegEncoder_Frame_Release
,
980 JpegEncoder_Frame_Initialize
,
981 JpegEncoder_Frame_SetSize
,
982 JpegEncoder_Frame_SetResolution
,
983 JpegEncoder_Frame_SetPixelFormat
,
984 JpegEncoder_Frame_SetColorContexts
,
985 JpegEncoder_Frame_SetPalette
,
986 JpegEncoder_Frame_SetThumbnail
,
987 JpegEncoder_Frame_WritePixels
,
988 JpegEncoder_Frame_WriteSource
,
989 JpegEncoder_Frame_Commit
,
990 JpegEncoder_Frame_GetMetadataQueryWriter
993 static HRESULT WINAPI
JpegEncoder_QueryInterface(IWICBitmapEncoder
*iface
, REFIID iid
,
996 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
997 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
999 if (!ppv
) return E_INVALIDARG
;
1001 if (IsEqualIID(&IID_IUnknown
, iid
) ||
1002 IsEqualIID(&IID_IWICBitmapEncoder
, iid
))
1009 return E_NOINTERFACE
;
1012 IUnknown_AddRef((IUnknown
*)*ppv
);
1016 static ULONG WINAPI
JpegEncoder_AddRef(IWICBitmapEncoder
*iface
)
1018 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1019 ULONG ref
= InterlockedIncrement(&This
->ref
);
1021 TRACE("(%p) refcount=%u\n", iface
, ref
);
1026 static ULONG WINAPI
JpegEncoder_Release(IWICBitmapEncoder
*iface
)
1028 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1029 ULONG ref
= InterlockedDecrement(&This
->ref
);
1031 TRACE("(%p) refcount=%u\n", iface
, ref
);
1035 This
->lock
.DebugInfo
->Spare
[0] = 0;
1036 DeleteCriticalSection(&This
->lock
);
1037 if (This
->initialized
) pjpeg_destroy_compress(&This
->cinfo
);
1038 if (This
->stream
) IStream_Release(This
->stream
);
1039 HeapFree(GetProcessHeap(), 0, This
);
1045 static HRESULT WINAPI
JpegEncoder_Initialize(IWICBitmapEncoder
*iface
,
1046 IStream
*pIStream
, WICBitmapEncoderCacheOption cacheOption
)
1048 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1051 TRACE("(%p,%p,%u)\n", iface
, pIStream
, cacheOption
);
1053 EnterCriticalSection(&This
->lock
);
1055 if (This
->initialized
)
1057 LeaveCriticalSection(&This
->lock
);
1058 return WINCODEC_ERR_WRONGSTATE
;
1061 pjpeg_std_error(&This
->jerr
);
1063 This
->jerr
.error_exit
= error_exit_fn
;
1064 This
->jerr
.emit_message
= emit_message_fn
;
1066 This
->cinfo
.err
= &This
->jerr
;
1068 This
->cinfo
.client_data
= &jmpbuf
;
1072 LeaveCriticalSection(&This
->lock
);
1076 pjpeg_CreateCompress(&This
->cinfo
, JPEG_LIB_VERSION
, sizeof(struct jpeg_compress_struct
));
1078 This
->stream
= pIStream
;
1079 IStream_AddRef(pIStream
);
1081 This
->dest_mgr
.next_output_byte
= This
->dest_buffer
;
1082 This
->dest_mgr
.free_in_buffer
= sizeof(This
->dest_buffer
);
1084 This
->dest_mgr
.init_destination
= dest_mgr_init_destination
;
1085 This
->dest_mgr
.empty_output_buffer
= dest_mgr_empty_output_buffer
;
1086 This
->dest_mgr
.term_destination
= dest_mgr_term_destination
;
1088 This
->cinfo
.dest
= &This
->dest_mgr
;
1090 This
->initialized
= TRUE
;
1092 LeaveCriticalSection(&This
->lock
);
1097 static HRESULT WINAPI
JpegEncoder_GetContainerFormat(IWICBitmapEncoder
*iface
,
1098 GUID
*pguidContainerFormat
)
1100 FIXME("(%p,%s): stub\n", iface
, debugstr_guid(pguidContainerFormat
));
1104 static HRESULT WINAPI
JpegEncoder_GetEncoderInfo(IWICBitmapEncoder
*iface
,
1105 IWICBitmapEncoderInfo
**ppIEncoderInfo
)
1107 FIXME("(%p,%p): stub\n", iface
, ppIEncoderInfo
);
1111 static HRESULT WINAPI
JpegEncoder_SetColorContexts(IWICBitmapEncoder
*iface
,
1112 UINT cCount
, IWICColorContext
**ppIColorContext
)
1114 FIXME("(%p,%u,%p): stub\n", iface
, cCount
, ppIColorContext
);
1118 static HRESULT WINAPI
JpegEncoder_SetPalette(IWICBitmapEncoder
*iface
, IWICPalette
*pIPalette
)
1120 TRACE("(%p,%p)\n", iface
, pIPalette
);
1121 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1124 static HRESULT WINAPI
JpegEncoder_SetThumbnail(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIThumbnail
)
1126 TRACE("(%p,%p)\n", iface
, pIThumbnail
);
1127 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1130 static HRESULT WINAPI
JpegEncoder_SetPreview(IWICBitmapEncoder
*iface
, IWICBitmapSource
*pIPreview
)
1132 TRACE("(%p,%p)\n", iface
, pIPreview
);
1133 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1136 static HRESULT WINAPI
JpegEncoder_CreateNewFrame(IWICBitmapEncoder
*iface
,
1137 IWICBitmapFrameEncode
**ppIFrameEncode
, IPropertyBag2
**ppIEncoderOptions
)
1139 JpegEncoder
*This
= impl_from_IWICBitmapEncoder(iface
);
1142 TRACE("(%p,%p,%p)\n", iface
, ppIFrameEncode
, ppIEncoderOptions
);
1144 EnterCriticalSection(&This
->lock
);
1146 if (This
->frame_count
!= 0)
1148 LeaveCriticalSection(&This
->lock
);
1149 return WINCODEC_ERR_UNSUPPORTEDOPERATION
;
1152 if (!This
->initialized
)
1154 LeaveCriticalSection(&This
->lock
);
1155 return WINCODEC_ERR_NOTINITIALIZED
;
1158 hr
= CreatePropertyBag2(ppIEncoderOptions
);
1161 LeaveCriticalSection(&This
->lock
);
1165 This
->frame_count
= 1;
1167 LeaveCriticalSection(&This
->lock
);
1169 IWICBitmapEncoder_AddRef(iface
);
1170 *ppIFrameEncode
= &This
->IWICBitmapFrameEncode_iface
;
1175 static HRESULT WINAPI
JpegEncoder_Commit(IWICBitmapEncoder
*iface
)
1177 FIXME("(%p): stub\n", iface
);
1181 static HRESULT WINAPI
JpegEncoder_GetMetadataQueryWriter(IWICBitmapEncoder
*iface
,
1182 IWICMetadataQueryWriter
**ppIMetadataQueryWriter
)
1184 FIXME("(%p,%p): stub\n", iface
, ppIMetadataQueryWriter
);
1188 static const IWICBitmapEncoderVtbl JpegEncoder_Vtbl
= {
1189 JpegEncoder_QueryInterface
,
1191 JpegEncoder_Release
,
1192 JpegEncoder_Initialize
,
1193 JpegEncoder_GetContainerFormat
,
1194 JpegEncoder_GetEncoderInfo
,
1195 JpegEncoder_SetColorContexts
,
1196 JpegEncoder_SetPalette
,
1197 JpegEncoder_SetThumbnail
,
1198 JpegEncoder_SetPreview
,
1199 JpegEncoder_CreateNewFrame
,
1201 JpegEncoder_GetMetadataQueryWriter
1204 HRESULT
JpegEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1209 TRACE("(%p,%s,%p)\n", pUnkOuter
, debugstr_guid(iid
), ppv
);
1213 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
1215 if (!libjpeg_handle
&& !load_libjpeg())
1217 ERR("Failed writing JPEG because unable to find %s\n",SONAME_LIBJPEG
);
1221 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(JpegEncoder
));
1222 if (!This
) return E_OUTOFMEMORY
;
1224 This
->IWICBitmapEncoder_iface
.lpVtbl
= &JpegEncoder_Vtbl
;
1225 This
->IWICBitmapFrameEncode_iface
.lpVtbl
= &JpegEncoder_FrameVtbl
;
1227 This
->initialized
= 0;
1228 This
->frame_count
= 0;
1229 This
->frame_initialized
= 0;
1230 This
->started_compress
= 0;
1231 This
->width
= This
->height
= 0;
1232 This
->xres
= This
->yres
= 0.0;
1233 This
->format
= NULL
;
1234 This
->stream
= NULL
;
1235 InitializeCriticalSection(&This
->lock
);
1236 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JpegEncoder.lock");
1238 ret
= IUnknown_QueryInterface((IUnknown
*)This
, iid
, ppv
);
1239 IUnknown_Release((IUnknown
*)This
);
1244 #else /* !defined(SONAME_LIBJPEG) */
1246 HRESULT
JpegDecoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1248 ERR("Trying to load JPEG picture, but JPEG support is not compiled in.\n");
1252 HRESULT
JpegEncoder_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
1254 ERR("Trying to save JPEG picture, but JPEG support is not compiled in.\n");