Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * JPEG 2000 decoding support via OpenJPEG | |
3 | * Copyright (c) 2009 Jaikrishnan Menon <realityman@gmx.net> | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
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. | |
11 | * | |
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. | |
16 | * | |
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 | |
20 | */ | |
21 | ||
22 | /** | |
23 | * @file | |
24 | * JPEG 2000 decoder using libopenjpeg | |
25 | */ | |
26 | ||
27 | #define OPJ_STATIC | |
28 | ||
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" | |
34 | ||
35 | #include "avcodec.h" | |
36 | #include "internal.h" | |
37 | #include "thread.h" | |
38 | ||
39 | #if HAVE_OPENJPEG_1_5_OPENJPEG_H | |
40 | # include <openjpeg-1.5/openjpeg.h> | |
41 | #else | |
42 | # include <openjpeg.h> | |
43 | #endif | |
44 | ||
45 | #define JP2_SIG_TYPE 0x6A502020 | |
46 | #define JP2_SIG_VALUE 0x0D0A870A | |
47 | ||
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 | |
52 | ||
53 | #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, \ | |
54 | AV_PIX_FMT_GRAY16 | |
55 | ||
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 | |
67 | ||
68 | #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12 | |
69 | ||
70 | static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[] = { | |
71 | RGB_PIXEL_FORMATS | |
72 | }; | |
73 | static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = { | |
74 | GRAY_PIXEL_FORMATS | |
75 | }; | |
76 | static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[] = { | |
77 | YUV_PIXEL_FORMATS | |
78 | }; | |
79 | static const enum AVPixelFormat libopenjpeg_all_pix_fmts[] = { | |
80 | RGB_PIXEL_FORMATS, GRAY_PIXEL_FORMATS, YUV_PIXEL_FORMATS, XYZ_PIXEL_FORMATS | |
81 | }; | |
82 | ||
83 | typedef struct { | |
84 | AVClass *class; | |
85 | opj_dparameters_t dec_params; | |
86 | int lowqual; | |
87 | } LibOpenJPEGContext; | |
88 | ||
89 | static inline int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt) | |
90 | { | |
91 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); | |
92 | int match = 1; | |
93 | ||
94 | if (desc->nb_components != image->numcomps) { | |
95 | return 0; | |
96 | } | |
97 | ||
98 | switch (desc->nb_components) { | |
99 | case 4: | |
100 | match = match && | |
101 | desc->comp[3].depth_minus1 + 1 >= image->comps[3].prec && | |
102 | 1 == image->comps[3].dx && | |
103 | 1 == image->comps[3].dy; | |
104 | case 3: | |
105 | match = match && | |
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; | |
109 | case 2: | |
110 | match = match && | |
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; | |
114 | case 1: | |
115 | match = match && | |
116 | desc->comp[0].depth_minus1 + 1 >= image->comps[0].prec && | |
117 | 1 == image->comps[0].dx && | |
118 | 1 == image->comps[0].dy; | |
119 | default: | |
120 | break; | |
121 | } | |
122 | ||
123 | return match; | |
124 | } | |
125 | ||
126 | static inline enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image) { | |
127 | int index; | |
128 | const enum AVPixelFormat *possible_fmts = NULL; | |
129 | int possible_fmts_nb = 0; | |
130 | ||
131 | switch (image->color_space) { | |
132 | case CLRSPC_SRGB: | |
133 | possible_fmts = libopenjpeg_rgb_pix_fmts; | |
134 | possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts); | |
135 | break; | |
136 | case CLRSPC_GRAY: | |
137 | possible_fmts = libopenjpeg_gray_pix_fmts; | |
138 | possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts); | |
139 | break; | |
140 | case CLRSPC_SYCC: | |
141 | possible_fmts = libopenjpeg_yuv_pix_fmts; | |
142 | possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts); | |
143 | break; | |
144 | default: | |
145 | possible_fmts = libopenjpeg_all_pix_fmts; | |
146 | possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts); | |
147 | break; | |
148 | } | |
149 | ||
150 | for (index = 0; index < possible_fmts_nb; ++index) | |
151 | if (libopenjpeg_matches_pix_fmt(image, possible_fmts[index])) { | |
152 | return possible_fmts[index]; | |
153 | } | |
154 | ||
155 | return AV_PIX_FMT_NONE; | |
156 | } | |
157 | ||
158 | static inline int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt) | |
159 | { | |
160 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); | |
161 | int i, component_plane; | |
162 | ||
163 | if (pix_fmt == AV_PIX_FMT_GRAY16) | |
164 | return 0; | |
165 | ||
166 | component_plane = desc->comp[0].plane; | |
167 | for (i = 1; i < desc->nb_components; i++) | |
168 | if (component_plane != desc->comp[i].plane) | |
169 | return 0; | |
170 | return 1; | |
171 | } | |
172 | ||
173 | static inline void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image) { | |
174 | uint8_t *img_ptr; | |
175 | int index, x, y, c; | |
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]; | |
182 | } | |
183 | } | |
184 | ||
185 | static inline void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image) { | |
186 | uint16_t *img_ptr; | |
187 | int index, x, y, c; | |
188 | int adjust[4]; | |
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); | |
191 | ||
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]; | |
199 | } | |
200 | } | |
201 | ||
202 | static inline void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image) { | |
203 | int *comp_data; | |
204 | uint8_t *img_ptr; | |
205 | int index, x, y; | |
206 | ||
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; | |
213 | img_ptr++; | |
214 | comp_data++; | |
215 | } | |
216 | } | |
217 | } | |
218 | } | |
219 | ||
220 | static inline void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image) { | |
221 | int *comp_data; | |
222 | uint16_t *img_ptr; | |
223 | int index, x, y; | |
224 | int adjust[4]; | |
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); | |
227 | ||
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]; | |
235 | img_ptr++; | |
236 | comp_data++; | |
237 | } | |
238 | } | |
239 | } | |
240 | } | |
241 | ||
242 | static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx) | |
243 | { | |
244 | LibOpenJPEGContext *ctx = avctx->priv_data; | |
245 | ||
246 | opj_set_default_decoder_parameters(&ctx->dec_params); | |
247 | return 0; | |
248 | } | |
249 | ||
250 | static int libopenjpeg_decode_frame(AVCodecContext *avctx, | |
251 | void *data, int *got_frame, | |
252 | AVPacket *avpkt) | |
253 | { | |
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; | |
260 | opj_dinfo_t *dec; | |
261 | opj_cio_t *stream; | |
262 | opj_image_t *image; | |
263 | int width, height, ret; | |
264 | int pixel_size = 0; | |
265 | int ispacked = 0; | |
266 | int i; | |
267 | ||
268 | *got_frame = 0; | |
269 | ||
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); | |
275 | } else { | |
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")) | |
279 | buf += 8; | |
280 | dec = opj_create_decompress(CODEC_J2K); | |
281 | } | |
282 | ||
283 | if (!dec) { | |
284 | av_log(avctx, AV_LOG_ERROR, "Error initializing decoder.\n"); | |
285 | return AVERROR_UNKNOWN; | |
286 | } | |
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); | |
293 | ||
294 | if (!stream) { | |
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; | |
299 | } | |
300 | ||
301 | // Decode the header only. | |
302 | image = opj_decode_with_info(dec, stream, NULL); | |
303 | opj_cio_close(stream); | |
304 | ||
305 | if (!image) { | |
306 | av_log(avctx, AV_LOG_ERROR, "Error decoding codestream.\n"); | |
307 | opj_destroy_decompress(dec); | |
308 | return AVERROR_UNKNOWN; | |
309 | } | |
310 | ||
311 | width = image->x1 - image->x0; | |
312 | height = image->y1 - image->y0; | |
313 | ||
314 | ret = ff_set_dimensions(avctx, width, height); | |
315 | if (ret < 0) | |
316 | goto done; | |
317 | ||
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; | |
321 | ||
322 | if (avctx->pix_fmt == AV_PIX_FMT_NONE) | |
323 | avctx->pix_fmt = libopenjpeg_guess_pix_fmt(image); | |
324 | ||
325 | if (avctx->pix_fmt == AV_PIX_FMT_NONE) { | |
326 | av_log(avctx, AV_LOG_ERROR, "Unable to determine pixel format\n"); | |
327 | goto done; | |
328 | } | |
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; | |
332 | ||
333 | if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) | |
334 | goto done; | |
335 | ||
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); | |
341 | if (!stream) { | |
342 | av_log(avctx, AV_LOG_ERROR, | |
343 | "Codestream could not be opened for reading.\n"); | |
344 | ret = AVERROR_UNKNOWN; | |
345 | goto done; | |
346 | } | |
347 | ||
348 | opj_image_destroy(image); | |
349 | // Decode the codestream | |
350 | image = opj_decode_with_info(dec, stream, NULL); | |
351 | opj_cio_close(stream); | |
352 | ||
353 | if (!image) { | |
354 | av_log(avctx, AV_LOG_ERROR, "Error decoding codestream.\n"); | |
355 | ret = AVERROR_UNKNOWN; | |
356 | goto done; | |
357 | } | |
358 | ||
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); | |
362 | ||
363 | switch (pixel_size) { | |
364 | case 1: | |
365 | if (ispacked) { | |
366 | libopenjpeg_copy_to_packed8(picture, image); | |
367 | } else { | |
368 | libopenjpeg_copyto8(picture, image); | |
369 | } | |
370 | break; | |
371 | case 2: | |
372 | if (ispacked) { | |
373 | libopenjpeg_copy_to_packed8(picture, image); | |
374 | } else { | |
375 | libopenjpeg_copyto16(picture, image); | |
376 | } | |
377 | break; | |
378 | case 3: | |
379 | case 4: | |
380 | if (ispacked) { | |
381 | libopenjpeg_copy_to_packed8(picture, image); | |
382 | } | |
383 | break; | |
384 | case 6: | |
385 | case 8: | |
386 | if (ispacked) { | |
387 | libopenjpeg_copy_to_packed16(picture, image); | |
388 | } | |
389 | break; | |
390 | default: | |
391 | av_log(avctx, AV_LOG_ERROR, "unsupported pixel size %d\n", pixel_size); | |
392 | ret = AVERROR_PATCHWELCOME; | |
393 | goto done; | |
394 | } | |
395 | ||
396 | *got_frame = 1; | |
397 | ret = buf_size; | |
398 | ||
399 | done: | |
400 | opj_image_destroy(image); | |
401 | opj_destroy_decompress(dec); | |
402 | return ret; | |
403 | } | |
404 | ||
405 | #define OFFSET(x) offsetof(LibOpenJPEGContext, x) | |
406 | #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | |
407 | ||
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 }, | |
411 | { NULL }, | |
412 | }; | |
413 | ||
414 | static const AVClass openjpeg_class = { | |
415 | .class_name = "libopenjpeg", | |
416 | .item_name = av_default_item_name, | |
417 | .option = options, | |
418 | .version = LIBAVUTIL_VERSION_INT, | |
419 | }; | |
420 | ||
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, | |
430 | .max_lowres = 31, | |
431 | .priv_class = &openjpeg_class, | |
432 | }; |