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