29 #include "libavutil/common.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/pixfmt.h"
33 #include "libavutil/opt.h"
37 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
38 # include <openjpeg-1.5/openjpeg.h>
40 # include <openjpeg.h>
43 #define JP2_SIG_TYPE 0x6A502020
44 #define JP2_SIG_VALUE 0x0D0A870A
48 #define RGB_PIXEL_FORMATS AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
49 #define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16
50 #define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
51 AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
52 AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
53 AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
54 AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
55 AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
56 AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
57 AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
58 AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
59 AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
60 AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
62 #define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
88 case 4: match = match && desc->
comp[3].
depth_minus1 + 1 >= image->comps[3].prec &&
89 1 == image->comps[3].dx &&
90 1 == image->comps[3].dy;
91 case 3: match = match && desc->
comp[2].
depth_minus1 + 1 >= image->comps[2].prec &&
94 case 2: match = match && desc->
comp[1].
depth_minus1 + 1 >= image->comps[1].prec &&
97 case 1: match = match && desc->
comp[0].
depth_minus1 + 1 >= image->comps[0].prec &&
98 1 == image->comps[0].dx &&
99 1 == image->comps[0].dy;
110 int possible_fmts_nb = 0;
112 switch (image->color_space) {
131 for (index = 0; index < possible_fmts_nb; ++
index) {
133 return possible_fmts[
index];
143 int i, component_plane;
150 if (component_plane != desc->
comp[i].
plane)
159 for (y = 0; y < picture->
height; y++) {
160 index = y*picture->
width;
162 for (x = 0; x < picture->
width; x++, index++) {
163 for (c = 0; c < image->numcomps; c++) {
164 *img_ptr++ = image->comps[
c].data[
index];
174 for (x = 0; x < image->numcomps; x++)
175 adjust[x] =
FFMAX(
FFMIN(16 - image->comps[x].prec, 8), 0);
177 for (y = 0; y < picture->
height; y++) {
178 index = y*picture->
width;
179 img_ptr = (uint16_t*) (picture->
data[0] + y*picture->
linesize[0]);
180 for (x = 0; x < picture->
width; x++, index++) {
181 for (c = 0; c < image->numcomps; c++) {
182 *img_ptr++ = image->comps[
c].data[
index] << adjust[
c];
193 for (index = 0; index < image->numcomps; index++) {
194 comp_data = image->comps[
index].data;
195 for (y = 0; y < image->comps[
index].h; y++) {
197 for (x = 0; x < image->comps[
index].w; x++) {
198 *img_ptr = (
uint8_t) *comp_data;
211 for (x = 0; x < image->numcomps; x++)
212 adjust[x] =
FFMAX(
FFMIN(16 - image->comps[x].prec, 8), 0);
214 for (index = 0; index < image->numcomps; index++) {
215 comp_data = image->comps[
index].data;
216 for (y = 0; y < image->comps[
index].h; y++) {
217 img_ptr = (uint16_t*) (picture->
data[index] + y * picture->
linesize[index]);
218 for (x = 0; x < image->comps[
index].w; x++) {
219 *img_ptr = *comp_data << adjust[
index];
231 opj_set_default_decoder_parameters(&ctx->
dec_params);
236 void *
data,
int *got_frame,
240 int buf_size = avpkt->
size;
259 dec = opj_create_decompress(CODEC_JP2);
265 dec = opj_create_decompress(CODEC_J2K);
272 opj_set_event_mgr((opj_common_ptr)dec, NULL, NULL);
273 ctx->
dec_params.cp_limit_decoding = LIMIT_TO_MAIN_HEADER;
277 stream = opj_cio_open((opj_common_ptr)dec, buf, buf_size);
281 "Codestream could not be opened for reading.\n");
282 opj_destroy_decompress(dec);
287 image = opj_decode_with_info(dec, stream, NULL);
288 opj_cio_close(stream);
292 opj_destroy_decompress(dec);
296 width = image->x1 - image->x0;
297 height = image->y1 - image->y0;
301 "%dx%d dimension invalid.\n", width, height);
318 for (i = 0; i < image->numcomps; i++)
325 ctx->
dec_params.cp_limit_decoding = NO_LIMITATION;
329 stream = opj_cio_open((opj_common_ptr)dec, buf, buf_size);
332 "Codestream could not be opened for reading.\n");
336 opj_image_destroy(image);
338 image = opj_decode_with_info(dec, stream, NULL);
339 opj_cio_close(stream);
350 switch (pixel_size) {
386 opj_image_destroy(image);
387 opj_destroy_decompress(dec);
391 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
392 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
395 {
"lowqual",
"Limit the number of layers used for decoding",
OFFSET(lowqual),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VD },
407 .
name =
"libopenjpeg",
416 .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)
static int libopenjpeg_ispacked(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
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.
const char * av_default_item_name(void *ctx)
Return the context 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...
#define XYZ_PIXEL_FORMATS
Multithreading support functions.
const char * name
Name of the codec implementation.
static av_cold int libopenjpeg_decode_init(AVCodecContext *avctx)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
enum AVPixelFormat pix_fmt
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
const OptionDef options[]
static void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image)
#define AV_PIX_FMT_GRAY16
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. ...
static enum AVPixelFormat libopenjpeg_all_pix_fmts[]
Libavcodec external API header.
AVPixelFormat
Pixel format.
static void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image)
#define RGB_PIXEL_FORMATS
#define FF_ARRAY_ELEMS(a)
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
uint8_t nb_components
The number of components each pixel has, (1-4)
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
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)
static enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]
uint16_t step_minus1
Number of elements between 2 horizontally consecutive pixels minus 1.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
uint16_t plane
which of the 4 planes contains the component
#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)
opj_dparameters_t dec_params
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
AVCodec ff_libopenjpeg_decoder
This structure stores compressed data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define GRAY_PIXEL_FORMATS