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_GRAY8A,               \
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
70static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]  = {
71    RGB_PIXEL_FORMATS
72};
73static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = {
74    GRAY_PIXEL_FORMATS
75};
76static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]  = {
77    YUV_PIXEL_FORMATS
78};
79static const enum AVPixelFormat libopenjpeg_all_pix_fmts[]  = {
80    RGB_PIXEL_FORMATS, GRAY_PIXEL_FORMATS, YUV_PIXEL_FORMATS, XYZ_PIXEL_FORMATS
81};
82
83typedef struct {
84    AVClass *class;
85    opj_dparameters_t dec_params;
86    int lowqual;
87} LibOpenJPEGContext;
88
89static 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
126static 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
158static 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
173static 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
185static 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
202static 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
220static 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
242static 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
250static 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
399done:
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
408static 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
414static 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
421AVCodec 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};
433