2 * JPEG 2000 encoding support via OpenJPEG
3 * Copyright (c) 2011 Michael Bradshaw <mjbshaw gmail com>
5 * This file is part of FFmpeg.
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.
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.
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
24 * JPEG 2000 encoder using libopenjpeg
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"
37 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
38 # include <openjpeg-1.5/openjpeg.h>
40 # include <openjpeg.h>
46 opj_cparameters_t enc_params;
47 opj_cinfo_t *compress;
48 opj_event_mgr_t event_mgr;
60 static void error_callback(const char *msg, void *data)
62 av_log(data, AV_LOG_ERROR, "%s\n", msg);
65 static void warning_callback(const char *msg, void *data)
67 av_log(data, AV_LOG_WARNING, "%s\n", msg);
70 static void info_callback(const char *msg, void *data)
72 av_log(data, AV_LOG_DEBUG, "%s\n", msg);
75 static opj_image_t *mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)
77 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
78 opj_image_cmptparm_t *cmptparm;
84 OPJ_COLOR_SPACE color_space = CLRSPC_UNKNOWN;
86 sub_dx[0] = sub_dx[3] = 1;
87 sub_dy[0] = sub_dy[3] = 1;
88 sub_dx[1] = sub_dx[2] = 1 << desc->log2_chroma_w;
89 sub_dy[1] = sub_dy[2] = 1 << desc->log2_chroma_h;
91 numcomps = desc->nb_components;
93 switch (avctx->pix_fmt) {
94 case AV_PIX_FMT_GRAY8:
95 case AV_PIX_FMT_GRAY8A:
96 case AV_PIX_FMT_GRAY16:
97 color_space = CLRSPC_GRAY;
99 case AV_PIX_FMT_RGB24:
100 case AV_PIX_FMT_RGBA:
101 case AV_PIX_FMT_RGB48:
102 case AV_PIX_FMT_RGBA64:
103 case AV_PIX_FMT_GBR24P:
104 case AV_PIX_FMT_GBRP9:
105 case AV_PIX_FMT_GBRP10:
106 case AV_PIX_FMT_GBRP12:
107 case AV_PIX_FMT_GBRP14:
108 case AV_PIX_FMT_GBRP16:
109 case AV_PIX_FMT_XYZ12:
110 color_space = CLRSPC_SRGB;
112 case AV_PIX_FMT_YUV410P:
113 case AV_PIX_FMT_YUV411P:
114 case AV_PIX_FMT_YUV420P:
115 case AV_PIX_FMT_YUV422P:
116 case AV_PIX_FMT_YUV440P:
117 case AV_PIX_FMT_YUV444P:
118 case AV_PIX_FMT_YUVA420P:
119 case AV_PIX_FMT_YUVA422P:
120 case AV_PIX_FMT_YUVA444P:
121 case AV_PIX_FMT_YUV420P9:
122 case AV_PIX_FMT_YUV422P9:
123 case AV_PIX_FMT_YUV444P9:
124 case AV_PIX_FMT_YUVA420P9:
125 case AV_PIX_FMT_YUVA422P9:
126 case AV_PIX_FMT_YUVA444P9:
127 case AV_PIX_FMT_YUV420P10:
128 case AV_PIX_FMT_YUV422P10:
129 case AV_PIX_FMT_YUV444P10:
130 case AV_PIX_FMT_YUVA420P10:
131 case AV_PIX_FMT_YUVA422P10:
132 case AV_PIX_FMT_YUVA444P10:
133 case AV_PIX_FMT_YUV420P12:
134 case AV_PIX_FMT_YUV422P12:
135 case AV_PIX_FMT_YUV444P12:
136 case AV_PIX_FMT_YUV420P14:
137 case AV_PIX_FMT_YUV422P14:
138 case AV_PIX_FMT_YUV444P14:
139 case AV_PIX_FMT_YUV420P16:
140 case AV_PIX_FMT_YUV422P16:
141 case AV_PIX_FMT_YUV444P16:
142 case AV_PIX_FMT_YUVA420P16:
143 case AV_PIX_FMT_YUVA422P16:
144 case AV_PIX_FMT_YUVA444P16:
145 color_space = CLRSPC_SYCC;
148 av_log(avctx, AV_LOG_ERROR,
149 "The requested pixel format '%s' is not supported\n",
150 av_get_pix_fmt_name(avctx->pix_fmt));
154 cmptparm = av_mallocz(numcomps * sizeof(*cmptparm));
156 av_log(avctx, AV_LOG_ERROR, "Not enough memory\n");
159 for (i = 0; i < numcomps; i++) {
160 cmptparm[i].prec = desc->comp[i].depth_minus1 + 1;
161 cmptparm[i].bpp = desc->comp[i].depth_minus1 + 1;
162 cmptparm[i].sgnd = 0;
163 cmptparm[i].dx = sub_dx[i];
164 cmptparm[i].dy = sub_dy[i];
165 cmptparm[i].w = avctx->width / sub_dx[i];
166 cmptparm[i].h = avctx->height / sub_dy[i];
169 img = opj_image_create(numcomps, cmptparm, color_space);
174 static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
176 LibOpenJPEGContext *ctx = avctx->priv_data;
177 int err = AVERROR(ENOMEM);
179 opj_set_default_encoder_parameters(&ctx->enc_params);
181 ctx->enc_params.cp_rsiz = ctx->profile;
182 ctx->enc_params.mode = !!avctx->global_quality;
183 ctx->enc_params.cp_cinema = ctx->cinema_mode;
184 ctx->enc_params.prog_order = ctx->prog_order;
185 ctx->enc_params.numresolution = ctx->numresolution;
186 ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;
187 ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;
188 ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;
189 ctx->enc_params.tcp_numlayers = ctx->numlayers;
190 ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;
192 if (ctx->cinema_mode > 0) {
193 ctx->enc_params.irreversible = 1;
194 ctx->enc_params.tcp_mct = 1;
195 ctx->enc_params.tile_size_on = 0;
197 ctx->enc_params.cp_tdx=1;
198 ctx->enc_params.cp_tdy=1;
199 ctx->enc_params.subsampling_dx = 1;
200 ctx->enc_params.subsampling_dy = 1;
201 /* Tile and Image shall be at (0,0) */
202 ctx->enc_params.cp_tx0 = 0;
203 ctx->enc_params.cp_ty0 = 0;
204 ctx->enc_params.image_offset_x0 = 0;
205 ctx->enc_params.image_offset_y0 = 0;
206 /* Codeblock size= 32*32 */
207 ctx->enc_params.cblockw_init = 32;
208 ctx->enc_params.cblockh_init = 32;
209 ctx->enc_params.csty |= 0x01;
211 ctx->enc_params.roi_compno = -1;
213 if (ctx->enc_params.prog_order != CPRL) {
214 av_log(avctx, AV_LOG_ERROR, "prog_order forced to CPRL\n");
215 ctx->enc_params.prog_order = CPRL;
217 ctx->enc_params.tp_flag = 'C';
218 ctx->enc_params.tp_on = 1;
221 ctx->compress = opj_create_compress(ctx->format);
222 if (!ctx->compress) {
223 av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");
224 return AVERROR(ENOMEM);
227 avctx->coded_frame = avcodec_alloc_frame();
228 if (!avctx->coded_frame) {
229 av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
233 ctx->image = mj2_create_image(avctx, &ctx->enc_params);
235 av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");
236 err = AVERROR(EINVAL);
240 memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));
241 ctx->event_mgr.info_handler = info_callback;
242 ctx->event_mgr.error_handler = error_callback;
243 ctx->event_mgr.warning_handler = warning_callback;
244 opj_set_event_mgr((opj_common_ptr)ctx->compress, &ctx->event_mgr, avctx);
249 av_freep(&ctx->compress);
250 av_freep(&avctx->coded_frame);
254 static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
261 const int numcomps = image->numcomps;
263 for (compno = 0; compno < numcomps; ++compno) {
264 if (image->comps[compno].w > frame->linesize[0] / numcomps) {
265 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
270 for (compno = 0; compno < numcomps; ++compno) {
271 for (y = 0; y < avctx->height; ++y) {
272 image_index = y * avctx->width;
273 frame_index = y * frame->linesize[0] + compno;
274 for (x = 0; x < avctx->width; ++x) {
275 image->comps[compno].data[image_index++] = frame->data[0][frame_index];
276 frame_index += numcomps;
285 static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
292 const int numcomps = image->numcomps;
293 uint16_t *frame_ptr = (uint16_t*)frame->data[0];
295 for (compno = 0; compno < numcomps; ++compno) {
296 if (image->comps[compno].w > frame->linesize[0] / numcomps) {
297 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
302 for (compno = 0; compno < numcomps; ++compno) {
303 for (y = 0; y < avctx->height; ++y) {
304 image_index = y * avctx->width;
305 frame_index = y * (frame->linesize[0] / 2) + compno;
306 for (x = 0; x < avctx->width; ++x) {
307 image->comps[compno].data[image_index++] = frame_ptr[frame_index] >> 4;
308 frame_index += numcomps;
316 static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
323 const int numcomps = image->numcomps;
324 uint16_t *frame_ptr = (uint16_t*)frame->data[0];
326 for (compno = 0; compno < numcomps; ++compno) {
327 if (image->comps[compno].w > frame->linesize[0] / numcomps) {
328 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
333 for (compno = 0; compno < numcomps; ++compno) {
334 for (y = 0; y < avctx->height; ++y) {
335 image_index = y * avctx->width;
336 frame_index = y * (frame->linesize[0] / 2) + compno;
337 for (x = 0; x < avctx->width; ++x) {
338 image->comps[compno].data[image_index++] = frame_ptr[frame_index];
339 frame_index += numcomps;
347 static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
356 const int numcomps = image->numcomps;
358 for (compno = 0; compno < numcomps; ++compno) {
359 if (image->comps[compno].w > frame->linesize[compno]) {
360 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
365 for (compno = 0; compno < numcomps; ++compno) {
366 width = avctx->width / image->comps[compno].dx;
367 height = avctx->height / image->comps[compno].dy;
368 for (y = 0; y < height; ++y) {
369 image_index = y * width;
370 frame_index = y * frame->linesize[compno];
371 for (x = 0; x < width; ++x)
372 image->comps[compno].data[image_index++] = frame->data[compno][frame_index++];
379 static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
388 const int numcomps = image->numcomps;
391 for (compno = 0; compno < numcomps; ++compno) {
392 if (image->comps[compno].w > frame->linesize[compno]) {
393 av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
398 for (compno = 0; compno < numcomps; ++compno) {
399 width = avctx->width / image->comps[compno].dx;
400 height = avctx->height / image->comps[compno].dy;
401 frame_ptr = (uint16_t*)frame->data[compno];
402 for (y = 0; y < height; ++y) {
403 image_index = y * width;
404 frame_index = y * (frame->linesize[compno] / 2);
405 for (x = 0; x < width; ++x)
406 image->comps[compno].data[image_index++] = frame_ptr[frame_index++];
413 static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
414 const AVFrame *frame, int *got_packet)
416 LibOpenJPEGContext *ctx = avctx->priv_data;
417 opj_cinfo_t *compress = ctx->compress;
418 opj_image_t *image = ctx->image;
424 // x0, y0 is the top left corner of the image
425 // x1, y1 is the width, height of the reference grid
428 image->x1 = (avctx->width - 1) * ctx->enc_params.subsampling_dx + 1;
429 image->y1 = (avctx->height - 1) * ctx->enc_params.subsampling_dy + 1;
431 switch (avctx->pix_fmt) {
432 case AV_PIX_FMT_RGB24:
433 case AV_PIX_FMT_RGBA:
434 case AV_PIX_FMT_GRAY8A:
435 cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);
437 case AV_PIX_FMT_XYZ12:
438 cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);
440 case AV_PIX_FMT_RGB48:
441 case AV_PIX_FMT_RGBA64:
442 cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);
444 case AV_PIX_FMT_GBR24P:
445 case AV_PIX_FMT_GBRP9:
446 case AV_PIX_FMT_GBRP10:
447 case AV_PIX_FMT_GBRP12:
448 case AV_PIX_FMT_GBRP14:
449 case AV_PIX_FMT_GBRP16:
451 gbrframe.data[0] = frame->data[2]; // swap to be rgb
452 gbrframe.data[1] = frame->data[0];
453 gbrframe.data[2] = frame->data[1];
454 gbrframe.linesize[0] = frame->linesize[2];
455 gbrframe.linesize[1] = frame->linesize[0];
456 gbrframe.linesize[2] = frame->linesize[1];
457 if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {
458 cpyresult = libopenjpeg_copy_unpacked8(avctx, &gbrframe, image);
460 cpyresult = libopenjpeg_copy_unpacked16(avctx, &gbrframe, image);
463 case AV_PIX_FMT_GRAY8:
464 case AV_PIX_FMT_YUV410P:
465 case AV_PIX_FMT_YUV411P:
466 case AV_PIX_FMT_YUV420P:
467 case AV_PIX_FMT_YUV422P:
468 case AV_PIX_FMT_YUV440P:
469 case AV_PIX_FMT_YUV444P:
470 case AV_PIX_FMT_YUVA420P:
471 case AV_PIX_FMT_YUVA422P:
472 case AV_PIX_FMT_YUVA444P:
473 cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);
475 case AV_PIX_FMT_GRAY16:
476 case AV_PIX_FMT_YUV420P9:
477 case AV_PIX_FMT_YUV422P9:
478 case AV_PIX_FMT_YUV444P9:
479 case AV_PIX_FMT_YUVA420P9:
480 case AV_PIX_FMT_YUVA422P9:
481 case AV_PIX_FMT_YUVA444P9:
482 case AV_PIX_FMT_YUV444P10:
483 case AV_PIX_FMT_YUV422P10:
484 case AV_PIX_FMT_YUV420P10:
485 case AV_PIX_FMT_YUVA444P10:
486 case AV_PIX_FMT_YUVA422P10:
487 case AV_PIX_FMT_YUVA420P10:
488 case AV_PIX_FMT_YUV420P12:
489 case AV_PIX_FMT_YUV422P12:
490 case AV_PIX_FMT_YUV444P12:
491 case AV_PIX_FMT_YUV420P14:
492 case AV_PIX_FMT_YUV422P14:
493 case AV_PIX_FMT_YUV444P14:
494 case AV_PIX_FMT_YUV444P16:
495 case AV_PIX_FMT_YUV422P16:
496 case AV_PIX_FMT_YUV420P16:
497 case AV_PIX_FMT_YUVA444P16:
498 case AV_PIX_FMT_YUVA422P16:
499 case AV_PIX_FMT_YUVA420P16:
500 cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);
503 av_log(avctx, AV_LOG_ERROR,
504 "The frame's pixel format '%s' is not supported\n",
505 av_get_pix_fmt_name(avctx->pix_fmt));
506 return AVERROR(EINVAL);
511 av_log(avctx, AV_LOG_ERROR,
512 "Could not copy the frame data to the internal image buffer\n");
516 opj_setup_encoder(compress, &ctx->enc_params, image);
517 stream = opj_cio_open((opj_common_ptr)compress, NULL, 0);
519 av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");
520 return AVERROR(ENOMEM);
523 if (!opj_encode(compress, stream, image, NULL)) {
524 opj_cio_close(stream);
525 av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");
529 len = cio_tell(stream);
530 if ((ret = ff_alloc_packet2(avctx, pkt, len)) < 0) {
531 opj_cio_close(stream);
535 memcpy(pkt->data, stream->buffer, len);
536 pkt->flags |= AV_PKT_FLAG_KEY;
538 opj_cio_close(stream);
542 static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
544 LibOpenJPEGContext *ctx = avctx->priv_data;
546 opj_destroy_compress(ctx->compress);
547 opj_image_destroy(ctx->image);
548 av_freep(&avctx->coded_frame);
552 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
553 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
554 static const AVOption options[] = {
555 { "format", "Codec Format", OFFSET(format), AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2, VE, "format" },
556 { "j2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K }, 0, 0, VE, "format" },
557 { "jp2", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2 }, 0, 0, VE, "format" },
558 { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = STD_RSIZ }, STD_RSIZ, CINEMA4K, VE, "profile" },
559 { "jpeg2000", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = STD_RSIZ }, 0, 0, VE, "profile" },
560 { "cinema2k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K }, 0, 0, VE, "profile" },
561 { "cinema4k", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA4K }, 0, 0, VE, "profile" },
562 { "cinema_mode", "Digital Cinema", OFFSET(cinema_mode), AV_OPT_TYPE_INT, { .i64 = OFF }, OFF, CINEMA4K_24, VE, "cinema_mode" },
563 { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = OFF }, 0, 0, VE, "cinema_mode" },
564 { "2k_24", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_24 }, 0, 0, VE, "cinema_mode" },
565 { "2k_48", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_48 }, 0, 0, VE, "cinema_mode" },
566 { "4k_24", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CINEMA4K_24 }, 0, 0, VE, "cinema_mode" },
567 { "prog_order", "Progression Order", OFFSET(prog_order), AV_OPT_TYPE_INT, { .i64 = LRCP }, LRCP, CPRL, VE, "prog_order" },
568 { "lrcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LRCP }, 0, 0, VE, "prog_order" },
569 { "rlcp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = RLCP }, 0, 0, VE, "prog_order" },
570 { "rpcl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = RPCL }, 0, 0, VE, "prog_order" },
571 { "pcrl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PCRL }, 0, 0, VE, "prog_order" },
572 { "cprl", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CPRL }, 0, 0, VE, "prog_order" },
573 { "numresolution", NULL, OFFSET(numresolution), AV_OPT_TYPE_INT, { .i64 = 6 }, 1, INT_MAX, VE },
574 { "numlayers", NULL, OFFSET(numlayers), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 10, VE },
575 { "disto_alloc", NULL, OFFSET(disto_alloc), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
576 { "fixed_alloc", NULL, OFFSET(fixed_alloc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
577 { "fixed_quality", NULL, OFFSET(fixed_quality), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
581 static const AVClass openjpeg_class = {
582 .class_name = "libopenjpeg",
583 .item_name = av_default_item_name,
585 .version = LIBAVUTIL_VERSION_INT,
588 AVCodec ff_libopenjpeg_encoder = {
589 .name = "libopenjpeg",
590 .type = AVMEDIA_TYPE_VIDEO,
591 .id = AV_CODEC_ID_JPEG2000,
592 .priv_data_size = sizeof(LibOpenJPEGContext),
593 .init = libopenjpeg_encode_init,
594 .encode2 = libopenjpeg_encode_frame,
595 .close = libopenjpeg_encode_close,
597 .pix_fmts = (const enum AVPixelFormat[]) {
598 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64,
600 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
601 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16,
602 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,
603 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,
604 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,
605 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
606 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
607 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
608 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
609 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
610 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
611 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
612 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
616 .long_name = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
617 .priv_class = &openjpeg_class,