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