2 * JPEG 2000 decoding support via OpenJPEG
3 * Copyright (c) 2009 Jaikrishnan Menon <realityman@gmx.net>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * JPEG 2000 decoder using libopenjpeg
29 #include "libavutil/common.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixfmt.h"
39 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
40 # include <openjpeg-1.5/openjpeg.h>
42 # include <openjpeg.h>
45 #define JP2_SIG_TYPE 0x6A502020
46 #define JP2_SIG_VALUE 0x0D0A870A
48 // pix_fmts with lower bpp have to be listed before
49 // similar pix_fmts with higher bpp.
50 #define RGB_PIXEL_FORMATS AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, \
51 AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64
53 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, \
56 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \
57 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
58 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
59 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
60 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \
61 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
62 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \
63 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \
64 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
65 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
66 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16
68 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
70 static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts
[] = {
73 static const enum AVPixelFormat libopenjpeg_gray_pix_fmts
[] = {
76 static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts
[] = {
79 static const enum AVPixelFormat libopenjpeg_all_pix_fmts
[] = {
80 RGB_PIXEL_FORMATS
, GRAY_PIXEL_FORMATS
, YUV_PIXEL_FORMATS
, XYZ_PIXEL_FORMATS
85 opj_dparameters_t dec_params
;
89 static inline int libopenjpeg_matches_pix_fmt(const opj_image_t
*image
, enum AVPixelFormat pix_fmt
)
91 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(pix_fmt
);
94 if (desc
->nb_components
!= image
->numcomps
) {
98 switch (desc
->nb_components
) {
101 desc
->comp
[3].depth_minus1
+ 1 >= image
->comps
[3].prec
&&
102 1 == image
->comps
[3].dx
&&
103 1 == image
->comps
[3].dy
;
106 desc
->comp
[2].depth_minus1
+ 1 >= image
->comps
[2].prec
&&
107 1 << desc
->log2_chroma_w
== image
->comps
[2].dx
&&
108 1 << desc
->log2_chroma_h
== image
->comps
[2].dy
;
111 desc
->comp
[1].depth_minus1
+ 1 >= image
->comps
[1].prec
&&
112 1 << desc
->log2_chroma_w
== image
->comps
[1].dx
&&
113 1 << desc
->log2_chroma_h
== image
->comps
[1].dy
;
116 desc
->comp
[0].depth_minus1
+ 1 >= image
->comps
[0].prec
&&
117 1 == image
->comps
[0].dx
&&
118 1 == image
->comps
[0].dy
;
126 static inline enum AVPixelFormat
libopenjpeg_guess_pix_fmt(const opj_image_t
*image
) {
128 const enum AVPixelFormat
*possible_fmts
= NULL
;
129 int possible_fmts_nb
= 0;
131 switch (image
->color_space
) {
133 possible_fmts
= libopenjpeg_rgb_pix_fmts
;
134 possible_fmts_nb
= FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts
);
137 possible_fmts
= libopenjpeg_gray_pix_fmts
;
138 possible_fmts_nb
= FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts
);
141 possible_fmts
= libopenjpeg_yuv_pix_fmts
;
142 possible_fmts_nb
= FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts
);
145 possible_fmts
= libopenjpeg_all_pix_fmts
;
146 possible_fmts_nb
= FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts
);
150 for (index
= 0; index
< possible_fmts_nb
; ++index
)
151 if (libopenjpeg_matches_pix_fmt(image
, possible_fmts
[index
])) {
152 return possible_fmts
[index
];
155 return AV_PIX_FMT_NONE
;
158 static inline int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt
)
160 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(pix_fmt
);
161 int i
, component_plane
;
163 if (pix_fmt
== AV_PIX_FMT_GRAY16
)
166 component_plane
= desc
->comp
[0].plane
;
167 for (i
= 1; i
< desc
->nb_components
; i
++)
168 if (component_plane
!= desc
->comp
[i
].plane
)
173 static inline void libopenjpeg_copy_to_packed8(AVFrame
*picture
, opj_image_t
*image
) {
176 for (y
= 0; y
< picture
->height
; y
++) {
177 index
= y
* picture
->width
;
178 img_ptr
= picture
->data
[0] + y
* picture
->linesize
[0];
179 for (x
= 0; x
< picture
->width
; x
++, index
++)
180 for (c
= 0; c
< image
->numcomps
; c
++)
181 *img_ptr
++ = 0x80 * image
->comps
[c
].sgnd
+ image
->comps
[c
].data
[index
];
185 static inline void libopenjpeg_copy_to_packed16(AVFrame
*picture
, opj_image_t
*image
) {
189 for (x
= 0; x
< image
->numcomps
; x
++)
190 adjust
[x
] = FFMAX(FFMIN(av_pix_fmt_desc_get(picture
->format
)->comp
[x
].depth_minus1
+ 1 - image
->comps
[x
].prec
, 8), 0);
192 for (y
= 0; y
< picture
->height
; y
++) {
193 index
= y
* picture
->width
;
194 img_ptr
= (uint16_t *) (picture
->data
[0] + y
* picture
->linesize
[0]);
195 for (x
= 0; x
< picture
->width
; x
++, index
++)
196 for (c
= 0; c
< image
->numcomps
; c
++)
197 *img_ptr
++ = (1 << image
->comps
[c
].prec
- 1) * image
->comps
[c
].sgnd
+
198 (unsigned)image
->comps
[c
].data
[index
] << adjust
[c
];
202 static inline void libopenjpeg_copyto8(AVFrame
*picture
, opj_image_t
*image
) {
207 for (index
= 0; index
< image
->numcomps
; index
++) {
208 comp_data
= image
->comps
[index
].data
;
209 for (y
= 0; y
< image
->comps
[index
].h
; y
++) {
210 img_ptr
= picture
->data
[index
] + y
* picture
->linesize
[index
];
211 for (x
= 0; x
< image
->comps
[index
].w
; x
++) {
212 *img_ptr
= 0x80 * image
->comps
[index
].sgnd
+ *comp_data
;
220 static inline void libopenjpeg_copyto16(AVFrame
*picture
, opj_image_t
*image
) {
225 for (x
= 0; x
< image
->numcomps
; x
++)
226 adjust
[x
] = FFMAX(FFMIN(av_pix_fmt_desc_get(picture
->format
)->comp
[x
].depth_minus1
+ 1 - image
->comps
[x
].prec
, 8), 0);
228 for (index
= 0; index
< image
->numcomps
; index
++) {
229 comp_data
= image
->comps
[index
].data
;
230 for (y
= 0; y
< image
->comps
[index
].h
; y
++) {
231 img_ptr
= (uint16_t *)(picture
->data
[index
] + y
* picture
->linesize
[index
]);
232 for (x
= 0; x
< image
->comps
[index
].w
; x
++) {
233 *img_ptr
= (1 << image
->comps
[index
].prec
- 1) * image
->comps
[index
].sgnd
+
234 (unsigned)*comp_data
<< adjust
[index
];
242 static av_cold
int libopenjpeg_decode_init(AVCodecContext
*avctx
)
244 LibOpenJPEGContext
*ctx
= avctx
->priv_data
;
246 opj_set_default_decoder_parameters(&ctx
->dec_params
);
250 static int libopenjpeg_decode_frame(AVCodecContext
*avctx
,
251 void *data
, int *got_frame
,
254 uint8_t *buf
= avpkt
->data
;
255 int buf_size
= avpkt
->size
;
256 LibOpenJPEGContext
*ctx
= avctx
->priv_data
;
257 ThreadFrame frame
= { .f
= data
};
258 AVFrame
*picture
= data
;
259 const AVPixFmtDescriptor
*desc
;
263 int width
, height
, ret
;
270 // Check if input is a raw jpeg2k codestream or in jp2 wrapping
271 if ((AV_RB32(buf
) == 12) &&
272 (AV_RB32(buf
+ 4) == JP2_SIG_TYPE
) &&
273 (AV_RB32(buf
+ 8) == JP2_SIG_VALUE
)) {
274 dec
= opj_create_decompress(CODEC_JP2
);
276 /* If the AVPacket contains a jp2c box, then skip to
277 * the starting byte of the codestream. */
278 if (AV_RB32(buf
+ 4) == AV_RB32("jp2c"))
280 dec
= opj_create_decompress(CODEC_J2K
);
284 av_log(avctx
, AV_LOG_ERROR
, "Error initializing decoder.\n");
285 return AVERROR_UNKNOWN
;
287 opj_set_event_mgr((opj_common_ptr
) dec
, NULL
, NULL
);
288 ctx
->dec_params
.cp_limit_decoding
= LIMIT_TO_MAIN_HEADER
;
289 ctx
->dec_params
.cp_layer
= ctx
->lowqual
;
290 // Tie decoder with decoding parameters
291 opj_setup_decoder(dec
, &ctx
->dec_params
);
292 stream
= opj_cio_open((opj_common_ptr
) dec
, buf
, buf_size
);
295 av_log(avctx
, AV_LOG_ERROR
,
296 "Codestream could not be opened for reading.\n");
297 opj_destroy_decompress(dec
);
298 return AVERROR_UNKNOWN
;
301 // Decode the header only.
302 image
= opj_decode_with_info(dec
, stream
, NULL
);
303 opj_cio_close(stream
);
306 av_log(avctx
, AV_LOG_ERROR
, "Error decoding codestream.\n");
307 opj_destroy_decompress(dec
);
308 return AVERROR_UNKNOWN
;
311 width
= image
->x1
- image
->x0
;
312 height
= image
->y1
- image
->y0
;
314 ret
= ff_set_dimensions(avctx
, width
, height
);
318 if (avctx
->pix_fmt
!= AV_PIX_FMT_NONE
)
319 if (!libopenjpeg_matches_pix_fmt(image
, avctx
->pix_fmt
))
320 avctx
->pix_fmt
= AV_PIX_FMT_NONE
;
322 if (avctx
->pix_fmt
== AV_PIX_FMT_NONE
)
323 avctx
->pix_fmt
= libopenjpeg_guess_pix_fmt(image
);
325 if (avctx
->pix_fmt
== AV_PIX_FMT_NONE
) {
326 av_log(avctx
, AV_LOG_ERROR
, "Unable to determine pixel format\n");
329 for (i
= 0; i
< image
->numcomps
; i
++)
330 if (image
->comps
[i
].prec
> avctx
->bits_per_raw_sample
)
331 avctx
->bits_per_raw_sample
= image
->comps
[i
].prec
;
333 if ((ret
= ff_thread_get_buffer(avctx
, &frame
, 0)) < 0)
336 ctx
->dec_params
.cp_limit_decoding
= NO_LIMITATION
;
337 ctx
->dec_params
.cp_reduce
= avctx
->lowres
;
338 // Tie decoder with decoding parameters.
339 opj_setup_decoder(dec
, &ctx
->dec_params
);
340 stream
= opj_cio_open((opj_common_ptr
) dec
, buf
, buf_size
);
342 av_log(avctx
, AV_LOG_ERROR
,
343 "Codestream could not be opened for reading.\n");
344 ret
= AVERROR_UNKNOWN
;
348 opj_image_destroy(image
);
349 // Decode the codestream
350 image
= opj_decode_with_info(dec
, stream
, NULL
);
351 opj_cio_close(stream
);
354 av_log(avctx
, AV_LOG_ERROR
, "Error decoding codestream.\n");
355 ret
= AVERROR_UNKNOWN
;
359 desc
= av_pix_fmt_desc_get(avctx
->pix_fmt
);
360 pixel_size
= desc
->comp
[0].step_minus1
+ 1;
361 ispacked
= libopenjpeg_ispacked(avctx
->pix_fmt
);
363 switch (pixel_size
) {
366 libopenjpeg_copy_to_packed8(picture
, image
);
368 libopenjpeg_copyto8(picture
, image
);
373 libopenjpeg_copy_to_packed8(picture
, image
);
375 libopenjpeg_copyto16(picture
, image
);
381 libopenjpeg_copy_to_packed8(picture
, image
);
387 libopenjpeg_copy_to_packed16(picture
, image
);
391 av_log(avctx
, AV_LOG_ERROR
, "unsupported pixel size %d\n", pixel_size
);
392 ret
= AVERROR_PATCHWELCOME
;
400 opj_image_destroy(image
);
401 opj_destroy_decompress(dec
);
405 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
406 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
408 static const AVOption options
[] = {
409 { "lowqual", "Limit the number of layers used for decoding",
410 OFFSET(lowqual
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, INT_MAX
, VD
},
414 static const AVClass openjpeg_class
= {
415 .class_name
= "libopenjpeg",
416 .item_name
= av_default_item_name
,
418 .version
= LIBAVUTIL_VERSION_INT
,
421 AVCodec ff_libopenjpeg_decoder
= {
422 .name
= "libopenjpeg",
423 .long_name
= NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
424 .type
= AVMEDIA_TYPE_VIDEO
,
425 .id
= AV_CODEC_ID_JPEG2000
,
426 .priv_data_size
= sizeof(LibOpenJPEGContext
),
427 .init
= libopenjpeg_decode_init
,
428 .decode
= libopenjpeg_decode_frame
,
429 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,
431 .priv_class
= &openjpeg_class
,