Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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.     if (!img)
  204.         return NULL;
  205.  
  206.     // x0, y0 is the top left corner of the image
  207.     // x1, y1 is the width, height of the reference grid
  208.     img->x0 = 0;
  209.     img->y0 = 0;
  210.     img->x1 = (avctx->width  - 1) * parameters->subsampling_dx + 1;
  211.     img->y1 = (avctx->height - 1) * parameters->subsampling_dy + 1;
  212.  
  213.     return img;
  214. }
  215.  
  216. static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
  217. {
  218.     LibOpenJPEGContext *ctx = avctx->priv_data;
  219.     int err = AVERROR(ENOMEM);
  220.  
  221.     opj_set_default_encoder_parameters(&ctx->enc_params);
  222.  
  223.     ctx->enc_params.cp_rsiz = ctx->profile;
  224.     ctx->enc_params.mode = !!avctx->global_quality;
  225.     ctx->enc_params.cp_cinema = ctx->cinema_mode;
  226.     ctx->enc_params.prog_order = ctx->prog_order;
  227.     ctx->enc_params.numresolution = ctx->numresolution;
  228.     ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;
  229.     ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;
  230.     ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;
  231.     ctx->enc_params.tcp_numlayers = ctx->numlayers;
  232.     ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;
  233.  
  234.     if (ctx->cinema_mode > 0) {
  235.         cinema_parameters(&ctx->enc_params);
  236.     }
  237.  
  238.     ctx->image = mj2_create_image(avctx, &ctx->enc_params);
  239.     if (!ctx->image) {
  240.         av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");
  241.         err = AVERROR(EINVAL);
  242.         goto fail;
  243.     }
  244.  
  245.     return 0;
  246.  
  247. fail:
  248.     opj_image_destroy(ctx->image);
  249.     ctx->image = NULL;
  250.     return err;
  251. }
  252.  
  253. static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  254. {
  255.     int compno;
  256.     int x;
  257.     int y;
  258.     int *image_line;
  259.     int frame_index;
  260.     const int numcomps = image->numcomps;
  261.  
  262.     for (compno = 0; compno < numcomps; ++compno) {
  263.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
  264.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
  265.             return 0;
  266.         }
  267.     }
  268.  
  269.     for (compno = 0; compno < numcomps; ++compno) {
  270.         for (y = 0; y < avctx->height; ++y) {
  271.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  272.             frame_index = y * frame->linesize[0] + compno;
  273.             for (x = 0; x < avctx->width; ++x) {
  274.                 image_line[x] = frame->data[0][frame_index];
  275.                 frame_index += numcomps;
  276.             }
  277.             for (; x < image->comps[compno].w; ++x) {
  278.                 image_line[x] = image_line[x - 1];
  279.             }
  280.         }
  281.         for (; y < image->comps[compno].h; ++y) {
  282.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  283.             for (x = 0; x < image->comps[compno].w; ++x) {
  284.                 image_line[x] = image_line[x - image->comps[compno].w];
  285.             }
  286.         }
  287.     }
  288.  
  289.     return 1;
  290. }
  291.  
  292. // for XYZ 12 bit
  293. static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  294. {
  295.     int compno;
  296.     int x, y;
  297.     int *image_line;
  298.     int frame_index;
  299.     const int numcomps  = image->numcomps;
  300.     uint16_t *frame_ptr = (uint16_t *)frame->data[0];
  301.  
  302.     for (compno = 0; compno < numcomps; ++compno) {
  303.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
  304.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
  305.             return 0;
  306.         }
  307.     }
  308.  
  309.     for (compno = 0; compno < numcomps; ++compno) {
  310.         for (y = 0; y < avctx->height; ++y) {
  311.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  312.             frame_index = y * (frame->linesize[0] / 2) + compno;
  313.             for (x = 0; x < avctx->width; ++x) {
  314.                 image_line[x] = frame_ptr[frame_index] >> 4;
  315.                 frame_index += numcomps;
  316.             }
  317.             for (; x < image->comps[compno].w; ++x) {
  318.                 image_line[x] = image_line[x - 1];
  319.             }
  320.         }
  321.         for (; y < image->comps[compno].h; ++y) {
  322.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  323.             for (x = 0; x < image->comps[compno].w; ++x) {
  324.                 image_line[x] = image_line[x - image->comps[compno].w];
  325.             }
  326.         }
  327.     }
  328.  
  329.     return 1;
  330. }
  331.  
  332. static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  333. {
  334.     int compno;
  335.     int x;
  336.     int y;
  337.     int *image_line;
  338.     int frame_index;
  339.     const int numcomps = image->numcomps;
  340.     uint16_t *frame_ptr = (uint16_t*)frame->data[0];
  341.  
  342.     for (compno = 0; compno < numcomps; ++compno) {
  343.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {
  344.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
  345.             return 0;
  346.         }
  347.     }
  348.  
  349.     for (compno = 0; compno < numcomps; ++compno) {
  350.         for (y = 0; y < avctx->height; ++y) {
  351.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  352.             frame_index = y * (frame->linesize[0] / 2) + compno;
  353.             for (x = 0; x < avctx->width; ++x) {
  354.                 image_line[x] = frame_ptr[frame_index];
  355.                 frame_index += numcomps;
  356.             }
  357.             for (; x < image->comps[compno].w; ++x) {
  358.                 image_line[x] = image_line[x - 1];
  359.             }
  360.         }
  361.         for (; y < image->comps[compno].h; ++y) {
  362.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  363.             for (x = 0; x < image->comps[compno].w; ++x) {
  364.                 image_line[x] = image_line[x - image->comps[compno].w];
  365.             }
  366.         }
  367.     }
  368.  
  369.     return 1;
  370. }
  371.  
  372. static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  373. {
  374.     int compno;
  375.     int x;
  376.     int y;
  377.     int width;
  378.     int height;
  379.     int *image_line;
  380.     int frame_index;
  381.     const int numcomps = image->numcomps;
  382.  
  383.     for (compno = 0; compno < numcomps; ++compno) {
  384.         if (image->comps[compno].w > frame->linesize[compno]) {
  385.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
  386.             return 0;
  387.         }
  388.     }
  389.  
  390.     for (compno = 0; compno < numcomps; ++compno) {
  391.         width  = avctx->width / image->comps[compno].dx;
  392.         height = avctx->height / image->comps[compno].dy;
  393.         for (y = 0; y < height; ++y) {
  394.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  395.             frame_index = y * frame->linesize[compno];
  396.             for (x = 0; x < width; ++x)
  397.                 image_line[x] = frame->data[compno][frame_index++];
  398.             for (; x < image->comps[compno].w; ++x) {
  399.                 image_line[x] = image_line[x - 1];
  400.             }
  401.         }
  402.         for (; y < image->comps[compno].h; ++y) {
  403.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  404.             for (x = 0; x < image->comps[compno].w; ++x) {
  405.                 image_line[x] = image_line[x - image->comps[compno].w];
  406.             }
  407.         }
  408.     }
  409.  
  410.     return 1;
  411. }
  412.  
  413. static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  414. {
  415.     int compno;
  416.     int x;
  417.     int y;
  418.     int width;
  419.     int height;
  420.     int *image_line;
  421.     int frame_index;
  422.     const int numcomps = image->numcomps;
  423.     uint16_t *frame_ptr;
  424.  
  425.     for (compno = 0; compno < numcomps; ++compno) {
  426.         if (image->comps[compno].w > frame->linesize[compno]) {
  427.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
  428.             return 0;
  429.         }
  430.     }
  431.  
  432.     for (compno = 0; compno < numcomps; ++compno) {
  433.         width     = avctx->width / image->comps[compno].dx;
  434.         height    = avctx->height / image->comps[compno].dy;
  435.         frame_ptr = (uint16_t *)frame->data[compno];
  436.         for (y = 0; y < height; ++y) {
  437.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  438.             frame_index = y * (frame->linesize[compno] / 2);
  439.             for (x = 0; x < width; ++x)
  440.                 image_line[x] = frame_ptr[frame_index++];
  441.             for (; x < image->comps[compno].w; ++x) {
  442.                 image_line[x] = image_line[x - 1];
  443.             }
  444.         }
  445.         for (; y < image->comps[compno].h; ++y) {
  446.             image_line = image->comps[compno].data + y * image->comps[compno].w;
  447.             for (x = 0; x < image->comps[compno].w; ++x) {
  448.                 image_line[x] = image_line[x - image->comps[compno].w];
  449.             }
  450.         }
  451.     }
  452.  
  453.     return 1;
  454. }
  455.  
  456. static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
  457.                                     const AVFrame *frame, int *got_packet)
  458. {
  459.     LibOpenJPEGContext *ctx = avctx->priv_data;
  460.     opj_image_t *image      = ctx->image;
  461.     opj_cinfo_t *compress   = NULL;
  462.     opj_cio_t *stream       = NULL;
  463.     int cpyresult = 0;
  464.     int ret, len;
  465.     AVFrame *gbrframe;
  466.  
  467.     switch (avctx->pix_fmt) {
  468.     case AV_PIX_FMT_RGB24:
  469.     case AV_PIX_FMT_RGBA:
  470.     case AV_PIX_FMT_YA8:
  471.         cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);
  472.         break;
  473.     case AV_PIX_FMT_XYZ12:
  474.         cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);
  475.         break;
  476.     case AV_PIX_FMT_RGB48:
  477.     case AV_PIX_FMT_RGBA64:
  478.     case AV_PIX_FMT_YA16:
  479.         cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);
  480.         break;
  481.     case AV_PIX_FMT_GBR24P:
  482.     case AV_PIX_FMT_GBRP9:
  483.     case AV_PIX_FMT_GBRP10:
  484.     case AV_PIX_FMT_GBRP12:
  485.     case AV_PIX_FMT_GBRP14:
  486.     case AV_PIX_FMT_GBRP16:
  487.         gbrframe = av_frame_clone(frame);
  488.         if (!gbrframe)
  489.             return AVERROR(ENOMEM);
  490.         gbrframe->data[0] = frame->data[2]; // swap to be rgb
  491.         gbrframe->data[1] = frame->data[0];
  492.         gbrframe->data[2] = frame->data[1];
  493.         gbrframe->linesize[0] = frame->linesize[2];
  494.         gbrframe->linesize[1] = frame->linesize[0];
  495.         gbrframe->linesize[2] = frame->linesize[1];
  496.         if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {
  497.             cpyresult = libopenjpeg_copy_unpacked8(avctx, gbrframe, image);
  498.         } else {
  499.             cpyresult = libopenjpeg_copy_unpacked16(avctx, gbrframe, image);
  500.         }
  501.         av_frame_free(&gbrframe);
  502.         break;
  503.     case AV_PIX_FMT_GRAY8:
  504.     case AV_PIX_FMT_YUV410P:
  505.     case AV_PIX_FMT_YUV411P:
  506.     case AV_PIX_FMT_YUV420P:
  507.     case AV_PIX_FMT_YUV422P:
  508.     case AV_PIX_FMT_YUV440P:
  509.     case AV_PIX_FMT_YUV444P:
  510.     case AV_PIX_FMT_YUVA420P:
  511.     case AV_PIX_FMT_YUVA422P:
  512.     case AV_PIX_FMT_YUVA444P:
  513.         cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);
  514.         break;
  515.     case AV_PIX_FMT_GRAY16:
  516.     case AV_PIX_FMT_YUV420P9:
  517.     case AV_PIX_FMT_YUV422P9:
  518.     case AV_PIX_FMT_YUV444P9:
  519.     case AV_PIX_FMT_YUVA420P9:
  520.     case AV_PIX_FMT_YUVA422P9:
  521.     case AV_PIX_FMT_YUVA444P9:
  522.     case AV_PIX_FMT_YUV444P10:
  523.     case AV_PIX_FMT_YUV422P10:
  524.     case AV_PIX_FMT_YUV420P10:
  525.     case AV_PIX_FMT_YUVA444P10:
  526.     case AV_PIX_FMT_YUVA422P10:
  527.     case AV_PIX_FMT_YUVA420P10:
  528.     case AV_PIX_FMT_YUV420P12:
  529.     case AV_PIX_FMT_YUV422P12:
  530.     case AV_PIX_FMT_YUV444P12:
  531.     case AV_PIX_FMT_YUV420P14:
  532.     case AV_PIX_FMT_YUV422P14:
  533.     case AV_PIX_FMT_YUV444P14:
  534.     case AV_PIX_FMT_YUV444P16:
  535.     case AV_PIX_FMT_YUV422P16:
  536.     case AV_PIX_FMT_YUV420P16:
  537.     case AV_PIX_FMT_YUVA444P16:
  538.     case AV_PIX_FMT_YUVA422P16:
  539.     case AV_PIX_FMT_YUVA420P16:
  540.         cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);
  541.         break;
  542.     default:
  543.         av_log(avctx, AV_LOG_ERROR,
  544.                "The frame's pixel format '%s' is not supported\n",
  545.                av_get_pix_fmt_name(avctx->pix_fmt));
  546.         return AVERROR(EINVAL);
  547.         break;
  548.     }
  549.  
  550.     if (!cpyresult) {
  551.         av_log(avctx, AV_LOG_ERROR,
  552.                "Could not copy the frame data to the internal image buffer\n");
  553.         return -1;
  554.     }
  555.  
  556.     compress = opj_create_compress(ctx->format);
  557.     if (!compress) {
  558.         av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");
  559.         return AVERROR(ENOMEM);
  560.     }
  561.  
  562.     opj_setup_encoder(compress, &ctx->enc_params, image);
  563.  
  564.     stream = opj_cio_open((opj_common_ptr) compress, NULL, 0);
  565.     if (!stream) {
  566.         av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");
  567.         return AVERROR(ENOMEM);
  568.     }
  569.  
  570.     memset(&ctx->event_mgr, 0, sizeof(ctx->event_mgr));
  571.     ctx->event_mgr.info_handler    = info_callback;
  572.     ctx->event_mgr.error_handler   = error_callback;
  573.     ctx->event_mgr.warning_handler = warning_callback;
  574.     opj_set_event_mgr((opj_common_ptr) compress, &ctx->event_mgr, avctx);
  575.  
  576.     if (!opj_encode(compress, stream, image, NULL)) {
  577.         av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");
  578.         return -1;
  579.     }
  580.  
  581.     len = cio_tell(stream);
  582.     if ((ret = ff_alloc_packet2(avctx, pkt, len, 0)) < 0) {
  583.         return ret;
  584.     }
  585.  
  586.     memcpy(pkt->data, stream->buffer, len);
  587.     pkt->flags |= AV_PKT_FLAG_KEY;
  588.     *got_packet = 1;
  589.  
  590.     opj_cio_close(stream);
  591.     stream = NULL;
  592.     opj_destroy_compress(compress);
  593.     compress = NULL;
  594.  
  595.     return 0;
  596. }
  597.  
  598. static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
  599. {
  600.     LibOpenJPEGContext *ctx = avctx->priv_data;
  601.  
  602.     opj_image_destroy(ctx->image);
  603.     ctx->image = NULL;
  604.     return 0;
  605. }
  606.  
  607. #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
  608. #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  609. static const AVOption options[] = {
  610.     { "format",        "Codec Format",      OFFSET(format),        AV_OPT_TYPE_INT,   { .i64 = CODEC_JP2   }, CODEC_J2K, CODEC_JP2,   VE, "format"      },
  611.     { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K   }, 0,         0,           VE, "format"      },
  612.     { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2   }, 0,         0,           VE, "format"      },
  613.     { "profile",       NULL,                OFFSET(profile),       AV_OPT_TYPE_INT,   { .i64 = STD_RSIZ    }, STD_RSIZ,  CINEMA4K,    VE, "profile"     },
  614.     { "jpeg2000",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = STD_RSIZ    }, 0,         0,           VE, "profile"     },
  615.     { "cinema2k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K    }, 0,         0,           VE, "profile"     },
  616.     { "cinema4k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K    }, 0,         0,           VE, "profile"     },
  617.     { "cinema_mode",   "Digital Cinema",    OFFSET(cinema_mode),   AV_OPT_TYPE_INT,   { .i64 = OFF         }, OFF,       CINEMA4K_24, VE, "cinema_mode" },
  618.     { "off",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OFF         }, 0,         0,           VE, "cinema_mode" },
  619.     { "2k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_24 }, 0,         0,           VE, "cinema_mode" },
  620.     { "2k_48",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_48 }, 0,         0,           VE, "cinema_mode" },
  621.     { "4k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K_24 }, 0,         0,           VE, "cinema_mode" },
  622.     { "prog_order",    "Progression Order", OFFSET(prog_order),    AV_OPT_TYPE_INT,   { .i64 = LRCP        }, LRCP,      CPRL,        VE, "prog_order"  },
  623.     { "lrcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = LRCP        }, 0,         0,           VE, "prog_order"  },
  624.     { "rlcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RLCP        }, 0,         0,           VE, "prog_order"  },
  625.     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RPCL        }, 0,         0,           VE, "prog_order"  },
  626.     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = PCRL        }, 0,         0,           VE, "prog_order"  },
  627.     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CPRL        }, 0,         0,           VE, "prog_order"  },
  628.     { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { .i64 = 6           }, 1,         INT_MAX,     VE                },
  629.     { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { .i64 = 1           }, 1,         10,          VE                },
  630.     { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { .i64 = 1           }, 0,         1,           VE                },
  631.     { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
  632.     { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
  633.     { NULL },
  634. };
  635.  
  636. static const AVClass openjpeg_class = {
  637.     .class_name = "libopenjpeg",
  638.     .item_name  = av_default_item_name,
  639.     .option     = options,
  640.     .version    = LIBAVUTIL_VERSION_INT,
  641. };
  642.  
  643. AVCodec ff_libopenjpeg_encoder = {
  644.     .name           = "libopenjpeg",
  645.     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
  646.     .type           = AVMEDIA_TYPE_VIDEO,
  647.     .id             = AV_CODEC_ID_JPEG2000,
  648.     .priv_data_size = sizeof(LibOpenJPEGContext),
  649.     .init           = libopenjpeg_encode_init,
  650.     .encode2        = libopenjpeg_encode_frame,
  651.     .close          = libopenjpeg_encode_close,
  652.     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
  653.     .pix_fmts       = (const enum AVPixelFormat[]) {
  654.         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,
  655.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_GBR24P,
  656.         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
  657.         AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16,
  658.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,
  659.         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,
  660.         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,
  661.         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
  662.         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
  663.         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
  664.         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
  665.         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
  666.         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
  667.         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
  668.         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
  669.         AV_PIX_FMT_XYZ12,
  670.         AV_PIX_FMT_NONE
  671.     },
  672.     .priv_class     = &openjpeg_class,
  673. };
  674.