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