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