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 {
159  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
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 {
228  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
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");
356  ret = AVERROR_EXTERNAL;
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");
364  ret = AVERROR_EXTERNAL;
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");
379  ret = AVERROR_EXTERNAL;
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");
393  ret = AVERROR_EXTERNAL;
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");
413  ret = AVERROR_UNKNOWN;
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");
427  ret = AVERROR_EXTERNAL;
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);
435  ret = AVERROR_INVALIDDATA;
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);
473  ret = AVERROR_PATCHWELCOME;
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 };
static void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image)
int plane
Which of the 4 planes contains the component.
Definition: pixdesc.h:35
static int libopenjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
static int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:104
const char * desc
Definition: nvenc.c:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1483
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1780
static const AVClass openjpeg_class
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2801
static enum AVPixelFormat libopenjpeg_gray_pix_fmts[]
#define JP2_SIG_TYPE
AVCodec.
Definition: avcodec.h:3494
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
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
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
#define XYZ_PIXEL_FORMATS
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
Multithreading support functions.
static void warning_callback(const char *msg, void *data)
static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)
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:87
#define height
uint8_t * data
Definition: avcodec.h:1482
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2809
static void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image)
#define YUV_PIXEL_FORMATS
#define av_log(a,...)
static void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image)
static OPJ_OFF_T stream_skip(OPJ_OFF_T nb_bytes, void *user_data)
#define JP2_SIG_VALUE
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVS_Value void * user_data
Definition: avisynth_c.h:775
static enum AVPixelFormat libopenjpeg_all_pix_fmts[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * name
Name of the codec implementation.
Definition: avcodec.h:3501
#define FFMAX(a, b)
Definition: common.h:94
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1042
static void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image)
#define RGB_PIXEL_FORMATS
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
#define FFMIN(a, b)
Definition: common.h:96
#define width
static OPJ_SIZE_T stream_read(void *out_buffer, OPJ_SIZE_T nb_bytes, void *user_data)
AVFormatContext * ctx
Definition: movenc.c:48
static enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]
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
#define FF_ARRAY_ELEMS(a)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1570
void * buf
Definition: avisynth_c.h:766
Describe the class of an AVClass context structure.
Definition: log.h:67
static enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image)
int index
Definition: gxfenc.c:89
static enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]
#define VD
int shift
Number of least significant bits that must be shifted away to get the value.
Definition: pixdesc.h:53
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static void info_callback(const char *msg, void *data)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int
const uint8_t * buffer
common internal api header.
common internal and external API header
static int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:1597
pixel format definitions
static const AVOption options[]
static void error_callback(const char *msg, void *data)
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
opj_dparameters_t dec_params
int height
Definition: frame.h:353
AVCodec ff_libopenjpeg_decoder
static OPJ_BOOL stream_seek(OPJ_OFF_T nb_bytes, void *user_data)
#define OFFSET(x)
int depth
Number of bits in the component.
Definition: pixdesc.h:58
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1459
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:986
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:41
#define GRAY_PIXEL_FORMATS