39 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
40 # include <openjpeg-1.5/openjpeg.h>
42 # include <openjpeg.h>
45 #define JP2_SIG_TYPE 0x6A502020
46 #define JP2_SIG_VALUE 0x0D0A870A
50 #define RGB_PIXEL_FORMATS AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, \
51 AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64
53 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8, \
54 AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16
56 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \
57 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
58 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
59 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
60 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \
61 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
62 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \
63 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \
64 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
65 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
66 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16
68 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
118 1 == image->comps[3].dx &&
119 1 == image->comps[3].dy;
133 1 == image->comps[0].dx &&
134 1 == image->comps[0].dy;
145 int possible_fmts_nb = 0;
147 switch (image->color_space) {
166 for (index = 0; index < possible_fmts_nb; ++
index)
168 return possible_fmts[
index];
177 int i, component_plane;
184 if (component_plane != desc->
comp[i].
plane)
192 for (y = 0; y < picture->
height; y++) {
193 index = y * picture->
width;
195 for (x = 0; x < picture->
width; x++, index++)
196 for (c = 0; c < image->numcomps; c++)
197 *img_ptr++ = 0x80 * image->comps[c].sgnd + image->comps[c].data[index];
206 for (x = 0; x < image->numcomps; x++)
209 for (y = 0; y < picture->
height; y++) {
210 index = y * picture->
width;
211 img_ptr = (uint16_t *) (picture->
data[0] + y * picture->
linesize[0]);
212 for (x = 0; x < picture->
width; x++, index++)
213 for (c = 0; c < image->numcomps; c++)
214 *img_ptr++ = (1 << image->comps[c].prec - 1) * image->comps[
c].sgnd +
215 (unsigned)image->comps[c].data[index] << adjust[c];
224 for (index = 0; index < image->numcomps; index++) {
225 comp_data = image->comps[
index].data;
226 for (y = 0; y < image->comps[
index].h; y++) {
228 for (x = 0; x < image->comps[
index].w; x++) {
229 *img_ptr = 0x80 * image->comps[
index].sgnd + *comp_data;
243 for (x = 0; x < image->numcomps; x++)
246 for (index = 0; index < image->numcomps; index++) {
247 comp_data = image->comps[
index].data;
248 for (y = 0; y < image->comps[
index].h; y++) {
249 img_ptr = (uint16_t *)(picture->
data[index] + y * picture->
linesize[index]);
250 for (x = 0; x < image->comps[
index].w; x++) {
251 *img_ptr = (1 << image->comps[
index].prec - 1) * image->comps[index].sgnd +
252 (
unsigned)*comp_data << adjust[
index];
264 opj_set_default_decoder_parameters(&ctx->
dec_params);
269 void *
data,
int *got_frame,
273 int buf_size = avpkt->
size;
292 dec = opj_create_decompress(CODEC_JP2);
298 dec = opj_create_decompress(CODEC_J2K);
309 opj_set_event_mgr((opj_common_ptr) dec, &ctx->
event_mgr, avctx);
310 ctx->
dec_params.cp_limit_decoding = LIMIT_TO_MAIN_HEADER;
314 stream = opj_cio_open((opj_common_ptr) dec, buf, buf_size);
318 "Codestream could not be opened for reading.\n");
319 opj_destroy_decompress(dec);
324 image = opj_decode_with_info(dec, stream,
NULL);
325 opj_cio_close(stream);
329 opj_destroy_decompress(dec);
333 width = image->x1 - image->x0;
334 height = image->y1 - image->y0;
351 for (i = 0; i < image->numcomps; i++)
358 ctx->
dec_params.cp_limit_decoding = NO_LIMITATION;
362 stream = opj_cio_open((opj_common_ptr) dec, buf, buf_size);
365 "Codestream could not be opened for reading.\n");
370 opj_image_destroy(image);
372 image = opj_decode_with_info(dec, stream,
NULL);
373 opj_cio_close(stream);
381 for (i = 0; i < image->numcomps; i++) {
382 if (!image->comps[i].data) {
384 "Image component %d contains no data.\n", i);
394 switch (pixel_size) {
431 opj_image_destroy(image);
432 opj_destroy_decompress(dec);
438 const char *
version = opj_version();
441 if (sscanf(version,
"%d.%d", &major, &minor) == 2 && 1000*major + minor <= 1003)
445 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
446 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
449 {
"lowqual",
"Limit the number of layers used for decoding",
462 .
name =
"libopenjpeg",
471 .priv_class = &openjpeg_class,
static void libopenjpeg_copy_to_packed16(AVFrame *picture, opj_image_t *image)
static int libopenjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static enum AVPixelFormat pix_fmt
static int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
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.
static av_cold int init(AVCodecContext *avctx)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define FF_ARRAY_ELEMS(a)
static const AVClass openjpeg_class
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static enum AVPixelFormat libopenjpeg_gray_pix_fmts[]
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
uint16_t shift
Number of least significant bits that must be shifted away to get the value.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define XYZ_PIXEL_FORMATS
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
static av_cold void init_static_data(void)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
static void libopenjpeg_copyto8(AVFrame *picture, opj_image_t *image)
#define YUV_PIXEL_FORMATS
static void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image)
uint16_t depth_minus1
Number of bits in the component minus 1.
int width
width and height of the video frame
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int capabilities
Codec capabilities.
static enum AVPixelFormat libopenjpeg_all_pix_fmts[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const char * name
Name of the codec implementation.
Libavcodec external API header.
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)
#define AV_PIX_FMT_GRAY16
static enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
BYTE int const BYTE int int int height
Describe the class of an AVClass context structure.
static enum AVPixelFormat libopenjpeg_guess_pix_fmt(const opj_image_t *image)
opj_event_mgr_t event_mgr
static enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]
uint16_t step_minus1
Number of elements between 2 horizontally consecutive pixels minus 1.
static av_cold void libopenjpeg_static_init(AVCodec *codec)
static void info_callback(const char *msg, void *data)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
uint16_t plane
Which of the 4 planes contains the component.
common internal api header.
common internal and external API header
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
static int libopenjpeg_matches_pix_fmt(const opj_image_t *image, enum AVPixelFormat pix_fmt)
#define CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
static const AVOption options[]
static void error_callback(const char *msg, void *data)
opj_dparameters_t dec_params
AVCodec ff_libopenjpeg_decoder
AVPixelFormat
Pixel format.
This structure stores compressed data.
#define GRAY_PIXEL_FORMATS