falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
79132 Commits
32 Branches
303MB
Tree: 99388eb091
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '99388eb091'
${ noResults }
FFmpeg/libavcodec/libopenjpegenc.c

864 lines
30KB
Raw Blame History 

  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_2_1_OPENJPEG_H

  38. #  include <openjpeg-2.1/openjpeg.h>

  39. #elif HAVE_OPENJPEG_2_0_OPENJPEG_H

  40. #  include <openjpeg-2.0/openjpeg.h>

  41. #elif HAVE_OPENJPEG_1_5_OPENJPEG_H

  42. #  include <openjpeg-1.5/openjpeg.h>

  43. #else

  44. #  include <openjpeg.h>

  45. #endif

  46. 

  47. #if HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H

  48. #  define OPENJPEG_MAJOR_VERSION 2

  49. #  define OPJ(x) OPJ_##x

  50. #else

  51. #  define OPENJPEG_MAJOR_VERSION 1

  52. #  define OPJ(x) x

  53. #endif

  54. 

  55. typedef struct LibOpenJPEGContext {

  56.     AVClass *avclass;

  57.     opj_image_t *image;

  58.     opj_cparameters_t enc_params;

  59. #if OPENJPEG_MAJOR_VERSION == 1

  60.     opj_event_mgr_t event_mgr;

  61. #endif // OPENJPEG_MAJOR_VERSION == 1

  62.     int format;

  63.     int profile;

  64.     int prog_order;

  65.     int cinema_mode;

  66.     int numresolution;

  67.     int numlayers;

  68.     int disto_alloc;

  69.     int fixed_alloc;

  70.     int fixed_quality;

  71. } LibOpenJPEGContext;

  72. 

  73. static void error_callback(const char *msg, void *data)

  74. {

  75.     av_log(data, AV_LOG_ERROR, "%s\n", msg);

  76. }

  77. 

  78. static void warning_callback(const char *msg, void *data)

  79. {

  80.     av_log(data, AV_LOG_WARNING, "%s\n", msg);

  81. }

  82. 

  83. static void info_callback(const char *msg, void *data)

  84. {

  85.     av_log(data, AV_LOG_DEBUG, "%s\n", msg);

  86. }

  87. 

  88. #if OPENJPEG_MAJOR_VERSION == 2

  89. typedef struct PacketWriter {

  90.     int pos;

  91.     AVPacket *packet;

  92. } PacketWriter;

  93. 

  94. static OPJ_SIZE_T stream_write(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)

  95. {

  96.     PacketWriter *writer = user_data;

  97.     AVPacket *packet = writer->packet;

  98.     int remaining = packet->size - writer->pos;

  99.     if (nb_bytes > remaining) {

  100.         OPJ_SIZE_T needed = nb_bytes - remaining;

  101.         int max_growth = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - packet->size;

  102.         if (needed > max_growth) {

  103.             return (OPJ_SIZE_T)-1;

  104.         }

  105.         if (av_grow_packet(packet, (int)needed)) {

  106.             return (OPJ_SIZE_T)-1;

  107.         }

  108.     }

  109.     memcpy(packet->data + writer->pos, out_buffer, nb_bytes);

  110.     writer->pos += (int)nb_bytes;

  111.     return nb_bytes;

  112. }

  113. 

  114. static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)

  115. {

  116.     PacketWriter *writer = user_data;

  117.     AVPacket *packet = writer->packet;

  118.     if (nb_bytes < 0) {

  119.         if (writer->pos == 0) {

  120.             return (OPJ_SIZE_T)-1;

  121.         }

  122.         if (nb_bytes + writer->pos < 0) {

  123.             nb_bytes = -writer->pos;

  124.         }

  125.     } else {

  126.         int remaining = packet->size - writer->pos;

  127.         if (nb_bytes > remaining) {

  128.             OPJ_SIZE_T needed = nb_bytes - remaining;

  129.             int max_growth = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - packet->size;

  130.             if (needed > max_growth) {

  131.                 return (OPJ_SIZE_T)-1;

  132.             }

  133.             if (av_grow_packet(packet, (int)needed)) {

  134.                 return (OPJ_SIZE_T)-1;

  135.             }

  136.         }

  137.     }

  138.     writer->pos += (int)nb_bytes;

  139.     return nb_bytes;

  140. }

  141. 

  142. static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)

  143. {

  144.     PacketWriter *writer = user_data;

  145.     AVPacket *packet = writer->packet;

  146.     if (nb_bytes < 0) {

  147.         return OPJ_FALSE;

  148.     }

  149.     if (nb_bytes > packet->size) {

  150.         if (nb_bytes > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||

  151.             av_grow_packet(packet, (int)nb_bytes - packet->size)) {

  152.             return OPJ_FALSE;

  153.         }

  154.     }

  155.     writer->pos = (int)nb_bytes;

  156.     return OPJ_TRUE;

  157. }

  158. #endif // OPENJPEG_MAJOR_VERSION == 2

  159. 

  160. static void cinema_parameters(opj_cparameters_t *p)

  161. {

  162.     p->tile_size_on = 0;

  163.     p->cp_tdx = 1;

  164.     p->cp_tdy = 1;

  165. 

  166.     /* Tile part */

  167.     p->tp_flag = 'C';

  168.     p->tp_on = 1;

  169. 

  170.     /* Tile and Image shall be at (0, 0) */

  171.     p->cp_tx0 = 0;

  172.     p->cp_ty0 = 0;

  173.     p->image_offset_x0 = 0;

  174.     p->image_offset_y0 = 0;

  175. 

  176.     /* Codeblock size= 32 * 32 */

  177.     p->cblockw_init = 32;

  178.     p->cblockh_init = 32;

  179.     p->csty |= 0x01;

  180. 

  181.     /* The progression order shall be CPRL */

  182.     p->prog_order = OPJ(CPRL);

  183. 

  184.     /* No ROI */

  185.     p->roi_compno = -1;

  186. 

  187.     /* No subsampling */

  188.     p->subsampling_dx = 1;

  189.     p->subsampling_dy = 1;

  190. 

  191.     /* 9-7 transform */

  192.     p->irreversible = 1;

  193. 

  194.     p->tcp_mct = 1;

  195. }

  196. 

  197. static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)

  198. {

  199.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

  200.     opj_image_cmptparm_t cmptparm[4] = {{0}};

  201.     opj_image_t *img;

  202.     int i;

  203.     int sub_dx[4];

  204.     int sub_dy[4];

  205.     int numcomps;

  206.     OPJ_COLOR_SPACE color_space = OPJ(CLRSPC_UNKNOWN);

  207. 

  208.     sub_dx[0] = sub_dx[3] = 1;

  209.     sub_dy[0] = sub_dy[3] = 1;

  210.     sub_dx[1] = sub_dx[2] = 1 << desc->log2_chroma_w;

  211.     sub_dy[1] = sub_dy[2] = 1 << desc->log2_chroma_h;

  212. 

  213.     numcomps = desc->nb_components;

  214. 

  215.     switch (avctx->pix_fmt) {

  216.     case AV_PIX_FMT_GRAY8:

  217.     case AV_PIX_FMT_YA8:

  218.     case AV_PIX_FMT_GRAY16:

  219.     case AV_PIX_FMT_YA16:

  220.         color_space = OPJ(CLRSPC_GRAY);

  221.         break;

  222.     case AV_PIX_FMT_RGB24:

  223.     case AV_PIX_FMT_RGBA:

  224.     case AV_PIX_FMT_RGB48:

  225.     case AV_PIX_FMT_RGBA64:

  226.     case AV_PIX_FMT_GBR24P:

  227.     case AV_PIX_FMT_GBRP9:

  228.     case AV_PIX_FMT_GBRP10:

  229.     case AV_PIX_FMT_GBRP12:

  230.     case AV_PIX_FMT_GBRP14:

  231.     case AV_PIX_FMT_GBRP16:

  232.     case AV_PIX_FMT_XYZ12:

  233.         color_space = OPJ(CLRSPC_SRGB);

  234.         break;

  235.     case AV_PIX_FMT_YUV410P:

  236.     case AV_PIX_FMT_YUV411P:

  237.     case AV_PIX_FMT_YUV420P:

  238.     case AV_PIX_FMT_YUV422P:

  239.     case AV_PIX_FMT_YUV440P:

  240.     case AV_PIX_FMT_YUV444P:

  241.     case AV_PIX_FMT_YUVA420P:

  242.     case AV_PIX_FMT_YUVA422P:

  243.     case AV_PIX_FMT_YUVA444P:

  244.     case AV_PIX_FMT_YUV420P9:

  245.     case AV_PIX_FMT_YUV422P9:

  246.     case AV_PIX_FMT_YUV444P9:

  247.     case AV_PIX_FMT_YUVA420P9:

  248.     case AV_PIX_FMT_YUVA422P9:

  249.     case AV_PIX_FMT_YUVA444P9:

  250.     case AV_PIX_FMT_YUV420P10:

  251.     case AV_PIX_FMT_YUV422P10:

  252.     case AV_PIX_FMT_YUV444P10:

  253.     case AV_PIX_FMT_YUVA420P10:

  254.     case AV_PIX_FMT_YUVA422P10:

  255.     case AV_PIX_FMT_YUVA444P10:

  256.     case AV_PIX_FMT_YUV420P12:

  257.     case AV_PIX_FMT_YUV422P12:

  258.     case AV_PIX_FMT_YUV444P12:

  259.     case AV_PIX_FMT_YUV420P14:

  260.     case AV_PIX_FMT_YUV422P14:

  261.     case AV_PIX_FMT_YUV444P14:

  262.     case AV_PIX_FMT_YUV420P16:

  263.     case AV_PIX_FMT_YUV422P16:

  264.     case AV_PIX_FMT_YUV444P16:

  265.     case AV_PIX_FMT_YUVA420P16:

  266.     case AV_PIX_FMT_YUVA422P16:

  267.     case AV_PIX_FMT_YUVA444P16:

  268.         color_space = OPJ(CLRSPC_SYCC);

  269.         break;

  270.     default:

  271.         av_log(avctx, AV_LOG_ERROR,

  272.                "The requested pixel format '%s' is not supported\n",

  273.                av_get_pix_fmt_name(avctx->pix_fmt));

  274.         return NULL;

  275.     }

  276. 

  277.     for (i = 0; i < numcomps; i++) {

  278.         cmptparm[i].prec = desc->comp[i].depth;

  279.         cmptparm[i].bpp  = desc->comp[i].depth;

  280.         cmptparm[i].sgnd = 0;

  281.         cmptparm[i].dx = sub_dx[i];

  282.         cmptparm[i].dy = sub_dy[i];

  283.         cmptparm[i].w = (avctx->width + sub_dx[i] - 1) / sub_dx[i];

  284.         cmptparm[i].h = (avctx->height + sub_dy[i] - 1) / sub_dy[i];

  285.     }

  286. 

  287.     img = opj_image_create(numcomps, cmptparm, color_space);

  288. 

  289.     if (!img)

  290.         return NULL;

  291. 

  292.     // x0, y0 is the top left corner of the image

  293.     // x1, y1 is the width, height of the reference grid

  294.     img->x0 = 0;

  295.     img->y0 = 0;

  296.     img->x1 = (avctx->width  - 1) * parameters->subsampling_dx + 1;

  297.     img->y1 = (avctx->height - 1) * parameters->subsampling_dy + 1;

  298. 

  299.     return img;

  300. }

  301. 

  302. static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)

  303. {

  304.     LibOpenJPEGContext *ctx = avctx->priv_data;

  305.     int err = 0;

  306. 

  307.     opj_set_default_encoder_parameters(&ctx->enc_params);

  308. 

  309. #if HAVE_OPENJPEG_2_1_OPENJPEG_H

  310.     switch (ctx->cinema_mode) {

  311.     case OPJ_CINEMA2K_24:

  312.         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_2K;

  313.         ctx->enc_params.max_cs_size = OPJ_CINEMA_24_CS;

  314.         ctx->enc_params.max_comp_size = OPJ_CINEMA_24_COMP;

  315.         break;

  316.     case OPJ_CINEMA2K_48:

  317.         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_2K;

  318.         ctx->enc_params.max_cs_size = OPJ_CINEMA_48_CS;

  319.         ctx->enc_params.max_comp_size = OPJ_CINEMA_48_COMP;

  320.         break;

  321.     case OPJ_CINEMA4K_24:

  322.         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_4K;

  323.         ctx->enc_params.max_cs_size = OPJ_CINEMA_24_CS;

  324.         ctx->enc_params.max_comp_size = OPJ_CINEMA_24_COMP;

  325.         break;

  326.     }

  327. 

  328.     switch (ctx->profile) {

  329.     case OPJ_CINEMA2K:

  330.         if (ctx->enc_params.rsiz == OPJ_PROFILE_CINEMA_4K) {

  331.             err = AVERROR(EINVAL);

  332.             break;

  333.         }

  334.         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_2K;

  335.         break;

  336.     case OPJ_CINEMA4K:

  337.         if (ctx->enc_params.rsiz == OPJ_PROFILE_CINEMA_2K) {

  338.             err = AVERROR(EINVAL);

  339.             break;

  340.         }

  341.         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_4K;

  342.         break;

  343.     }

  344. 

  345.     if (err) {

  346.         av_log(avctx, AV_LOG_ERROR,

  347.                "Invalid parameter pairing: cinema_mode and profile conflict.\n");

  348.         goto fail;

  349.     }

  350. #else

  351.     ctx->enc_params.cp_rsiz = ctx->profile;

  352.     ctx->enc_params.cp_cinema = ctx->cinema_mode;

  353. #endif

  354. 

  355.     ctx->enc_params.mode = !!avctx->global_quality;

  356.     ctx->enc_params.prog_order = ctx->prog_order;

  357.     ctx->enc_params.numresolution = ctx->numresolution;

  358.     ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;

  359.     ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;

  360.     ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;

  361.     ctx->enc_params.tcp_numlayers = ctx->numlayers;

  362.     ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;

  363. 

  364.     if (ctx->cinema_mode > 0) {

  365.         cinema_parameters(&ctx->enc_params);

  366.     }

  367. 

  368.     ctx->image = mj2_create_image(avctx, &ctx->enc_params);

  369.     if (!ctx->image) {

  370.         av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");

  371.         err = AVERROR(EINVAL);

  372.         goto fail;

  373.     }

  374. 

  375.     return 0;

  376. 

  377. fail:

  378.     opj_image_destroy(ctx->image);

  379.     ctx->image = NULL;

  380.     return err;

  381. }

  382. 

  383. static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

  384. {

  385.     int compno;

  386.     int x;

  387.     int y;

  388.     int *image_line;

  389.     int frame_index;

  390.     const int numcomps = image->numcomps;

  391. 

  392.     for (compno = 0; compno < numcomps; ++compno) {

  393.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {

  394.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

  395.             return 0;

  396.         }

  397.     }

  398. 

  399.     for (compno = 0; compno < numcomps; ++compno) {

  400.         for (y = 0; y < avctx->height; ++y) {

  401.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  402.             frame_index = y * frame->linesize[0] + compno;

  403.             for (x = 0; x < avctx->width; ++x) {

  404.                 image_line[x] = frame->data[0][frame_index];

  405.                 frame_index += numcomps;

  406.             }

  407.             for (; x < image->comps[compno].w; ++x) {

  408.                 image_line[x] = image_line[x - 1];

  409.             }

  410.         }

  411.         for (; y < image->comps[compno].h; ++y) {

  412.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  413.             for (x = 0; x < image->comps[compno].w; ++x) {

  414.                 image_line[x] = image_line[x - image->comps[compno].w];

  415.             }

  416.         }

  417.     }

  418. 

  419.     return 1;

  420. }

  421. 

  422. // for XYZ 12 bit

  423. static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

  424. {

  425.     int compno;

  426.     int x, y;

  427.     int *image_line;

  428.     int frame_index;

  429.     const int numcomps  = image->numcomps;

  430.     uint16_t *frame_ptr = (uint16_t *)frame->data[0];

  431. 

  432.     for (compno = 0; compno < numcomps; ++compno) {

  433.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {

  434.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

  435.             return 0;

  436.         }

  437.     }

  438. 

  439.     for (compno = 0; compno < numcomps; ++compno) {

  440.         for (y = 0; y < avctx->height; ++y) {

  441.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  442.             frame_index = y * (frame->linesize[0] / 2) + compno;

  443.             for (x = 0; x < avctx->width; ++x) {

  444.                 image_line[x] = frame_ptr[frame_index] >> 4;

  445.                 frame_index += numcomps;

  446.             }

  447.             for (; x < image->comps[compno].w; ++x) {

  448.                 image_line[x] = image_line[x - 1];

  449.             }

  450.         }

  451.         for (; y < image->comps[compno].h; ++y) {

  452.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  453.             for (x = 0; x < image->comps[compno].w; ++x) {

  454.                 image_line[x] = image_line[x - image->comps[compno].w];

  455.             }

  456.         }

  457.     }

  458. 

  459.     return 1;

  460. }

  461. 

  462. static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

  463. {

  464.     int compno;

  465.     int x;

  466.     int y;

  467.     int *image_line;

  468.     int frame_index;

  469.     const int numcomps = image->numcomps;

  470.     uint16_t *frame_ptr = (uint16_t*)frame->data[0];

  471. 

  472.     for (compno = 0; compno < numcomps; ++compno) {

  473.         if (image->comps[compno].w > frame->linesize[0] / numcomps) {

  474.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

  475.             return 0;

  476.         }

  477.     }

  478. 

  479.     for (compno = 0; compno < numcomps; ++compno) {

  480.         for (y = 0; y < avctx->height; ++y) {

  481.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  482.             frame_index = y * (frame->linesize[0] / 2) + compno;

  483.             for (x = 0; x < avctx->width; ++x) {

  484.                 image_line[x] = frame_ptr[frame_index];

  485.                 frame_index += numcomps;

  486.             }

  487.             for (; x < image->comps[compno].w; ++x) {

  488.                 image_line[x] = image_line[x - 1];

  489.             }

  490.         }

  491.         for (; y < image->comps[compno].h; ++y) {

  492.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  493.             for (x = 0; x < image->comps[compno].w; ++x) {

  494.                 image_line[x] = image_line[x - image->comps[compno].w];

  495.             }

  496.         }

  497.     }

  498. 

  499.     return 1;

  500. }

  501. 

  502. static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

  503. {

  504.     int compno;

  505.     int x;

  506.     int y;

  507.     int width;

  508.     int height;

  509.     int *image_line;

  510.     int frame_index;

  511.     const int numcomps = image->numcomps;

  512. 

  513.     for (compno = 0; compno < numcomps; ++compno) {

  514.         if (image->comps[compno].w > frame->linesize[compno]) {

  515.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

  516.             return 0;

  517.         }

  518.     }

  519. 

  520.     for (compno = 0; compno < numcomps; ++compno) {

  521.         width  = avctx->width / image->comps[compno].dx;

  522.         height = avctx->height / image->comps[compno].dy;

  523.         for (y = 0; y < height; ++y) {

  524.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  525.             frame_index = y * frame->linesize[compno];

  526.             for (x = 0; x < width; ++x)

  527.                 image_line[x] = frame->data[compno][frame_index++];

  528.             for (; x < image->comps[compno].w; ++x) {

  529.                 image_line[x] = image_line[x - 1];

  530.             }

  531.         }

  532.         for (; y < image->comps[compno].h; ++y) {

  533.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  534.             for (x = 0; x < image->comps[compno].w; ++x) {

  535.                 image_line[x] = image_line[x - image->comps[compno].w];

  536.             }

  537.         }

  538.     }

  539. 

  540.     return 1;

  541. }

  542. 

  543. static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)

  544. {

  545.     int compno;

  546.     int x;

  547.     int y;

  548.     int width;

  549.     int height;

  550.     int *image_line;

  551.     int frame_index;

  552.     const int numcomps = image->numcomps;

  553.     uint16_t *frame_ptr;

  554. 

  555.     for (compno = 0; compno < numcomps; ++compno) {

  556.         if (image->comps[compno].w > frame->linesize[compno]) {

  557.             av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");

  558.             return 0;

  559.         }

  560.     }

  561. 

  562.     for (compno = 0; compno < numcomps; ++compno) {

  563.         width     = avctx->width / image->comps[compno].dx;

  564.         height    = avctx->height / image->comps[compno].dy;

  565.         frame_ptr = (uint16_t *)frame->data[compno];

  566.         for (y = 0; y < height; ++y) {

  567.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  568.             frame_index = y * (frame->linesize[compno] / 2);

  569.             for (x = 0; x < width; ++x)

  570.                 image_line[x] = frame_ptr[frame_index++];

  571.             for (; x < image->comps[compno].w; ++x) {

  572.                 image_line[x] = image_line[x - 1];

  573.             }

  574.         }

  575.         for (; y < image->comps[compno].h; ++y) {

  576.             image_line = image->comps[compno].data + y * image->comps[compno].w;

  577.             for (x = 0; x < image->comps[compno].w; ++x) {

  578.                 image_line[x] = image_line[x - image->comps[compno].w];

  579.             }

  580.         }

  581.     }

  582. 

  583.     return 1;

  584. }

  585. 

  586. static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

  587.                                     const AVFrame *frame, int *got_packet)

  588. {

  589.     LibOpenJPEGContext *ctx = avctx->priv_data;

  590.     opj_image_t *image      = ctx->image;

  591. #if OPENJPEG_MAJOR_VERSION == 1

  592.     opj_cinfo_t *compress   = NULL;

  593.     opj_cio_t *stream       = NULL;

  594.     int len;

  595. #else // OPENJPEG_MAJOR_VERSION == 2

  596.     opj_codec_t *compress   = NULL;

  597.     opj_stream_t *stream    = NULL;

  598.     PacketWriter writer     = { 0 };

  599. #endif // OPENJPEG_MAJOR_VERSION == 1

  600.     int cpyresult = 0;

  601.     int ret;

  602.     AVFrame *gbrframe;

  603. 

  604.     switch (avctx->pix_fmt) {

  605.     case AV_PIX_FMT_RGB24:

  606.     case AV_PIX_FMT_RGBA:

  607.     case AV_PIX_FMT_YA8:

  608.         cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);

  609.         break;

  610.     case AV_PIX_FMT_XYZ12:

  611.         cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);

  612.         break;

  613.     case AV_PIX_FMT_RGB48:

  614.     case AV_PIX_FMT_RGBA64:

  615.     case AV_PIX_FMT_YA16:

  616.         cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);

  617.         break;

  618.     case AV_PIX_FMT_GBR24P:

  619.     case AV_PIX_FMT_GBRP9:

  620.     case AV_PIX_FMT_GBRP10:

  621.     case AV_PIX_FMT_GBRP12:

  622.     case AV_PIX_FMT_GBRP14:

  623.     case AV_PIX_FMT_GBRP16:

  624.         gbrframe = av_frame_clone(frame);

  625.         if (!gbrframe)

  626.             return AVERROR(ENOMEM);

  627.         gbrframe->data[0] = frame->data[2]; // swap to be rgb

  628.         gbrframe->data[1] = frame->data[0];

  629.         gbrframe->data[2] = frame->data[1];

  630.         gbrframe->linesize[0] = frame->linesize[2];

  631.         gbrframe->linesize[1] = frame->linesize[0];

  632.         gbrframe->linesize[2] = frame->linesize[1];

  633.         if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {

  634.             cpyresult = libopenjpeg_copy_unpacked8(avctx, gbrframe, image);

  635.         } else {

  636.             cpyresult = libopenjpeg_copy_unpacked16(avctx, gbrframe, image);

  637.         }

  638.         av_frame_free(&gbrframe);

  639.         break;

  640.     case AV_PIX_FMT_GRAY8:

  641.     case AV_PIX_FMT_YUV410P:

  642.     case AV_PIX_FMT_YUV411P:

  643.     case AV_PIX_FMT_YUV420P:

  644.     case AV_PIX_FMT_YUV422P:

  645.     case AV_PIX_FMT_YUV440P:

  646.     case AV_PIX_FMT_YUV444P:

  647.     case AV_PIX_FMT_YUVA420P:

  648.     case AV_PIX_FMT_YUVA422P:

  649.     case AV_PIX_FMT_YUVA444P:

  650.         cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);

  651.         break;

  652.     case AV_PIX_FMT_GRAY16:

  653.     case AV_PIX_FMT_YUV420P9:

  654.     case AV_PIX_FMT_YUV422P9:

  655.     case AV_PIX_FMT_YUV444P9:

  656.     case AV_PIX_FMT_YUVA420P9:

  657.     case AV_PIX_FMT_YUVA422P9:

  658.     case AV_PIX_FMT_YUVA444P9:

  659.     case AV_PIX_FMT_YUV444P10:

  660.     case AV_PIX_FMT_YUV422P10:

  661.     case AV_PIX_FMT_YUV420P10:

  662.     case AV_PIX_FMT_YUVA444P10:

  663.     case AV_PIX_FMT_YUVA422P10:

  664.     case AV_PIX_FMT_YUVA420P10:

  665.     case AV_PIX_FMT_YUV420P12:

  666.     case AV_PIX_FMT_YUV422P12:

  667.     case AV_PIX_FMT_YUV444P12:

  668.     case AV_PIX_FMT_YUV420P14:

  669.     case AV_PIX_FMT_YUV422P14:

  670.     case AV_PIX_FMT_YUV444P14:

  671.     case AV_PIX_FMT_YUV444P16:

  672.     case AV_PIX_FMT_YUV422P16:

  673.     case AV_PIX_FMT_YUV420P16:

  674.     case AV_PIX_FMT_YUVA444P16:

  675.     case AV_PIX_FMT_YUVA422P16:

  676.     case AV_PIX_FMT_YUVA420P16:

  677.         cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);

  678.         break;

  679.     default:

  680.         av_log(avctx, AV_LOG_ERROR,

  681.                "The frame's pixel format '%s' is not supported\n",

  682.                av_get_pix_fmt_name(avctx->pix_fmt));

  683.         return AVERROR(EINVAL);

  684.         break;

  685.     }

  686. 

  687.     if (!cpyresult) {

  688.         av_log(avctx, AV_LOG_ERROR,

  689.                "Could not copy the frame data to the internal image buffer\n");

  690.         return -1;

  691.     }

  692. 

  693. #if OPENJPEG_MAJOR_VERSION == 2

  694.     if ((ret = ff_alloc_packet2(avctx, pkt, 1024, 0)) < 0) {

  695.         return ret;

  696.     }

  697. #endif // OPENJPEG_MAJOR_VERSION == 2

  698. 

  699.     compress = opj_create_compress(ctx->format);

  700.     if (!compress) {

  701.         av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");

  702.         ret = AVERROR(ENOMEM);

  703.         goto done;

  704.     }

  705. 

  706. #if OPENJPEG_MAJOR_VERSION == 1

  707.     opj_setup_encoder(compress, &ctx->enc_params, image);

  708.     stream = opj_cio_open((opj_common_ptr) compress, NULL, 0);

  709. #else // OPENJPEG_MAJOR_VERSION == 2

  710.     if (!opj_set_error_handler(compress, error_callback, avctx) ||

  711.         !opj_set_warning_handler(compress, warning_callback, avctx) ||

  712.         !opj_set_info_handler(compress, info_callback, avctx)) {

  713.         av_log(avctx, AV_LOG_ERROR, "Error setting the compressor handlers\n");

  714.         ret = AVERROR_EXTERNAL;

  715.         goto done;

  716.     }

  717. 

  718.     if (!opj_setup_encoder(compress, &ctx->enc_params, image)) {

  719.         av_log(avctx, AV_LOG_ERROR, "Error setting up the compressor\n");

  720.         ret = AVERROR_EXTERNAL;

  721.         goto done;

  722.     }

  723.     stream = opj_stream_default_create(OPJ_STREAM_WRITE);

  724. #endif // OPENJPEG_MAJOR_VERSION == 1

  725. 

  726.     if (!stream) {

  727.         av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");

  728.         ret = AVERROR(ENOMEM);

  729.         goto done;

  730.     }

  731. #if OPENJPEG_MAJOR_VERSION == 1

  732.     memset(&ctx->event_mgr, 0, sizeof(ctx->event_mgr));

  733.     ctx->event_mgr.info_handler    = info_callback;

  734.     ctx->event_mgr.error_handler   = error_callback;

  735.     ctx->event_mgr.warning_handler = warning_callback;

  736.     opj_set_event_mgr((opj_common_ptr) compress, &ctx->event_mgr, avctx);

  737.     if (!opj_encode(compress, stream, image, NULL)) {

  738.         av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");

  739.         ret = AVERROR_EXTERNAL;

  740.         goto done;

  741.     }

  742. 

  743.     len = cio_tell(stream);

  744.     if ((ret = ff_alloc_packet2(avctx, pkt, len, 0)) < 0) {

  745.         goto done;

  746.     }

  747. 

  748.     memcpy(pkt->data, stream->buffer, len);

  749. #else // OPENJPEG_MAJOR_VERSION == 2

  750.     writer.packet = pkt;

  751.     opj_stream_set_write_function(stream, stream_write);

  752.     opj_stream_set_skip_function(stream, stream_skip);

  753.     opj_stream_set_seek_function(stream, stream_seek);

  754. #if HAVE_OPENJPEG_2_1_OPENJPEG_H

  755.     opj_stream_set_user_data(stream, &writer, NULL);

  756. #elif HAVE_OPENJPEG_2_0_OPENJPEG_H

  757.     opj_stream_set_user_data(stream, &writer);

  758. #else

  759. #error Missing call to opj_stream_set_user_data

  760. #endif

  761. 

  762.     if (!opj_start_compress(compress, ctx->image, stream) ||

  763.         !opj_encode(compress, stream) ||

  764.         !opj_end_compress(compress, stream)) {

  765.         av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");

  766.         ret = AVERROR_EXTERNAL;

  767.         goto done;

  768.     }

  769. 

  770.     av_shrink_packet(pkt, writer.pos);

  771. #endif // OPENJPEG_MAJOR_VERSION == 1

  772. 

  773.     pkt->flags |= AV_PKT_FLAG_KEY;

  774.     *got_packet = 1;

  775.     ret = 0;

  776. 

  777. done:

  778. #if OPENJPEG_MAJOR_VERSION == 2

  779.     opj_stream_destroy(stream);

  780.     opj_destroy_codec(compress);

  781. #else

  782.     opj_cio_close(stream);

  783.     opj_destroy_compress(compress);

  784. #endif

  785.     return ret;

  786. }

  787. 

  788. static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)

  789. {

  790.     LibOpenJPEGContext *ctx = avctx->priv_data;

  791. 

  792.     opj_image_destroy(ctx->image);

  793.     ctx->image = NULL;

  794.     return 0;

  795. }

  796. 

  797. #define OFFSET(x) offsetof(LibOpenJPEGContext, x)

  798. #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

  799. static const AVOption options[] = {

  800.     { "format",        "Codec Format",      OFFSET(format),        AV_OPT_TYPE_INT,   { .i64 = OPJ(CODEC_JP2)   }, OPJ(CODEC_J2K), OPJ(CODEC_JP2),   VE, "format"      },

  801.     { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CODEC_J2K)   }, 0,         0,           VE, "format"      },

  802.     { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CODEC_JP2)   }, 0,         0,           VE, "format"      },

  803.     { "profile",       NULL,                OFFSET(profile),       AV_OPT_TYPE_INT,   { .i64 = OPJ(STD_RSIZ)    }, OPJ(STD_RSIZ),  OPJ(CINEMA4K),    VE, "profile"     },

  804.     { "jpeg2000",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(STD_RSIZ)    }, 0,         0,           VE, "profile"     },

  805.     { "cinema2k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CINEMA2K)    }, 0,         0,           VE, "profile"     },

  806.     { "cinema4k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CINEMA4K)    }, 0,         0,           VE, "profile"     },

  807.     { "cinema_mode",   "Digital Cinema",    OFFSET(cinema_mode),   AV_OPT_TYPE_INT,   { .i64 = OPJ(OFF)         }, OPJ(OFF),       OPJ(CINEMA4K_24), VE, "cinema_mode" },

  808.     { "off",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(OFF)         }, 0,         0,           VE, "cinema_mode" },

  809.     { "2k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CINEMA2K_24) }, 0,         0,           VE, "cinema_mode" },

  810.     { "2k_48",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CINEMA2K_48) }, 0,         0,           VE, "cinema_mode" },

  811.     { "4k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CINEMA4K_24) }, 0,         0,           VE, "cinema_mode" },

  812.     { "prog_order",    "Progression Order", OFFSET(prog_order),    AV_OPT_TYPE_INT,   { .i64 = OPJ(LRCP)    }, OPJ(LRCP),  OPJ(CPRL),    VE, "prog_order"  },

  813.     { "lrcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(LRCP)    }, 0,         0,           VE, "prog_order"  },

  814.     { "rlcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(RLCP)    }, 0,         0,           VE, "prog_order"  },

  815.     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(RPCL)    }, 0,         0,           VE, "prog_order"  },

  816.     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(PCRL)    }, 0,         0,           VE, "prog_order"  },

  817.     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CPRL)    }, 0,         0,           VE, "prog_order"  },

  818.     { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { .i64 = 6           }, 1,         INT_MAX,     VE                },

  819.     { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { .i64 = 1           }, 1,         10,          VE                },

  820.     { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { .i64 = 1           }, 0,         1,           VE                },

  821.     { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },

  822.     { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },

  823.     { NULL },

  824. };

  825. 

  826. static const AVClass openjpeg_class = {

  827.     .class_name = "libopenjpeg",

  828.     .item_name  = av_default_item_name,

  829.     .option     = options,

  830.     .version    = LIBAVUTIL_VERSION_INT,

  831. };

  832. 

  833. AVCodec ff_libopenjpeg_encoder = {

  834.     .name           = "libopenjpeg",

  835.     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),

  836.     .type           = AVMEDIA_TYPE_VIDEO,

  837.     .id             = AV_CODEC_ID_JPEG2000,

  838.     .priv_data_size = sizeof(LibOpenJPEGContext),

  839.     .init           = libopenjpeg_encode_init,

  840.     .encode2        = libopenjpeg_encode_frame,

  841.     .close          = libopenjpeg_encode_close,

  842.     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,

  843.     .pix_fmts       = (const enum AVPixelFormat[]) {

  844.         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,

  845.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_GBR24P,

  846.         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,

  847.         AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16,

  848.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,

  849.         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,

  850.         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,

  851.         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,

  852.         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,

  853.         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

  854.         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,

  855.         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,

  856.         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,

  857.         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,

  858.         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,

  859.         AV_PIX_FMT_XYZ12,

  860.         AV_PIX_FMT_NONE

  861.     },

  862.     .priv_class     = &openjpeg_class,

  863. };