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

   1 /*
   2  * JPEG 2000 encoding support via OpenJPEG
   3  * Copyright (c) 2011 Michael Bradshaw <mjbshaw gmail com>
   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 encoder using libopenjpeg
  25  */
  26
  27 #define  OPJ_STATIC
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/common.h"
  31 #include "libavutil/imgutils.h"
  32 #include "libavutil/intreadwrite.h"
  33 #include "libavutil/opt.h"
  34 #include "avcodec.h"
  35 #include "internal.h"
  36
  37 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
  38 # include <openjpeg-1.5/openjpeg.h>
  39 #else
  40 # include <openjpeg.h>
  41 #endif
  42
  43 typedef struct LibOpenJPEGContext {
  44     AVClass *avclass;
  45     opj_image_t *image;
  46     opj_cparameters_t enc_params;
  47     opj_event_mgr_t event_mgr;
  48     int format;
  49     int profile;
  50     int prog_order;
  51     int cinema_mode;
  52     int numresolution;
  53     int numlayers;
  54     int disto_alloc;
  55     int fixed_alloc;
  56     int fixed_quality;
  57 } LibOpenJPEGContext;
  58
  59 static void error_callback(const char *msg, void *data)
  60 {
  61     av_log(data, AV_LOG_ERROR, "%s\n", msg);
  62 }
  63
  64 static void warning_callback(const char *msg, void *data)
  65 {
  66     av_log(data, AV_LOG_WARNING, "%s\n", msg);
  67 }
  68
  69 static void info_callback(const char *msg, void *data)
  70 {
  71     av_log(data, AV_LOG_DEBUG, "%s\n", msg);
  72 }
  73
  74 static void cinema_parameters(opj_cparameters_t *p)
  75 {
  76     p->tile_size_on = 0;
  77     p->cp_tdx = 1;
  78     p->cp_tdy = 1;
  79
  80     /* Tile part */
  81     p->tp_flag = 'C';
  82     p->tp_on = 1;
  83
  84     /* Tile and Image shall be at (0, 0) */
  85     p->cp_tx0 = 0;
  86     p->cp_ty0 = 0;
  87     p->image_offset_x0 = 0;
  88     p->image_offset_y0 = 0;
  89
  90     /* Codeblock size= 32 * 32 */
  91     p->cblockw_init = 32;
  92     p->cblockh_init = 32;
  93     p->csty |= 0x01;
  94
  95     /* The progression order shall be CPRL */
  96     p->prog_order = CPRL;
  97
  98     /* No ROI */
  99     p->roi_compno = -1;
 100
 101     /* No subsampling */
 102     p->subsampling_dx = 1;
 103     p->subsampling_dy = 1;
 104
 105     /* 9-7 transform */
 106     p->irreversible = 1;
 107
 108     p->tcp_mct = 1;
 109 }
 110
 111 static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)
 112 {
 113     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 114     opj_image_cmptparm_t cmptparm[4] = {{0}};
 115     opj_image_t *img;
 116     int i;
 117     int sub_dx[4];
 118     int sub_dy[4];
 119     int numcomps;
 120     OPJ_COLOR_SPACE color_space = CLRSPC_UNKNOWN;
 121
 122     sub_dx[0] = sub_dx[3] = 1;
 123     sub_dy[0] = sub_dy[3] = 1;
 124     sub_dx[1] = sub_dx[2] = 1 << desc->log2_chroma_w;
 125     sub_dy[1] = sub_dy[2] = 1 << desc->log2_chroma_h;
 126
 127     numcomps = desc->nb_components;
 128
 129     switch (avctx->pix_fmt) {
 130     case AV_PIX_FMT_GRAY8:
 131     case AV_PIX_FMT_YA8:
 132     case AV_PIX_FMT_GRAY16:
 133     case AV_PIX_FMT_YA16:
 134         color_space = CLRSPC_GRAY;
 135         break;
 136     case AV_PIX_FMT_RGB24:
 137     case AV_PIX_FMT_RGBA:
 138     case AV_PIX_FMT_RGB48:
 139     case AV_PIX_FMT_RGBA64:
 140     case AV_PIX_FMT_GBR24P:
 141     case AV_PIX_FMT_GBRP9:
 142     case AV_PIX_FMT_GBRP10:
 143     case AV_PIX_FMT_GBRP12:
 144     case AV_PIX_FMT_GBRP14:
 145     case AV_PIX_FMT_GBRP16:
 146     case AV_PIX_FMT_XYZ12:
 147         color_space = CLRSPC_SRGB;
 148         break;
 149     case AV_PIX_FMT_YUV410P:
 150     case AV_PIX_FMT_YUV411P:
 151     case AV_PIX_FMT_YUV420P:
 152     case AV_PIX_FMT_YUV422P:
 153     case AV_PIX_FMT_YUV440P:
 154     case AV_PIX_FMT_YUV444P:
 155     case AV_PIX_FMT_YUVA420P:
 156     case AV_PIX_FMT_YUVA422P:
 157     case AV_PIX_FMT_YUVA444P:
 158     case AV_PIX_FMT_YUV420P9:
 159     case AV_PIX_FMT_YUV422P9:
 160     case AV_PIX_FMT_YUV444P9:
 161     case AV_PIX_FMT_YUVA420P9:
 162     case AV_PIX_FMT_YUVA422P9:
 163     case AV_PIX_FMT_YUVA444P9:
 164     case AV_PIX_FMT_YUV420P10:
 165     case AV_PIX_FMT_YUV422P10:
 166     case AV_PIX_FMT_YUV444P10:
 167     case AV_PIX_FMT_YUVA420P10:
 168     case AV_PIX_FMT_YUVA422P10:
 169     case AV_PIX_FMT_YUVA444P10:
 170     case AV_PIX_FMT_YUV420P12:
 171     case AV_PIX_FMT_YUV422P12:
 172     case AV_PIX_FMT_YUV444P12:
 173     case AV_PIX_FMT_YUV420P14:
 174     case AV_PIX_FMT_YUV422P14:
 175     case AV_PIX_FMT_YUV444P14:
 176     case AV_PIX_FMT_YUV420P16:
 177     case AV_PIX_FMT_YUV422P16:
 178     case AV_PIX_FMT_YUV444P16:
 179     case AV_PIX_FMT_YUVA420P16:
 180     case AV_PIX_FMT_YUVA422P16:
 181     case AV_PIX_FMT_YUVA444P16:
 182         color_space = CLRSPC_SYCC;
 183         break;
 184     default:
 185         av_log(avctx, AV_LOG_ERROR,
 186                "The requested pixel format '%s' is not supported\n",
 187                av_get_pix_fmt_name(avctx->pix_fmt));
 188         return NULL;
 189     }
 190
 191     for (i = 0; i < numcomps; i++) {
 192         cmptparm[i].prec = desc->comp[i].depth_minus1 + 1;
 193         cmptparm[i].bpp  = desc->comp[i].depth_minus1 + 1;
 194         cmptparm[i].sgnd = 0;
 195         cmptparm[i].dx = sub_dx[i];
 196         cmptparm[i].dy = sub_dy[i];
 197         cmptparm[i].w = (avctx->width + sub_dx[i] - 1) / sub_dx[i];
 198         cmptparm[i].h = (avctx->height + sub_dy[i] - 1) / sub_dy[i];
 199     }
 200
 201     img = opj_image_create(numcomps, cmptparm, color_space);
 202
 203     // x0, y0 is the top left corner of the image
 204     // x1, y1 is the width, height of the reference grid
 205     img->x0 = 0;
 206     img->y0 = 0;
 207     img->x1 = (avctx->width  - 1) * parameters->subsampling_dx + 1;
 208     img->y1 = (avctx->height - 1) * parameters->subsampling_dy + 1;
 209
 210     return img;
 211 }
 212
 213 static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
 214 {
 215     LibOpenJPEGContext *ctx = avctx->priv_data;
 216     int err = AVERROR(ENOMEM);
 217
 218     opj_set_default_encoder_parameters(&ctx->enc_params);
 219
 220     ctx->enc_params.cp_rsiz = ctx->profile;
 221     ctx->enc_params.mode = !!avctx->global_quality;
 222     ctx->enc_params.cp_cinema = ctx->cinema_mode;
 223     ctx->enc_params.prog_order = ctx->prog_order;
 224     ctx->enc_params.numresolution = ctx->numresolution;
 225     ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;
 226     ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;
 227     ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;
 228     ctx->enc_params.tcp_numlayers = ctx->numlayers;
 229     ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;
 230
 231     if (ctx->cinema_mode > 0) {
 232         cinema_parameters(&ctx->enc_params);
 233     }
 234
 235     ctx->image = mj2_create_image(avctx, &ctx->enc_params);
 236     if (!ctx->image) {
 237         av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");
 238         err = AVERROR(EINVAL);
 239         goto fail;
 240     }
 241
 242     avctx->coded_frame = av_frame_alloc();
 243     if (!avctx->coded_frame) {
 244         av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
 245         goto fail;
 246     }
 247
 248     return 0;
 249
 250 fail:
 251     opj_image_destroy(ctx->image);
 252     ctx->image = NULL;
 253     av_frame_free(&avctx->coded_frame);
 254     return err;
 255 }
 256
 257 static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 258 {
 259     int compno;
 260     int x;
 261     int y;
 262     int *image_line;
 263     int frame_index;
 264     const int numcomps = image->numcomps;
 265
 266     for (compno = 0; compno < numcomps; ++compno) {
 267         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 268             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 269             return 0;
 270         }
 271     }
 272
 273     for (compno = 0; compno < numcomps; ++compno) {
 274         for (y = 0; y < avctx->height; ++y) {
 275             image_line = image->comps[compno].data + y * image->comps[compno].w;
 276             frame_index = y * frame->linesize[0] + compno;
 277             for (x = 0; x < avctx->width; ++x) {
 278                 image_line[x] = frame->data[0][frame_index];
 279                 frame_index += numcomps;
 280             }
 281             for (; x < image->comps[compno].w; ++x) {
 282                 image_line[x] = image_line[x - 1];
 283             }
 284         }
 285         for (; y < image->comps[compno].h; ++y) {
 286             image_line = image->comps[compno].data + y * image->comps[compno].w;
 287             for (x = 0; x < image->comps[compno].w; ++x) {
 288                 image_line[x] = image_line[x - image->comps[compno].w];
 289             }
 290         }
 291     }
 292
 293     return 1;
 294 }
 295
 296 // for XYZ 12 bit
 297 static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 298 {
 299     int compno;
 300     int x, y;
 301     int *image_line;
 302     int frame_index;
 303     const int numcomps  = image->numcomps;
 304     uint16_t *frame_ptr = (uint16_t *)frame->data[0];
 305
 306     for (compno = 0; compno < numcomps; ++compno) {
 307         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 308             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 309             return 0;
 310         }
 311     }
 312
 313     for (compno = 0; compno < numcomps; ++compno) {
 314         for (y = 0; y < avctx->height; ++y) {
 315             image_line = image->comps[compno].data + y * image->comps[compno].w;
 316             frame_index = y * (frame->linesize[0] / 2) + compno;
 317             for (x = 0; x < avctx->width; ++x) {
 318                 image_line[x] = frame_ptr[frame_index] >> 4;
 319                 frame_index += numcomps;
 320             }
 321             for (; x < image->comps[compno].w; ++x) {
 322                 image_line[x] = image_line[x - 1];
 323             }
 324         }
 325         for (; y < image->comps[compno].h; ++y) {
 326             image_line = image->comps[compno].data + y * image->comps[compno].w;
 327             for (x = 0; x < image->comps[compno].w; ++x) {
 328                 image_line[x] = image_line[x - image->comps[compno].w];
 329             }
 330         }
 331     }
 332
 333     return 1;
 334 }
 335
 336 static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 337 {
 338     int compno;
 339     int x;
 340     int y;
 341     int *image_line;
 342     int frame_index;
 343     const int numcomps = image->numcomps;
 344     uint16_t *frame_ptr = (uint16_t*)frame->data[0];
 345
 346     for (compno = 0; compno < numcomps; ++compno) {
 347         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 348             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 349             return 0;
 350         }
 351     }
 352
 353     for (compno = 0; compno < numcomps; ++compno) {
 354         for (y = 0; y < avctx->height; ++y) {
 355             image_line = image->comps[compno].data + y * image->comps[compno].w;
 356             frame_index = y * (frame->linesize[0] / 2) + compno;
 357             for (x = 0; x < avctx->width; ++x) {
 358                 image_line[x] = frame_ptr[frame_index];
 359                 frame_index += numcomps;
 360             }
 361             for (; x < image->comps[compno].w; ++x) {
 362                 image_line[x] = image_line[x - 1];
 363             }
 364         }
 365         for (; y < image->comps[compno].h; ++y) {
 366             image_line = image->comps[compno].data + y * image->comps[compno].w;
 367             for (x = 0; x < image->comps[compno].w; ++x) {
 368                 image_line[x] = image_line[x - image->comps[compno].w];
 369             }
 370         }
 371     }
 372
 373     return 1;
 374 }
 375
 376 static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 377 {
 378     int compno;
 379     int x;
 380     int y;
 381     int width;
 382     int height;
 383     int *image_line;
 384     int frame_index;
 385     const int numcomps = image->numcomps;
 386
 387     for (compno = 0; compno < numcomps; ++compno) {
 388         if (image->comps[compno].w > frame->linesize[compno]) {
 389             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 390             return 0;
 391         }
 392     }
 393
 394     for (compno = 0; compno < numcomps; ++compno) {
 395         width  = avctx->width / image->comps[compno].dx;
 396         height = avctx->height / image->comps[compno].dy;
 397         for (y = 0; y < height; ++y) {
 398             image_line = image->comps[compno].data + y * image->comps[compno].w;
 399             frame_index = y * frame->linesize[compno];
 400             for (x = 0; x < width; ++x)
 401                 image_line[x] = frame->data[compno][frame_index++];
 402             for (; x < image->comps[compno].w; ++x) {
 403                 image_line[x] = image_line[x - 1];
 404             }
 405         }
 406         for (; y < image->comps[compno].h; ++y) {
 407             image_line = image->comps[compno].data + y * image->comps[compno].w;
 408             for (x = 0; x < image->comps[compno].w; ++x) {
 409                 image_line[x] = image_line[x - image->comps[compno].w];
 410             }
 411         }
 412     }
 413
 414     return 1;
 415 }
 416
 417 static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 418 {
 419     int compno;
 420     int x;
 421     int y;
 422     int width;
 423     int height;
 424     int *image_line;
 425     int frame_index;
 426     const int numcomps = image->numcomps;
 427     uint16_t *frame_ptr;
 428
 429     for (compno = 0; compno < numcomps; ++compno) {
 430         if (image->comps[compno].w > frame->linesize[compno]) {
 431             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 432             return 0;
 433         }
 434     }
 435
 436     for (compno = 0; compno < numcomps; ++compno) {
 437         width     = avctx->width / image->comps[compno].dx;
 438         height    = avctx->height / image->comps[compno].dy;
 439         frame_ptr = (uint16_t *)frame->data[compno];
 440         for (y = 0; y < height; ++y) {
 441             image_line = image->comps[compno].data + y * image->comps[compno].w;
 442             frame_index = y * (frame->linesize[compno] / 2);
 443             for (x = 0; x < width; ++x)
 444                 image_line[x] = frame_ptr[frame_index++];
 445             for (; x < image->comps[compno].w; ++x) {
 446                 image_line[x] = image_line[x - 1];
 447             }
 448         }
 449         for (; y < image->comps[compno].h; ++y) {
 450             image_line = image->comps[compno].data + y * image->comps[compno].w;
 451             for (x = 0; x < image->comps[compno].w; ++x) {
 452                 image_line[x] = image_line[x - image->comps[compno].w];
 453             }
 454         }
 455     }
 456
 457     return 1;
 458 }
 459
 460 static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 461                                     const AVFrame *frame, int *got_packet)
 462 {
 463     LibOpenJPEGContext *ctx = avctx->priv_data;
 464     opj_image_t *image      = ctx->image;
 465     opj_cinfo_t *compress   = NULL;
 466     opj_cio_t *stream       = NULL;
 467     int cpyresult = 0;
 468     int ret, len;
 469     AVFrame *gbrframe;
 470
 471     switch (avctx->pix_fmt) {
 472     case AV_PIX_FMT_RGB24:
 473     case AV_PIX_FMT_RGBA:
 474     case AV_PIX_FMT_YA8:
 475         cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);
 476         break;
 477     case AV_PIX_FMT_XYZ12:
 478         cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);
 479         break;
 480     case AV_PIX_FMT_RGB48:
 481     case AV_PIX_FMT_RGBA64:
 482     case AV_PIX_FMT_YA16:
 483         cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);
 484         break;
 485     case AV_PIX_FMT_GBR24P:
 486     case AV_PIX_FMT_GBRP9:
 487     case AV_PIX_FMT_GBRP10:
 488     case AV_PIX_FMT_GBRP12:
 489     case AV_PIX_FMT_GBRP14:
 490     case AV_PIX_FMT_GBRP16:
 491         gbrframe = av_frame_clone(frame);
 492         if (!gbrframe)
 493             return AVERROR(ENOMEM);
 494         gbrframe->data[0] = frame->data[2]; // swap to be rgb
 495         gbrframe->data[1] = frame->data[0];
 496         gbrframe->data[2] = frame->data[1];
 497         gbrframe->linesize[0] = frame->linesize[2];
 498         gbrframe->linesize[1] = frame->linesize[0];
 499         gbrframe->linesize[2] = frame->linesize[1];
 500         if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {
 501             cpyresult = libopenjpeg_copy_unpacked8(avctx, gbrframe, image);
 502         } else {
 503             cpyresult = libopenjpeg_copy_unpacked16(avctx, gbrframe, image);
 504         }
 505         av_frame_free(&gbrframe);
 506         break;
 507     case AV_PIX_FMT_GRAY8:
 508     case AV_PIX_FMT_YUV410P:
 509     case AV_PIX_FMT_YUV411P:
 510     case AV_PIX_FMT_YUV420P:
 511     case AV_PIX_FMT_YUV422P:
 512     case AV_PIX_FMT_YUV440P:
 513     case AV_PIX_FMT_YUV444P:
 514     case AV_PIX_FMT_YUVA420P:
 515     case AV_PIX_FMT_YUVA422P:
 516     case AV_PIX_FMT_YUVA444P:
 517         cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);
 518         break;
 519     case AV_PIX_FMT_GRAY16:
 520     case AV_PIX_FMT_YUV420P9:
 521     case AV_PIX_FMT_YUV422P9:
 522     case AV_PIX_FMT_YUV444P9:
 523     case AV_PIX_FMT_YUVA420P9:
 524     case AV_PIX_FMT_YUVA422P9:
 525     case AV_PIX_FMT_YUVA444P9:
 526     case AV_PIX_FMT_YUV444P10:
 527     case AV_PIX_FMT_YUV422P10:
 528     case AV_PIX_FMT_YUV420P10:
 529     case AV_PIX_FMT_YUVA444P10:
 530     case AV_PIX_FMT_YUVA422P10:
 531     case AV_PIX_FMT_YUVA420P10:
 532     case AV_PIX_FMT_YUV420P12:
 533     case AV_PIX_FMT_YUV422P12:
 534     case AV_PIX_FMT_YUV444P12:
 535     case AV_PIX_FMT_YUV420P14:
 536     case AV_PIX_FMT_YUV422P14:
 537     case AV_PIX_FMT_YUV444P14:
 538     case AV_PIX_FMT_YUV444P16:
 539     case AV_PIX_FMT_YUV422P16:
 540     case AV_PIX_FMT_YUV420P16:
 541     case AV_PIX_FMT_YUVA444P16:
 542     case AV_PIX_FMT_YUVA422P16:
 543     case AV_PIX_FMT_YUVA420P16:
 544         cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);
 545         break;
 546     default:
 547         av_log(avctx, AV_LOG_ERROR,
 548                "The frame's pixel format '%s' is not supported\n",
 549                av_get_pix_fmt_name(avctx->pix_fmt));
 550         return AVERROR(EINVAL);
 551         break;
 552     }
 553
 554     if (!cpyresult) {
 555         av_log(avctx, AV_LOG_ERROR,
 556                "Could not copy the frame data to the internal image buffer\n");
 557         return -1;
 558     }
 559
 560     compress = opj_create_compress(ctx->format);
 561     if (!compress) {
 562         av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");
 563         return AVERROR(ENOMEM);
 564     }
 565
 566     opj_setup_encoder(compress, &ctx->enc_params, image);
 567
 568     stream = opj_cio_open((opj_common_ptr) compress, NULL, 0);
 569     if (!stream) {
 570         av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");
 571         return AVERROR(ENOMEM);
 572     }
 573
 574     memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));
 575     ctx->event_mgr.info_handler    = info_callback;
 576     ctx->event_mgr.error_handler   = error_callback;
 577     ctx->event_mgr.warning_handler = warning_callback;
 578     opj_set_event_mgr((opj_common_ptr) compress, &ctx->event_mgr, avctx);
 579
 580     if (!opj_encode(compress, stream, image, NULL)) {
 581         av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");
 582         return -1;
 583     }
 584
 585     len = cio_tell(stream);
 586     if ((ret = ff_alloc_packet2(avctx, pkt, len)) < 0) {
 587         return ret;
 588     }
 589
 590     memcpy(pkt->data, stream->buffer, len);
 591     pkt->flags |= AV_PKT_FLAG_KEY;
 592     *got_packet = 1;
 593
 594     opj_cio_close(stream);
 595     stream = NULL;
 596     opj_destroy_compress(compress);
 597     compress = NULL;
 598
 599     return 0;
 600 }
 601
 602 static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
 603 {
 604     LibOpenJPEGContext *ctx = avctx->priv_data;
 605
 606     opj_image_destroy(ctx->image);
 607     ctx->image = NULL;
 608     av_frame_free(&avctx->coded_frame);
 609     return 0;
 610 }
 611
 612 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
 613 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 614 static const AVOption options[] = {
 615     { "format",        "Codec Format",      OFFSET(format),        AV_OPT_TYPE_INT,   { .i64 = CODEC_JP2   }, CODEC_J2K, CODEC_JP2,   VE, "format"      },
 616     { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K   }, 0,         0,           VE, "format"      },
 617     { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2   }, 0,         0,           VE, "format"      },
 618     { "profile",       NULL,                OFFSET(profile),       AV_OPT_TYPE_INT,   { .i64 = STD_RSIZ    }, STD_RSIZ,  CINEMA4K,    VE, "profile"     },
 619     { "jpeg2000",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = STD_RSIZ    }, 0,         0,           VE, "profile"     },
 620     { "cinema2k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K    }, 0,         0,           VE, "profile"     },
 621     { "cinema4k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K    }, 0,         0,           VE, "profile"     },
 622     { "cinema_mode",   "Digital Cinema",    OFFSET(cinema_mode),   AV_OPT_TYPE_INT,   { .i64 = OFF         }, OFF,       CINEMA4K_24, VE, "cinema_mode" },
 623     { "off",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OFF         }, 0,         0,           VE, "cinema_mode" },
 624     { "2k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_24 }, 0,         0,           VE, "cinema_mode" },
 625     { "2k_48",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_48 }, 0,         0,           VE, "cinema_mode" },
 626     { "4k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K_24 }, 0,         0,           VE, "cinema_mode" },
 627     { "prog_order",    "Progression Order", OFFSET(prog_order),    AV_OPT_TYPE_INT,   { .i64 = LRCP        }, LRCP,      CPRL,        VE, "prog_order"  },
 628     { "lrcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = LRCP        }, 0,         0,           VE, "prog_order"  },
 629     { "rlcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RLCP        }, 0,         0,           VE, "prog_order"  },
 630     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RPCL        }, 0,         0,           VE, "prog_order"  },
 631     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = PCRL        }, 0,         0,           VE, "prog_order"  },
 632     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CPRL        }, 0,         0,           VE, "prog_order"  },
 633     { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { .i64 = 6           }, 1,         INT_MAX,     VE                },
 634     { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { .i64 = 1           }, 1,         10,          VE                },
 635     { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { .i64 = 1           }, 0,         1,           VE                },
 636     { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
 637     { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
 638     { NULL },
 639 };
 640
 641 static const AVClass openjpeg_class = {
 642     .class_name = "libopenjpeg",
 643     .item_name  = av_default_item_name,
 644     .option     = options,
 645     .version    = LIBAVUTIL_VERSION_INT,
 646 };
 647
 648 AVCodec ff_libopenjpeg_encoder = {
 649     .name           = "libopenjpeg",
 650     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
 651     .type           = AVMEDIA_TYPE_VIDEO,
 652     .id             = AV_CODEC_ID_JPEG2000,
 653     .priv_data_size = sizeof(LibOpenJPEGContext),
 654     .init           = libopenjpeg_encode_init,
 655     .encode2        = libopenjpeg_encode_frame,
 656     .close          = libopenjpeg_encode_close,
 657     .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 658     .pix_fmts       = (const enum AVPixelFormat[]) {
 659         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,
 660         AV_PIX_FMT_RGBA64, AV_PIX_FMT_GBR24P,
 661         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
 662         AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16,
 663         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,
 664         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,
 665         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,
 666         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
 667         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
 668         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 669         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
 670         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
 671         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
 672         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
 673         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
 674         AV_PIX_FMT_XYZ12,
 675         AV_PIX_FMT_NONE
 676     },
 677     .priv_class     = &openjpeg_class,
 678 };