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