37 #if HAVE_OPENJPEG_1_5_OPENJPEG_H
38 # include <openjpeg-1.5/openjpeg.h>
40 # include <openjpeg.h>
87 p->image_offset_x0 = 0;
88 p->image_offset_y0 = 0;
102 p->subsampling_dx = 1;
103 p->subsampling_dy = 1;
114 opj_image_cmptparm_t cmptparm[4] = {{0}};
120 OPJ_COLOR_SPACE color_space = CLRSPC_UNKNOWN;
122 sub_dx[0] = sub_dx[3] = 1;
123 sub_dy[0] = sub_dy[3] = 1;
134 color_space = CLRSPC_GRAY;
147 color_space = CLRSPC_SRGB;
182 color_space = CLRSPC_SYCC;
186 "The requested pixel format '%s' is not supported\n",
191 for (i = 0; i < numcomps; i++) {
194 cmptparm[i].sgnd = 0;
195 cmptparm[i].dx = sub_dx[i];
196 cmptparm[i].dy = sub_dy[i];
197 cmptparm[i].w = (avctx->
width + sub_dx[i] - 1) / sub_dx[i];
198 cmptparm[i].h = (avctx->
height + sub_dy[i] - 1) / sub_dy[i];
201 img = opj_image_create(numcomps, cmptparm, color_space);
207 img->x1 = (avctx->
width - 1) * parameters->subsampling_dx + 1;
208 img->y1 = (avctx->
height - 1) * parameters->subsampling_dy + 1;
218 opj_set_default_encoder_parameters(&ctx->
enc_params);
251 opj_image_destroy(ctx->
image);
264 const int numcomps = image->numcomps;
266 for (compno = 0; compno < numcomps; ++compno) {
267 if (image->comps[compno].w > frame->
linesize[0] / numcomps) {
273 for (compno = 0; compno < numcomps; ++compno) {
274 for (y = 0; y < avctx->
height; ++
y) {
275 image_line = image->comps[compno].data + y * image->comps[compno].w;
276 frame_index = y * frame->
linesize[0] + compno;
277 for (x = 0; x < avctx->
width; ++x) {
278 image_line[x] = frame->
data[0][frame_index];
279 frame_index += numcomps;
281 for (; x < image->comps[compno].w; ++x) {
282 image_line[x] = image_line[x - 1];
285 for (; y < image->comps[compno].h; ++
y) {
286 image_line = image->comps[compno].data + y * image->comps[compno].w;
287 for (x = 0; x < image->comps[compno].w; ++x) {
288 image_line[x] = image_line[x - image->comps[compno].w];
303 const int numcomps = image->numcomps;
304 uint16_t *frame_ptr = (uint16_t *)frame->
data[0];
306 for (compno = 0; compno < numcomps; ++compno) {
307 if (image->comps[compno].w > frame->
linesize[0] / numcomps) {
313 for (compno = 0; compno < numcomps; ++compno) {
314 for (y = 0; y < avctx->
height; ++
y) {
315 image_line = image->comps[compno].data + y * image->comps[compno].w;
316 frame_index = y * (frame->
linesize[0] / 2) + compno;
317 for (x = 0; x < avctx->
width; ++x) {
318 image_line[x] = frame_ptr[frame_index] >> 4;
319 frame_index += numcomps;
321 for (; x < image->comps[compno].w; ++x) {
322 image_line[x] = image_line[x - 1];
325 for (; y < image->comps[compno].h; ++
y) {
326 image_line = image->comps[compno].data + y * image->comps[compno].w;
327 for (x = 0; x < image->comps[compno].w; ++x) {
328 image_line[x] = image_line[x - image->comps[compno].w];
343 const int numcomps = image->numcomps;
344 uint16_t *frame_ptr = (uint16_t*)frame->
data[0];
346 for (compno = 0; compno < numcomps; ++compno) {
347 if (image->comps[compno].w > frame->
linesize[0] / numcomps) {
353 for (compno = 0; compno < numcomps; ++compno) {
354 for (y = 0; y < avctx->
height; ++
y) {
355 image_line = image->comps[compno].data + y * image->comps[compno].w;
356 frame_index = y * (frame->
linesize[0] / 2) + compno;
357 for (x = 0; x < avctx->
width; ++x) {
358 image_line[x] = frame_ptr[frame_index];
359 frame_index += numcomps;
361 for (; x < image->comps[compno].w; ++x) {
362 image_line[x] = image_line[x - 1];
365 for (; y < image->comps[compno].h; ++
y) {
366 image_line = image->comps[compno].data + y * image->comps[compno].w;
367 for (x = 0; x < image->comps[compno].w; ++x) {
368 image_line[x] = image_line[x - image->comps[compno].w];
385 const int numcomps = image->numcomps;
387 for (compno = 0; compno < numcomps; ++compno) {
388 if (image->comps[compno].w > frame->
linesize[compno]) {
394 for (compno = 0; compno < numcomps; ++compno) {
395 width = avctx->
width / image->comps[compno].dx;
396 height = avctx->
height / image->comps[compno].dy;
398 image_line = image->comps[compno].data + y * image->comps[compno].w;
399 frame_index = y * frame->
linesize[compno];
400 for (x = 0; x <
width; ++x)
401 image_line[x] = frame->
data[compno][frame_index++];
402 for (; x < image->comps[compno].w; ++x) {
403 image_line[x] = image_line[x - 1];
406 for (; y < image->comps[compno].h; ++
y) {
407 image_line = image->comps[compno].data + y * image->comps[compno].w;
408 for (x = 0; x < image->comps[compno].w; ++x) {
409 image_line[x] = image_line[x - image->comps[compno].w];
426 const int numcomps = image->numcomps;
429 for (compno = 0; compno < numcomps; ++compno) {
430 if (image->comps[compno].w > frame->
linesize[compno]) {
436 for (compno = 0; compno < numcomps; ++compno) {
437 width = avctx->
width / image->comps[compno].dx;
438 height = avctx->
height / image->comps[compno].dy;
439 frame_ptr = (uint16_t *)frame->
data[compno];
441 image_line = image->comps[compno].data + y * image->comps[compno].w;
442 frame_index = y * (frame->
linesize[compno] / 2);
443 for (x = 0; x <
width; ++x)
444 image_line[x] = frame_ptr[frame_index++];
445 for (; x < image->comps[compno].w; ++x) {
446 image_line[x] = image_line[x - 1];
449 for (; y < image->comps[compno].h; ++
y) {
450 image_line = image->comps[compno].data + y * image->comps[compno].w;
451 for (x = 0; x < image->comps[compno].w; ++x) {
452 image_line[x] = image_line[x - image->comps[compno].w];
464 opj_image_t *image = ctx->
image;
465 opj_cinfo_t *compress =
NULL;
466 opj_cio_t *stream =
NULL;
548 "The frame's pixel format '%s' is not supported\n",
556 "Could not copy the frame data to the internal image buffer\n");
560 compress = opj_create_compress(ctx->
format);
566 opj_setup_encoder(compress, &ctx->
enc_params, image);
568 stream = opj_cio_open((opj_common_ptr) compress,
NULL, 0);
574 memset(&ctx->
event_mgr, 0,
sizeof(opj_event_mgr_t));
578 opj_set_event_mgr((opj_common_ptr) compress, &ctx->
event_mgr, avctx);
580 if (!opj_encode(compress, stream, image,
NULL)) {
585 len = cio_tell(stream);
590 memcpy(pkt->
data, stream->buffer, len);
594 opj_cio_close(stream);
596 opj_destroy_compress(compress);
606 opj_image_destroy(ctx->
image);
612 #define OFFSET(x) offsetof(LibOpenJPEGContext, x)
613 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
615 {
"format",
"Codec Format",
OFFSET(format),
AV_OPT_TYPE_INT, { .i64 = CODEC_JP2 }, CODEC_J2K, CODEC_JP2,
VE,
"format" },
622 {
"cinema_mode",
"Digital Cinema",
OFFSET(cinema_mode),
AV_OPT_TYPE_INT, { .i64 = OFF }, OFF, CINEMA4K_24,
VE,
"cinema_mode" },
627 {
"prog_order",
"Progression Order",
OFFSET(prog_order),
AV_OPT_TYPE_INT, { .i64 = LRCP }, LRCP, CPRL,
VE,
"prog_order" },
649 .
name =
"libopenjpeg",
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
#define AV_PIX_FMT_YUVA422P16
static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
#define AV_PIX_FMT_YUVA422P9
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_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
packed RGB 8:8:8, 24bpp, RGBRGB...
AVFrame * coded_frame
the picture in the bitstream
static av_cold int init(AVCodecContext *avctx)
#define AV_PIX_FMT_RGBA64
AVCodec ff_libopenjpeg_encoder
#define AV_PIX_FMT_GBRP10
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static const AVClass openjpeg_class
#define AV_PIX_FMT_YUV420P12
static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
opj_cparameters_t enc_params
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define CODEC_CAP_INTRA_ONLY
Codec is intra only.
static void cinema_parameters(opj_cparameters_t *p)
#define AV_PIX_FMT_YUVA420P9
static void warning_callback(const char *msg, void *data)
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUVA420P16
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
uint16_t depth_minus1
Number of bits in the component minus 1.
static opj_image_t * mj2_create_image(AVCodecContext *avctx, opj_cparameters_t *parameters)
#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.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_PIX_FMT_YUVA444P16
simple assert() macros that are a bit more flexible than ISO C assert().
static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
Libavcodec external API header.
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
int flags
A combination of AV_PKT_FLAG values.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
#define AV_PIX_FMT_YUV422P9
uint8_t nb_components
The number of components each pixel has, (1-4)
#define AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GRAY16
int width
picture width / height.
#define AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_GBRP14
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P14
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
BYTE int const BYTE int int int height
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
opj_event_mgr_t event_mgr
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_GBR24P
static void info_callback(const char *msg, void *data)
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_GBRP12
int global_quality
Global quality for codecs which cannot change it per frame.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
common internal and external API header
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
static const AVOption options[]
static void error_callback(const char *msg, void *data)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
AVPixelFormat
Pixel format.
This structure stores compressed data.
#define AV_PIX_FMT_YUV422P16