FFmpeg
libopenjpegdec.c
Go to the documentation of this file.
1 /*
2  * JPEG 2000 decoding support via OpenJPEG
3  * Copyright (c) 2009 Jaikrishnan Menon <realityman@gmx.net>
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 decoder using libopenjpeg
25  */
26 
27 #include "libavutil/common.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixfmt.h"
32 
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "thread.h"
36 
37 #include <openjpeg.h>
38 
39 #define JP2_SIG_TYPE 0x6A502020
40 #define JP2_SIG_VALUE 0x0D0A870A
41 
42 // pix_fmts with lower bpp have to be listed before
43 // similar pix_fmts with higher bpp.
44 #define RGB_PIXEL_FORMATS AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, \
45  AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64
46 
47 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, \
48  AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, \
49  AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16
50 
51 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \
52  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
53  AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
54  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
55  AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \
56  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
57  AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \
58  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \
59  AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
60  AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
61  AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16
62 
63 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
64 
65 static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[] = {
67 };
70 };
71 static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[] = {
73 };
74 static const enum AVPixelFormat libopenjpeg_all_pix_fmts[] = {
76 };
77 
78 typedef struct LibOpenJPEGContext {
79  AVClass *class;
80  opj_dparameters_t dec_params;
81  int lowqual;
83 
84 static void error_callback(const char *msg, void *data)
85 {
86  av_log(data, AV_LOG_ERROR, "%s", msg);
87 }
88 
89 static void warning_callback(const char *msg, void *data)
90 {
91  av_log(data, AV_LOG_WARNING, "%s", msg);
92 }
93 
94 static void info_callback(const char *msg, void *data)
95 {
96  av_log(data, AV_LOG_DEBUG, "%s", msg);
97 }
98 
99 typedef struct BufferReader {
100  int pos;
101  int size;
102  const uint8_t *buffer;
103 } BufferReader;
104 
105 static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)
106 {
107  BufferReader *reader = user_data;
108  int remaining;
109 
110  if (reader->pos == reader->size) {
111  return (OPJ_SIZE_T)-1;
112  }
113  remaining = reader->size - reader->pos;
114  if (nb_bytes > remaining) {
115  nb_bytes = remaining;
116  }
117  memcpy(out_buffer, reader->buffer + reader->pos, nb_bytes);
118  reader->pos += (int)nb_bytes;
119  return nb_bytes;
120 }
121 
122 static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)
123 {
124  BufferReader *reader = user_data;
125  if (nb_bytes < 0) {
126  if (reader->pos == 0) {
127  return (OPJ_SIZE_T)-1;
128  }
129  if (nb_bytes + reader->pos < 0) {
130  nb_bytes = -reader->pos;
131  }
132  } else {
133  int remaining;
134 
135  if (reader->pos == reader->size) {
136  return (OPJ_SIZE_T)-1;
137  }
138  remaining = reader->size - reader->pos;
139  if (nb_bytes > remaining) {
140  nb_bytes = remaining;
141  }
142  }
143  reader->pos += (int)nb_bytes;
144  return nb_bytes;
145 }
146 
147 static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)
148 {
149  BufferReader *reader = user_data;
150  if (nb_bytes < 0 || nb_bytes > reader->size) {
151  return OPJ_FALSE;
152  }
153  reader->pos = (int)nb_bytes;
154  return OPJ_TRUE;
155 }
156 
157 static inline int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
158 {
160  int match = 1;
161 
162  if (desc->nb_components != image->numcomps) {
163  return 0;
164  }
165 
166  switch (desc->nb_components) {
167  case 4:
168  match = match &&
169  desc->comp[3].depth >= image->comps[3].prec &&
170  1 == image->comps[3].dx &&
171  1 == image->comps[3].dy;
172  case 3:
173  match = match &&
174  desc->comp[2].depth >= image->comps[2].prec &&
175  1 << desc->log2_chroma_w == image->comps[2].dx &&
176  1 << desc->log2_chroma_h == image->comps[2].dy;
177  case 2:
178  match = match &&
179  desc->comp[1].depth >= image->comps[1].prec &&
180  1 << desc->log2_chroma_w == image->comps[1].dx &&
181  1 << desc->log2_chroma_h == image->comps[1].dy;
182  case 1:
183  match = match &&
184  desc->comp[0].depth >= image->comps[0].prec &&
185  1 == image->comps[0].dx &&
186  1 == image->comps[0].dy;
187  default:
188  break;
189  }
190 
191  return match;
192 }
193 
194 static inline enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image) {
195  int index;
196  const enum AVPixelFormat *possible_fmts = NULL;
197  int possible_fmts_nb = 0;
198 
199  switch (image->color_space) {
200  case OPJ_CLRSPC_SRGB:
201  possible_fmts = libopenjpeg_rgb_pix_fmts;
202  possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts);
203  break;
204  case OPJ_CLRSPC_GRAY:
205  possible_fmts = libopenjpeg_gray_pix_fmts;
206  possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts);
207  break;
208  case OPJ_CLRSPC_SYCC:
209  possible_fmts = libopenjpeg_yuv_pix_fmts;
210  possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts);
211  break;
212  default:
213  possible_fmts = libopenjpeg_all_pix_fmts;
214  possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts);
215  break;
216  }
217 
218  for (index = 0; index < possible_fmts_nb; ++index)
219  if (libopenjpeg_matches_pix_fmt(image, possible_fmts[index])) {
220  return possible_fmts[index];
221  }
222 
223  return AV_PIX_FMT_NONE;
224 }
225 
227 {
229  int i, component_plane;
230 
231  if (pix_fmt == AV_PIX_FMT_GRAY16)
232  return 0;
233 
234  component_plane = desc->comp[0].plane;
235  for (i = 1; i < desc->nb_components; i++)
236  if (component_plane != desc->comp[i].plane)
237  return 0;
238  return 1;
239 }
240 
241 static inline void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image) {
242  uint8_t *img_ptr;
243  int index, x, y, c;
244  for (y = 0; y < picture->height; y++) {
245  index = y * picture->width;
246  img_ptr = picture->data[0] + y * picture->linesize[0];
247  for (x = 0; x < picture->width; x++, index++)
248  for (c = 0; c < image->numcomps; c++)
249  *img_ptr++ = 0x80 * image->comps[c].sgnd + image->comps[c].data[index];
250  }
251 }
252 
253 static inline void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image) {
254  uint16_t *img_ptr;
256  int index, x, y, c;
257  int adjust[4];
258  for (x = 0; x < image->numcomps; x++)
259  adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
260 
261  for (y = 0; y < picture->height; y++) {
262  index = y * picture->width;
263  img_ptr = (uint16_t *) (picture->data[0] + y * picture->linesize[0]);
264  for (x = 0; x < picture->width; x++, index++)
265  for (c = 0; c < image->numcomps; c++)
266  *img_ptr++ = (1 << image->comps[c].prec - 1) * image->comps[c].sgnd +
267  (unsigned)image->comps[c].data[index] << adjust[c];
268  }
269 }
270 
271 static inline void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image) {
272  int *comp_data;
273  uint8_t *img_ptr;
274  int index, x, y;
275 
276  for (index = 0; index < image->numcomps; index++) {
277  comp_data = image->comps[index].data;
278  for (y = 0; y < image->comps[index].h; y++) {
279  img_ptr = picture->data[index] + y * picture->linesize[index];
280  for (x = 0; x < image->comps[index].w; x++) {
281  *img_ptr = 0x80 * image->comps[index].sgnd + *comp_data;
282  img_ptr++;
283  comp_data++;
284  }
285  }
286  }
287 }
288 
289 static inline void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image) {
290  int *comp_data;
291  uint16_t *img_ptr;
293  int index, x, y;
294  int adjust[4];
295  for (x = 0; x < image->numcomps; x++)
296  adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
297 
298  for (index = 0; index < image->numcomps; index++) {
299  comp_data = image->comps[index].data;
300  for (y = 0; y < image->comps[index].h; y++) {
301  img_ptr = (uint16_t *)(picture->data[index] + y * picture->linesize[index]);
302  for (x = 0; x < image->comps[index].w; x++) {
303  *img_ptr = (1 << image->comps[index].prec - 1) * image->comps[index].sgnd +
304  (unsigned)*comp_data << adjust[index];
305  img_ptr++;
306  comp_data++;
307  }
308  }
309  }
310 }
311 
313 {
314  LibOpenJPEGContext *ctx = avctx->priv_data;
315 
316  opj_set_default_decoder_parameters(&ctx->dec_params);
317  return 0;
318 }
319 
321  void *data, int *got_frame,
322  AVPacket *avpkt)
323 {
324  uint8_t *buf = avpkt->data;
325  int buf_size = avpkt->size;
326  LibOpenJPEGContext *ctx = avctx->priv_data;
327  ThreadFrame frame = { .f = data };
328  AVFrame *picture = data;
329  const AVPixFmtDescriptor *desc;
330  int width, height, ret;
331  int pixel_size = 0;
332  int ispacked = 0;
333  int i;
334  opj_image_t *image = NULL;
335  BufferReader reader = {0, avpkt->size, avpkt->data};
336  opj_codec_t *dec = NULL;
337  opj_stream_t *stream = NULL;
338 
339  *got_frame = 0;
340 
341  // Check if input is a raw jpeg2k codestream or in jp2 wrapping
342  if ((AV_RB32(buf) == 12) &&
343  (AV_RB32(buf + 4) == JP2_SIG_TYPE) &&
344  (AV_RB32(buf + 8) == JP2_SIG_VALUE)) {
345  dec = opj_create_decompress(OPJ_CODEC_JP2);
346  } else {
347  /* If the AVPacket contains a jp2c box, then skip to
348  * the starting byte of the codestream. */
349  if (AV_RB32(buf + 4) == AV_RB32("jp2c"))
350  buf += 8;
351  dec = opj_create_decompress(OPJ_CODEC_J2K);
352  }
353 
354  if (!dec) {
355  av_log(avctx, AV_LOG_ERROR, "Error initializing decoder.\n");
357  goto done;
358  }
359 
360  if (!opj_set_error_handler(dec, error_callback, avctx) ||
361  !opj_set_warning_handler(dec, warning_callback, avctx) ||
362  !opj_set_info_handler(dec, info_callback, avctx)) {
363  av_log(avctx, AV_LOG_ERROR, "Error setting decoder handlers.\n");
365  goto done;
366  }
367 
368  ctx->dec_params.cp_layer = ctx->lowqual;
369  ctx->dec_params.cp_reduce = avctx->lowres;
370 
371  // Tie decoder with decoding parameters
372  opj_setup_decoder(dec, &ctx->dec_params);
373 
374  stream = opj_stream_default_create(OPJ_STREAM_READ);
375 
376  if (!stream) {
377  av_log(avctx, AV_LOG_ERROR,
378  "Codestream could not be opened for reading.\n");
380  goto done;
381  }
382 
383  opj_stream_set_read_function(stream, stream_read);
384  opj_stream_set_skip_function(stream, stream_skip);
385  opj_stream_set_seek_function(stream, stream_seek);
386  opj_stream_set_user_data(stream, &reader, NULL);
387  opj_stream_set_user_data_length(stream, avpkt->size);
388  // Decode the header only.
389  ret = !opj_read_header(stream, dec, &image);
390 
391  if (ret) {
392  av_log(avctx, AV_LOG_ERROR, "Error decoding codestream header.\n");
394  goto done;
395  }
396 
397  width = image->x1 - image->x0;
398  height = image->y1 - image->y0;
399 
400  ret = ff_set_dimensions(avctx, width, height);
401  if (ret < 0)
402  goto done;
403 
404  if (avctx->pix_fmt != AV_PIX_FMT_NONE)
405  if (!libopenjpeg_matches_pix_fmt(image, avctx->pix_fmt))
406  avctx->pix_fmt = AV_PIX_FMT_NONE;
407 
408  if (avctx->pix_fmt == AV_PIX_FMT_NONE)
409  avctx->pix_fmt = libopenjpeg_guess_pix_fmt(image);
410 
411  if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
412  av_log(avctx, AV_LOG_ERROR, "Unable to determine pixel format.\n");
414  goto done;
415  }
416  for (i = 0; i < image->numcomps; i++)
417  if (image->comps[i].prec > avctx->bits_per_raw_sample)
418  avctx->bits_per_raw_sample = image->comps[i].prec;
419 
420  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
421  goto done;
422 
423  ret = !opj_decode(dec, stream, image);
424 
425  if (ret) {
426  av_log(avctx, AV_LOG_ERROR, "Error decoding codestream.\n");
428  goto done;
429  }
430 
431  for (i = 0; i < image->numcomps; i++) {
432  if (!image->comps[i].data) {
433  av_log(avctx, AV_LOG_ERROR,
434  "Image component %d contains no data.\n", i);
436  goto done;
437  }
438  }
439 
440  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
441  pixel_size = desc->comp[0].step;
442  ispacked = libopenjpeg_ispacked(avctx->pix_fmt);
443 
444  switch (pixel_size) {
445  case 1:
446  if (ispacked) {
447  libopenjpeg_copy_to_packed8(picture, image);
448  } else {
449  libopenjpeg_copyto8(picture, image);
450  }
451  break;
452  case 2:
453  if (ispacked) {
454  libopenjpeg_copy_to_packed8(picture, image);
455  } else {
456  libopenjpeg_copyto16(picture, image);
457  }
458  break;
459  case 3:
460  case 4:
461  if (ispacked) {
462  libopenjpeg_copy_to_packed8(picture, image);
463  }
464  break;
465  case 6:
466  case 8:
467  if (ispacked) {
468  libopenjpeg_copy_to_packed16(picture, image);
469  }
470  break;
471  default:
472  avpriv_report_missing_feature(avctx, "Pixel size %d", pixel_size);
474  goto done;
475  }
476 
477  *got_frame = 1;
478  picture->pict_type = AV_PICTURE_TYPE_I;
479  picture->key_frame = 1;
480  ret = buf_size;
481 
482 done:
483  opj_image_destroy(image);
484  opj_stream_destroy(stream);
485  opj_destroy_codec(dec);
486  return ret;
487 }
488 
489 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
490 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
491 
492 static const AVOption options[] = {
493  { "lowqual", "Limit the number of layers used for decoding",
494  OFFSET(lowqual), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
495  { NULL },
496 };
497 
498 static const AVClass openjpeg_class = {
499  .class_name = "libopenjpeg",
500  .item_name = av_default_item_name,
501  .option = options,
502  .version = LIBAVUTIL_VERSION_INT,
503 };
504 
506  .name = "libopenjpeg",
507  .long_name = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
508  .type = AVMEDIA_TYPE_VIDEO,
509  .id = AV_CODEC_ID_JPEG2000,
510  .priv_data_size = sizeof(LibOpenJPEGContext),
514  .max_lowres = 31,
515  .priv_class = &openjpeg_class,
516  .wrapper_name = "libopenjpeg",
517 };
AVCodec
AVCodec.
Definition: codec.h:197
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
opt.h
libopenjpeg_copy_to_packed8
static void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image)
Definition: libopenjpegdec.c:241
ff_libopenjpeg_decoder
const AVCodec ff_libopenjpeg_decoder
Definition: libopenjpegdec.c:505
BufferReader::size
int size
Definition: libopenjpegdec.c:101
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
index
fg index
Definition: ffmpeg_filter.c:168
AVFrame::width
int width
Definition: frame.h:361
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
AVOption
AVOption.
Definition: opt.h:248
libopenjpeg_yuv_pix_fmts
static enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]
Definition: libopenjpegdec.c:71
BufferReader::buffer
const uint8_t * buffer
Definition: libopenjpegdec.c:102
data
const char data[16]
Definition: mxf.c:142
libopenjpeg_gray_pix_fmts
static enum AVPixelFormat libopenjpeg_gray_pix_fmts[]
Definition: libopenjpegdec.c:68
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
XYZ_PIXEL_FORMATS
#define XYZ_PIXEL_FORMATS
Definition: libopenjpegdec.c:63
libopenjpeg_decode_init
static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)
Definition: libopenjpegdec.c:312
options
static const AVOption options[]
Definition: libopenjpegdec.c:492
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
warning_callback
static void warning_callback(const char *msg, void *data)
Definition: libopenjpegdec.c:89
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
stream_skip
static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)
Definition: libopenjpegdec.c:122
intreadwrite.h
libopenjpeg_rgb_pix_fmts
static enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]
Definition: libopenjpegdec.c:65
VD
#define VD
Definition: libopenjpegdec.c:490
adjust
static int adjust(int x, int size)
Definition: mobiclip.c:515
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1531
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
ctx
AVFormatContext * ctx
Definition: movenc.c:48
libopenjpeg_ispacked
static int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)
Definition: libopenjpegdec.c:226
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
GRAY_PIXEL_FORMATS
#define GRAY_PIXEL_FORMATS
Definition: libopenjpegdec.c:47
info_callback
static void info_callback(const char *msg, void *data)
Definition: libopenjpegdec.c:94
RGB_PIXEL_FORMATS
#define RGB_PIXEL_FORMATS
Definition: libopenjpegdec.c:44
libopenjpeg_all_pix_fmts
static enum AVPixelFormat libopenjpeg_all_pix_fmts[]
Definition: libopenjpegdec.c:74
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
LibOpenJPEGContext::lowqual
int lowqual
Definition: libopenjpegdec.c:81
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
LibOpenJPEGContext
Definition: libopenjpegdec.c:78
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1538
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
openjpeg_class
static const AVClass openjpeg_class
Definition: libopenjpegdec.c:498
stream_read
static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)
Definition: libopenjpegdec.c:105
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
libopenjpeg_copy_to_packed16
static void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image)
Definition: libopenjpegdec.c:253
user_data
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
Definition: cbs_mpeg2_syntax_template.c:59
libopenjpeg_decode_frame
static int libopenjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: libopenjpegdec.c:320
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
i
int i
Definition: input.c:407
libopenjpeg_copyto8
static void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image)
Definition: libopenjpegdec.c:271
LibOpenJPEGContext::dec_params
opj_dparameters_t dec_params
Definition: libopenjpegdec.c:80
libopenjpeg_guess_pix_fmt
static enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image)
Definition: libopenjpegdec.c:194
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:137
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
avcodec.h
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
BufferReader::pos
int pos
Definition: libopenjpegdec.c:100
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AVFrame::height
int height
Definition: frame.h:361
JP2_SIG_TYPE
#define JP2_SIG_TYPE
Definition: libopenjpegdec.c:39
ThreadFrame
Definition: thread.h:34
libopenjpeg_matches_pix_fmt
static int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
Definition: libopenjpegdec.c:157
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
error_callback
static void error_callback(const char *msg, void *data)
Definition: libopenjpegdec.c:84
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:84
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
BufferReader
Definition: libopenjpegdec.c:99
stream_seek
static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)
Definition: libopenjpegdec.c:147
OFFSET
#define OFFSET(x)
Definition: libopenjpegdec.c:489
int
int
Definition: ffmpeg_filter.c:156
YUV_PIXEL_FORMATS
#define YUV_PIXEL_FORMATS
Definition: libopenjpegdec.c:51
libopenjpeg_copyto16
static void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image)
Definition: libopenjpegdec.c:289
JP2_SIG_VALUE
#define JP2_SIG_VALUE
Definition: libopenjpegdec.c:40