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>
47 opj_cparameters_t enc_params
;
48 opj_cinfo_t
*compress
;
49 opj_event_mgr_t event_mgr
;
61 static void error_callback(const char *msg
, void *data
)
63 av_log(data
, AV_LOG_ERROR
, "%s\n", msg
);
66 static void warning_callback(const char *msg
, void *data
)
68 av_log(data
, AV_LOG_WARNING
, "%s\n", msg
);
71 static void info_callback(const char *msg
, void *data
)
73 av_log(data
, AV_LOG_DEBUG
, "%s\n", msg
);
76 static opj_image_t
*mj2_create_image(AVCodecContext
*avctx
, opj_cparameters_t
*parameters
)
78 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(avctx
->pix_fmt
);
79 opj_image_cmptparm_t cmptparm
[4] = {{0}};
85 OPJ_COLOR_SPACE color_space
= CLRSPC_UNKNOWN
;
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
;
92 numcomps
= desc
->nb_components
;
94 switch (avctx
->pix_fmt
) {
95 case AV_PIX_FMT_GRAY8
:
97 case AV_PIX_FMT_GRAY16
:
98 color_space
= CLRSPC_GRAY
;
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
;
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
;
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
));
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
];
165 img
= opj_image_create(numcomps
, cmptparm
, color_space
);
167 // x0, y0 is the top left corner of the image
168 // x1, y1 is the width, height of the reference grid
171 img
->x1
= (avctx
->width
- 1) * parameters
->subsampling_dx
+ 1;
172 img
->y1
= (avctx
->height
- 1) * parameters
->subsampling_dy
+ 1;
177 static av_cold
int libopenjpeg_encode_init(AVCodecContext
*avctx
)
179 LibOpenJPEGContext
*ctx
= avctx
->priv_data
;
180 int err
= AVERROR(ENOMEM
);
182 opj_set_default_encoder_parameters(&ctx
->enc_params
);
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;
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;
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;
214 ctx
->enc_params
.roi_compno
= -1;
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
;
220 ctx
->enc_params
.tp_flag
= 'C';
221 ctx
->enc_params
.tp_on
= 1;
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
);
230 ctx
->image
= mj2_create_image(avctx
, &ctx
->enc_params
);
232 av_log(avctx
, AV_LOG_ERROR
, "Error creating the mj2 image\n");
233 err
= AVERROR(EINVAL
);
236 opj_setup_encoder(ctx
->compress
, &ctx
->enc_params
, ctx
->image
);
238 ctx
->stream
= opj_cio_open((opj_common_ptr
) ctx
->compress
, NULL
, 0);
240 av_log(avctx
, AV_LOG_ERROR
, "Error creating the cio stream\n");
241 err
= AVERROR(ENOMEM
);
245 avctx
->coded_frame
= av_frame_alloc();
246 if (!avctx
->coded_frame
) {
247 av_log(avctx
, AV_LOG_ERROR
, "Error allocating coded frame\n");
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
);
260 opj_cio_close(ctx
->stream
);
262 opj_destroy_compress(ctx
->compress
);
263 ctx
->compress
= NULL
;
264 opj_image_destroy(ctx
->image
);
266 av_freep(&avctx
->coded_frame
);
270 static int libopenjpeg_copy_packed8(AVCodecContext
*avctx
, const AVFrame
*frame
, opj_image_t
*image
)
277 const int numcomps
= image
->numcomps
;
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");
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
;
294 for (; x
< image
->comps
[compno
].w
; ++x
) {
295 image_line
[x
] = image_line
[x
- 1];
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
];
310 static int libopenjpeg_copy_packed12(AVCodecContext
*avctx
, const AVFrame
*frame
, opj_image_t
*image
)
316 const int numcomps
= image
->numcomps
;
317 uint16_t *frame_ptr
= (uint16_t *)frame
->data
[0];
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");
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
;
334 for (; x
< image
->comps
[compno
].w
; ++x
) {
335 image_line
[x
] = image_line
[x
- 1];
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
];
349 static int libopenjpeg_copy_packed16(AVCodecContext
*avctx
, const AVFrame
*frame
, opj_image_t
*image
)
356 const int numcomps
= image
->numcomps
;
357 uint16_t *frame_ptr
= (uint16_t*)frame
->data
[0];
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");
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
;
374 for (; x
< image
->comps
[compno
].w
; ++x
) {
375 image_line
[x
] = image_line
[x
- 1];
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
];
389 static int libopenjpeg_copy_unpacked8(AVCodecContext
*avctx
, const AVFrame
*frame
, opj_image_t
*image
)
398 const int numcomps
= image
->numcomps
;
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");
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];
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
];
430 static int libopenjpeg_copy_unpacked16(AVCodecContext
*avctx
, const AVFrame
*frame
, opj_image_t
*image
)
439 const int numcomps
= image
->numcomps
;
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");
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];
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
];
473 static int libopenjpeg_encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
474 const AVFrame
*frame
, int *got_packet
)
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
;
484 switch (avctx
->pix_fmt
) {
485 case AV_PIX_FMT_RGB24
:
486 case AV_PIX_FMT_RGBA
:
488 cpyresult
= libopenjpeg_copy_packed8(avctx
, frame
, image
);
490 case AV_PIX_FMT_XYZ12
:
491 cpyresult
= libopenjpeg_copy_packed12(avctx
, frame
, image
);
493 case AV_PIX_FMT_RGB48
:
494 case AV_PIX_FMT_RGBA64
:
495 cpyresult
= libopenjpeg_copy_packed16(avctx
, frame
, image
);
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
);
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
);
515 cpyresult
= libopenjpeg_copy_unpacked16(avctx
, gbrframe
, image
);
517 av_frame_free(&gbrframe
);
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
);
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
);
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
);
567 av_log(avctx
, AV_LOG_ERROR
,
568 "Could not copy the frame data to the internal image buffer\n");
573 if (!opj_encode(compress
, stream
, image
, NULL
)) {
574 av_log(avctx
, AV_LOG_ERROR
, "Error during the opj encode\n");
578 len
= cio_tell(stream
);
579 if ((ret
= ff_alloc_packet2(avctx
, pkt
, len
)) < 0) {
583 memcpy(pkt
->data
, stream
->buffer
, len
);
584 pkt
->flags
|= AV_PKT_FLAG_KEY
;
589 static av_cold
int libopenjpeg_encode_close(AVCodecContext
*avctx
)
591 LibOpenJPEGContext
*ctx
= avctx
->priv_data
;
593 opj_cio_close(ctx
->stream
);
595 opj_destroy_compress(ctx
->compress
);
596 ctx
->compress
= NULL
;
597 opj_image_destroy(ctx
->image
);
599 av_freep(&avctx
->coded_frame
);
603 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
604 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
605 static 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
},
632 static const AVClass openjpeg_class
= {
633 .class_name
= "libopenjpeg",
634 .item_name
= av_default_item_name
,
636 .version
= LIBAVUTIL_VERSION_INT
,
639 AVCodec 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_YA8
, 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
,
668 .priv_class
= &openjpeg_class
,