git.sesse.net Git - ffmpeg/blob - libavcodec/libopenjpegdec.c

   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_2_1_OPENJPEG_H
  40 #  include <openjpeg-2.1/openjpeg.h>
  41 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
  42 #  include <openjpeg-2.0/openjpeg.h>
  43 #elif HAVE_OPENJPEG_1_5_OPENJPEG_H
  44 #  include <openjpeg-1.5/openjpeg.h>
  45 #else
  46 #  include <openjpeg.h>
  47 #endif
  48
  49 #if HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H
  50 #  define OPENJPEG_MAJOR_VERSION 2
  51 #  define OPJ(x) OPJ_##x
  52 #else
  53 #  define OPENJPEG_MAJOR_VERSION 1
  54 #  define OPJ(x) x
  55 #endif
  56
  57 #define JP2_SIG_TYPE    0x6A502020
  58 #define JP2_SIG_VALUE   0x0D0A870A
  59
  60 // pix_fmts with lower bpp have to be listed before
  61 // similar pix_fmts with higher bpp.
  62 #define RGB_PIXEL_FORMATS  AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,                 \
  63                            AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64
  64
  65 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8,                  \
  66                            AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16
  67
  68 #define YUV_PIXEL_FORMATS  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \
  69                            AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
  70                            AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
  71                            AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
  72                            AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \
  73                            AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
  74                            AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \
  75                            AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \
  76                            AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
  77                            AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
  78                            AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16
  79
  80 #define XYZ_PIXEL_FORMATS  AV_PIX_FMT_XYZ12
  81
  82 static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]  = {
  83     RGB_PIXEL_FORMATS
  84 };
  85 static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = {
  86     GRAY_PIXEL_FORMATS
  87 };
  88 static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]  = {
  89     YUV_PIXEL_FORMATS
  90 };
  91 static const enum AVPixelFormat libopenjpeg_all_pix_fmts[]  = {
  92     RGB_PIXEL_FORMATS, GRAY_PIXEL_FORMATS, YUV_PIXEL_FORMATS, XYZ_PIXEL_FORMATS
  93 };
  94
  95 typedef struct LibOpenJPEGContext {
  96     AVClass *class;
  97     opj_dparameters_t dec_params;
  98 #if OPENJPEG_MAJOR_VERSION == 1
  99     opj_event_mgr_t event_mgr;
 100 #endif // OPENJPEG_MAJOR_VERSION == 1
 101     int lowqual;
 102 } LibOpenJPEGContext;
 103
 104 static void error_callback(const char *msg, void *data)
 105 {
 106     av_log(data, AV_LOG_ERROR, "%s", msg);
 107 }
 108
 109 static void warning_callback(const char *msg, void *data)
 110 {
 111     av_log(data, AV_LOG_WARNING, "%s", msg);
 112 }
 113
 114 static void info_callback(const char *msg, void *data)
 115 {
 116     av_log(data, AV_LOG_DEBUG, "%s", msg);
 117 }
 118
 119 #if OPENJPEG_MAJOR_VERSION == 2
 120 typedef struct BufferReader {
 121     int pos;
 122     int size;
 123     const uint8_t *buffer;
 124 } BufferReader;
 125
 126 static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)
 127 {
 128     BufferReader *reader = user_data;
 129     if (reader->pos == reader->size) {
 130         return (OPJ_SIZE_T)-1;
 131     }
 132     int remaining = reader->size - reader->pos;
 133     if (nb_bytes > remaining) {
 134         nb_bytes = remaining;
 135     }
 136     memcpy(out_buffer, reader->buffer + reader->pos, nb_bytes);
 137     reader->pos += (int)nb_bytes;
 138     return nb_bytes;
 139 }
 140
 141 static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)
 142 {
 143     BufferReader *reader = user_data;
 144     if (nb_bytes < 0) {
 145         if (reader->pos == 0) {
 146             return (OPJ_SIZE_T)-1;
 147         }
 148         if (nb_bytes + reader->pos < 0) {
 149             nb_bytes = -reader->pos;
 150         }
 151     } else {
 152         if (reader->pos == reader->size) {
 153             return (OPJ_SIZE_T)-1;
 154         }
 155         int remaining = reader->size - reader->pos;
 156         if (nb_bytes > remaining) {
 157             nb_bytes = remaining;
 158         }
 159     }
 160     reader->pos += (int)nb_bytes;
 161     return nb_bytes;
 162 }
 163
 164 static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)
 165 {
 166     BufferReader *reader = user_data;
 167     if (nb_bytes < 0 || nb_bytes > reader->size) {
 168         return OPJ_FALSE;
 169     }
 170     reader->pos = (int)nb_bytes;
 171     return OPJ_TRUE;
 172 }
 173 #endif // OPENJPEG_MAJOR_VERSION == 2
 174
 175 static inline int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
 176 {
 177     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 178     int match = 1;
 179
 180     if (desc->nb_components != image->numcomps) {
 181         return 0;
 182     }
 183
 184     switch (desc->nb_components) {
 185     case 4:
 186         match = match &&
 187                 desc->comp[3].depth >= image->comps[3].prec &&
 188                 1 == image->comps[3].dx &&
 189                 1 == image->comps[3].dy;
 190     case 3:
 191         match = match &&
 192                 desc->comp[2].depth >= image->comps[2].prec &&
 193                 1 << desc->log2_chroma_w == image->comps[2].dx &&
 194                 1 << desc->log2_chroma_h == image->comps[2].dy;
 195     case 2:
 196         match = match &&
 197                 desc->comp[1].depth >= image->comps[1].prec &&
 198                 1 << desc->log2_chroma_w == image->comps[1].dx &&
 199                 1 << desc->log2_chroma_h == image->comps[1].dy;
 200     case 1:
 201         match = match &&
 202                 desc->comp[0].depth >= image->comps[0].prec &&
 203                 1 == image->comps[0].dx &&
 204                 1 == image->comps[0].dy;
 205     default:
 206         break;
 207     }
 208
 209     return match;
 210 }
 211
 212 static inline enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image) {
 213     int index;
 214     const enum AVPixelFormat *possible_fmts = NULL;
 215     int possible_fmts_nb = 0;
 216
 217     switch (image->color_space) {
 218     case OPJ(CLRSPC_SRGB):
 219         possible_fmts    = libopenjpeg_rgb_pix_fmts;
 220         possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts);
 221         break;
 222     case OPJ(CLRSPC_GRAY):
 223         possible_fmts    = libopenjpeg_gray_pix_fmts;
 224         possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts);
 225         break;
 226     case OPJ(CLRSPC_SYCC):
 227         possible_fmts    = libopenjpeg_yuv_pix_fmts;
 228         possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts);
 229         break;
 230     default:
 231         possible_fmts    = libopenjpeg_all_pix_fmts;
 232         possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts);
 233         break;
 234     }
 235
 236     for (index = 0; index < possible_fmts_nb; ++index)
 237         if (libopenjpeg_matches_pix_fmt(image, possible_fmts[index])) {
 238             return possible_fmts[index];
 239         }
 240
 241     return AV_PIX_FMT_NONE;
 242 }
 243
 244 static inline int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)
 245 {
 246     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 247     int i, component_plane;
 248
 249     if (pix_fmt == AV_PIX_FMT_GRAY16)
 250         return 0;
 251
 252     component_plane = desc->comp[0].plane;
 253     for (i = 1; i < desc->nb_components; i++)
 254         if (component_plane != desc->comp[i].plane)
 255             return 0;
 256     return 1;
 257 }
 258
 259 static inline void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image) {
 260     uint8_t *img_ptr;
 261     int index, x, y, c;
 262     for (y = 0; y < picture->height; y++) {
 263         index   = y * picture->width;
 264         img_ptr = picture->data[0] + y * picture->linesize[0];
 265         for (x = 0; x < picture->width; x++, index++)
 266             for (c = 0; c < image->numcomps; c++)
 267                 *img_ptr++ = 0x80 * image->comps[c].sgnd + image->comps[c].data[index];
 268     }
 269 }
 270
 271 static inline void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image) {
 272     uint16_t *img_ptr;
 273     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(picture->format);
 274     int index, x, y, c;
 275     int adjust[4];
 276     for (x = 0; x < image->numcomps; x++)
 277         adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
 278
 279     for (y = 0; y < picture->height; y++) {
 280         index   = y * picture->width;
 281         img_ptr = (uint16_t *) (picture->data[0] + y * picture->linesize[0]);
 282         for (x = 0; x < picture->width; x++, index++)
 283             for (c = 0; c < image->numcomps; c++)
 284                 *img_ptr++ = (1 << image->comps[c].prec - 1) * image->comps[c].sgnd +
 285                              (unsigned)image->comps[c].data[index] << adjust[c];
 286     }
 287 }
 288
 289 static inline void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image) {
 290     int *comp_data;
 291     uint8_t *img_ptr;
 292     int index, x, y;
 293
 294     for (index = 0; index < image->numcomps; index++) {
 295         comp_data = image->comps[index].data;
 296         for (y = 0; y < image->comps[index].h; y++) {
 297             img_ptr = picture->data[index] + y * picture->linesize[index];
 298             for (x = 0; x < image->comps[index].w; x++) {
 299                 *img_ptr = 0x80 * image->comps[index].sgnd + *comp_data;
 300                 img_ptr++;
 301                 comp_data++;
 302             }
 303         }
 304     }
 305 }
 306
 307 static inline void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image) {
 308     int *comp_data;
 309     uint16_t *img_ptr;
 310     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(picture->format);
 311     int index, x, y;
 312     int adjust[4];
 313     for (x = 0; x < image->numcomps; x++)
 314         adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
 315
 316     for (index = 0; index < image->numcomps; index++) {
 317         comp_data = image->comps[index].data;
 318         for (y = 0; y < image->comps[index].h; y++) {
 319             img_ptr = (uint16_t *)(picture->data[index] + y * picture->linesize[index]);
 320             for (x = 0; x < image->comps[index].w; x++) {
 321                 *img_ptr = (1 << image->comps[index].prec - 1) * image->comps[index].sgnd +
 322                            (unsigned)*comp_data << adjust[index];
 323                 img_ptr++;
 324                 comp_data++;
 325             }
 326         }
 327     }
 328 }
 329
 330 static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)
 331 {
 332     LibOpenJPEGContext *ctx = avctx->priv_data;
 333
 334     opj_set_default_decoder_parameters(&ctx->dec_params);
 335     return 0;
 336 }
 337
 338 static int libopenjpeg_decode_frame(AVCodecContext *avctx,
 339                                     void *data, int *got_frame,
 340                                     AVPacket *avpkt)
 341 {
 342     uint8_t *buf            = avpkt->data;
 343     int buf_size            = avpkt->size;
 344     LibOpenJPEGContext *ctx = avctx->priv_data;
 345     ThreadFrame frame       = { .f = data };
 346     AVFrame *picture        = data;
 347     const AVPixFmtDescriptor *desc;
 348     int width, height, ret;
 349     int pixel_size = 0;
 350     int ispacked   = 0;
 351     int i;
 352     opj_image_t *image = NULL;
 353 #if OPENJPEG_MAJOR_VERSION == 1
 354     opj_dinfo_t *dec = NULL;
 355     opj_cio_t *stream = NULL;
 356 #else // OPENJPEG_MAJOR_VERSION == 2
 357     BufferReader reader = {0, avpkt->size, avpkt->data};
 358     opj_codec_t *dec = NULL;
 359     opj_stream_t *stream = NULL;
 360 #endif // OPENJPEG_MAJOR_VERSION == 1
 361
 362     *got_frame = 0;
 363
 364     // Check if input is a raw jpeg2k codestream or in jp2 wrapping
 365     if ((AV_RB32(buf) == 12) &&
 366         (AV_RB32(buf + 4) == JP2_SIG_TYPE) &&
 367         (AV_RB32(buf + 8) == JP2_SIG_VALUE)) {
 368         dec = opj_create_decompress(OPJ(CODEC_JP2));
 369     } else {
 370         /* If the AVPacket contains a jp2c box, then skip to
 371          * the starting byte of the codestream. */
 372         if (AV_RB32(buf + 4) == AV_RB32("jp2c"))
 373             buf += 8;
 374         dec = opj_create_decompress(OPJ(CODEC_J2K));
 375     }
 376
 377     if (!dec) {
 378         av_log(avctx, AV_LOG_ERROR, "Error initializing decoder.\n");
 379         ret = AVERROR_EXTERNAL;
 380         goto done;
 381     }
 382
 383 #if OPENJPEG_MAJOR_VERSION == 1
 384     memset(&ctx->event_mgr, 0, sizeof(ctx->event_mgr));
 385     ctx->event_mgr.info_handler    = info_callback;
 386     ctx->event_mgr.error_handler   = error_callback;
 387     ctx->event_mgr.warning_handler = warning_callback;
 388     opj_set_event_mgr((opj_common_ptr) dec, &ctx->event_mgr, avctx);
 389     ctx->dec_params.cp_limit_decoding = LIMIT_TO_MAIN_HEADER;
 390     ctx->dec_params.cp_layer          = ctx->lowqual;
 391 #else // OPENJPEG_MAJOR_VERSION == 2
 392     if (!opj_set_error_handler(dec, error_callback, avctx) ||
 393         !opj_set_warning_handler(dec, warning_callback, avctx) ||
 394         !opj_set_info_handler(dec, info_callback, avctx)) {
 395         av_log(avctx, AV_LOG_ERROR, "Error setting decoder handlers.\n");
 396         ret = AVERROR_EXTERNAL;
 397         goto done;
 398     }
 399
 400     ctx->dec_params.cp_layer = ctx->lowqual;
 401     ctx->dec_params.cp_reduce = avctx->lowres;
 402 #endif // OPENJPEG_MAJOR_VERSION == 1
 403
 404     // Tie decoder with decoding parameters
 405     opj_setup_decoder(dec, &ctx->dec_params);
 406
 407 #if OPENJPEG_MAJOR_VERSION == 1
 408     stream = opj_cio_open((opj_common_ptr) dec, buf, buf_size);
 409 #else // OPENJPEG_MAJOR_VERSION == 2
 410     stream = opj_stream_default_create(OPJ_STREAM_READ);
 411 #endif // OPENJPEG_MAJOR_VERSION == 1
 412
 413     if (!stream) {
 414         av_log(avctx, AV_LOG_ERROR,
 415                "Codestream could not be opened for reading.\n");
 416         ret = AVERROR_EXTERNAL;
 417         goto done;
 418     }
 419
 420 #if OPENJPEG_MAJOR_VERSION == 1
 421     // Decode the header only.
 422     image = opj_decode_with_info(dec, stream, NULL);
 423     opj_cio_close(stream);
 424     stream = NULL;
 425     ret = !image;
 426 #else // OPENJPEG_MAJOR_VERSION == 2
 427     opj_stream_set_read_function(stream, stream_read);
 428     opj_stream_set_skip_function(stream, stream_skip);
 429     opj_stream_set_seek_function(stream, stream_seek);
 430 #if HAVE_OPENJPEG_2_1_OPENJPEG_H
 431     opj_stream_set_user_data(stream, &reader, NULL);
 432 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
 433     opj_stream_set_user_data(stream, &reader);
 434 #else
 435 #error Missing call to opj_stream_set_user_data
 436 #endif
 437     opj_stream_set_user_data_length(stream, avpkt->size);
 438     // Decode the header only.
 439     ret = !opj_read_header(stream, dec, &image);
 440 #endif // OPENJPEG_MAJOR_VERSION == 1
 441
 442     if (ret) {
 443         av_log(avctx, AV_LOG_ERROR, "Error decoding codestream header.\n");
 444         ret = AVERROR_EXTERNAL;
 445         goto done;
 446     }
 447
 448     width  = image->x1 - image->x0;
 449     height = image->y1 - image->y0;
 450
 451     ret = ff_set_dimensions(avctx, width, height);
 452     if (ret < 0)
 453         goto done;
 454
 455     if (avctx->pix_fmt != AV_PIX_FMT_NONE)
 456         if (!libopenjpeg_matches_pix_fmt(image, avctx->pix_fmt))
 457             avctx->pix_fmt = AV_PIX_FMT_NONE;
 458
 459     if (avctx->pix_fmt == AV_PIX_FMT_NONE)
 460         avctx->pix_fmt = libopenjpeg_guess_pix_fmt(image);
 461
 462     if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
 463         av_log(avctx, AV_LOG_ERROR, "Unable to determine pixel format.\n");
 464         ret = AVERROR_UNKNOWN;
 465         goto done;
 466     }
 467     for (i = 0; i < image->numcomps; i++)
 468         if (image->comps[i].prec > avctx->bits_per_raw_sample)
 469             avctx->bits_per_raw_sample = image->comps[i].prec;
 470
 471     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
 472         goto done;
 473
 474 #if OPENJPEG_MAJOR_VERSION == 1
 475     ctx->dec_params.cp_limit_decoding = NO_LIMITATION;
 476     ctx->dec_params.cp_reduce = avctx->lowres;
 477     // Tie decoder with decoding parameters.
 478     opj_setup_decoder(dec, &ctx->dec_params);
 479     stream = opj_cio_open((opj_common_ptr) dec, buf, buf_size);
 480     if (!stream) {
 481         av_log(avctx, AV_LOG_ERROR,
 482                "Codestream could not be opened for reading.\n");
 483         ret = AVERROR_EXTERNAL;
 484         goto done;
 485     }
 486     opj_image_destroy(image);
 487     // Decode the codestream
 488     image = opj_decode_with_info(dec, stream, NULL);
 489     ret = !image;
 490 #else // OPENJPEG_MAJOR_VERSION == 2
 491     ret = !opj_decode(dec, stream, image);
 492 #endif // OPENJPEG_MAJOR_VERSION == 1
 493
 494     if (ret) {
 495         av_log(avctx, AV_LOG_ERROR, "Error decoding codestream.\n");
 496         ret = AVERROR_EXTERNAL;
 497         goto done;
 498     }
 499
 500     for (i = 0; i < image->numcomps; i++) {
 501         if (!image->comps[i].data) {
 502             av_log(avctx, AV_LOG_ERROR,
 503                    "Image component %d contains no data.\n", i);
 504             ret = AVERROR_INVALIDDATA;
 505             goto done;
 506         }
 507     }
 508
 509     desc       = av_pix_fmt_desc_get(avctx->pix_fmt);
 510     pixel_size = desc->comp[0].step;
 511     ispacked   = libopenjpeg_ispacked(avctx->pix_fmt);
 512
 513     switch (pixel_size) {
 514     case 1:
 515         if (ispacked) {
 516             libopenjpeg_copy_to_packed8(picture, image);
 517         } else {
 518             libopenjpeg_copyto8(picture, image);
 519         }
 520         break;
 521     case 2:
 522         if (ispacked) {
 523             libopenjpeg_copy_to_packed8(picture, image);
 524         } else {
 525             libopenjpeg_copyto16(picture, image);
 526         }
 527         break;
 528     case 3:
 529     case 4:
 530         if (ispacked) {
 531             libopenjpeg_copy_to_packed8(picture, image);
 532         }
 533         break;
 534     case 6:
 535     case 8:
 536         if (ispacked) {
 537             libopenjpeg_copy_to_packed16(picture, image);
 538         }
 539         break;
 540     default:
 541         av_log(avctx, AV_LOG_ERROR, "unsupported pixel size %d\n", pixel_size);
 542         ret = AVERROR_PATCHWELCOME;
 543         goto done;
 544     }
 545
 546     *got_frame = 1;
 547     ret        = buf_size;
 548
 549 done:
 550     opj_image_destroy(image);
 551 #if OPENJPEG_MAJOR_VERSION == 2
 552     opj_stream_destroy(stream);
 553     opj_destroy_codec(dec);
 554 #else
 555     opj_cio_close(stream);
 556     opj_destroy_decompress(dec);
 557 #endif
 558     return ret;
 559 }
 560
 561 static av_cold void libopenjpeg_static_init(AVCodec *codec)
 562 {
 563     const char *version = opj_version();
 564     int major, minor;
 565
 566     if (sscanf(version, "%d.%d", &major, &minor) == 2 && 1000*major + minor <= 1003)
 567         codec->capabilities |= AV_CODEC_CAP_EXPERIMENTAL;
 568 }
 569
 570 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
 571 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
 572
 573 static const AVOption options[] = {
 574     { "lowqual", "Limit the number of layers used for decoding",
 575         OFFSET(lowqual), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
 576     { NULL },
 577 };
 578
 579 static const AVClass openjpeg_class = {
 580     .class_name = "libopenjpeg",
 581     .item_name  = av_default_item_name,
 582     .option     = options,
 583     .version    = LIBAVUTIL_VERSION_INT,
 584 };
 585
 586 AVCodec ff_libopenjpeg_decoder = {
 587     .name           = "libopenjpeg",
 588     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
 589     .type           = AVMEDIA_TYPE_VIDEO,
 590     .id             = AV_CODEC_ID_JPEG2000,
 591     .priv_data_size = sizeof(LibOpenJPEGContext),
 592     .init           = libopenjpeg_decode_init,
 593     .decode         = libopenjpeg_decode_frame,
 594     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
 595     .max_lowres     = 31,
 596     .priv_class     = &openjpeg_class,
 597     .init_static_data = libopenjpeg_static_init,
 598 };