static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
{
LibOpenJPEGContext *ctx = avctx->priv_data;
opj_destroy_compress(ctx->compress);
opj_image_destroy(ctx->image);
return 0;
}
static av_cold int libopenjpeg_encode_close(AVCodecContext *avctx)
{
LibOpenJPEGContext *ctx = avctx->priv_data;
opj_cio_close(ctx->stream);
ctx->stream = NULL;
opj_destroy_compress(ctx->compress);
ctx->compress = NULL;
opj_image_destroy(ctx->image);
ctx->image = NULL;
av_freep(&avctx->coded_frame);
return 0;
}
static BOOL DLL_CALLCONV
Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
if ((dib) && (handle)) {
BOOL bSuccess;
opj_cparameters_t parameters; // compression parameters
opj_event_mgr_t event_mgr; // event manager
opj_image_t *image = NULL; // image to encode
opj_cinfo_t* cinfo = NULL; // codec context
opj_cio_t *cio = NULL; // memory byte stream
// configure the event callbacks
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = jp2_error_callback;
event_mgr.warning_handler = jp2_warning_callback;
event_mgr.info_handler = NULL;
// set encoding parameters to default values
opj_set_default_encoder_parameters(¶meters);
parameters.tcp_numlayers = 0;
// if no rate entered, apply a 16:1 rate by default
if(flags == JP2_DEFAULT) {
parameters.tcp_rates[0] = (float)16;
} else {
// for now, the flags parameter is only used to specify the rate
parameters.tcp_rates[0] = (float)flags;
}
parameters.tcp_numlayers++;
parameters.cp_disto_alloc = 1;
try {
// convert the dib to a OpenJPEG image
image = FIBITMAPToJ2KImage(s_format_id, dib, ¶meters);
if(!image) return FALSE;
// encode the destination image
// get a J2K compressor handle
cinfo = opj_create_compress(CODEC_JP2);
// catch events using our callbacks
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, NULL);
// setup the encoder parameters using the current image and using user parameters
opj_setup_encoder(cinfo, ¶meters, image);
// open a byte stream for writing, allocate memory for all tiles
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
// encode the image
bSuccess = opj_encode(cinfo, cio, image, NULL/*parameters.index*/);
if (!bSuccess) {
throw "Failed to encode image";
}
int codestream_length = cio_tell(cio);
// write the buffer to user's IO handle
io->write_proc(cio->buffer, 1, codestream_length, handle);
// close and free the byte stream
opj_cio_close(cio);
// free remaining compression structures
opj_destroy_compress(cinfo);
// free image data
opj_image_destroy(image);
return TRUE;
} catch (const char *text) {
if(cio) opj_cio_close(cio);
if(cinfo) opj_destroy_compress(cinfo);
if(image) opj_image_destroy(image);
FreeImage_OutputMessageProc(s_format_id, text);
return FALSE;
}
}
return FALSE;
}
BOOL LLImageJ2COJ::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, BOOL reversible)
{
const S32 MAX_COMPS = 5;
opj_cparameters_t parameters; /* compression parameters */
opj_event_mgr_t event_mgr; /* event manager */
/*
configure the event callbacks (not required)
setting of each callback is optional
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(¶meters);
parameters.cod_format = 0;
parameters.cp_disto_alloc = 1;
if (reversible)
{
parameters.tcp_numlayers = 1;
parameters.tcp_rates[0] = 0.0f;
}
else
{
parameters.tcp_numlayers = 5;
parameters.tcp_rates[0] = 1920.0f;
parameters.tcp_rates[1] = 480.0f;
parameters.tcp_rates[2] = 120.0f;
parameters.tcp_rates[3] = 30.0f;
parameters.tcp_rates[4] = 10.0f;
parameters.irreversible = 1;
if (raw_image.getComponents() >= 3)
{
parameters.tcp_mct = 1;
}
}
if (!comment_text)
{
parameters.cp_comment = (char *) "";
}
else
{
// Awful hacky cast, too lazy to copy right now.
parameters.cp_comment = (char *) comment_text;
}
//
// Fill in the source image from our raw image
//
OPJ_COLOR_SPACE color_space = CLRSPC_SRGB;
opj_image_cmptparm_t cmptparm[MAX_COMPS];
opj_image_t * image = NULL;
S32 numcomps = raw_image.getComponents();
S32 width = raw_image.getWidth();
S32 height = raw_image.getHeight();
memset(&cmptparm[0], 0, MAX_COMPS * sizeof(opj_image_cmptparm_t));
for(S32 c = 0; c < numcomps; c++) {
cmptparm[c].prec = 8;
cmptparm[c].bpp = 8;
cmptparm[c].sgnd = 0;
cmptparm[c].dx = parameters.subsampling_dx;
cmptparm[c].dy = parameters.subsampling_dy;
cmptparm[c].w = width;
cmptparm[c].h = height;
}
/* create the image */
image = opj_image_create(numcomps, &cmptparm[0], color_space);
image->x1 = width;
image->y1 = height;
S32 i = 0;
const U8 *src_datap = raw_image.getData();
for (S32 y = height - 1; y >= 0; y--)
{
for (S32 x = 0; x < width; x++)
{
const U8 *pixel = src_datap + (y*width + x) * numcomps;
for (S32 c = 0; c < numcomps; c++)
{
image->comps[c].data[i] = *pixel;
pixel++;
}
i++;
}
}
/* encode the destination image */
/* ---------------------------- */
int codestream_length;
opj_cio_t *cio = NULL;
/* get a J2K compressor handle */
opj_cinfo_t* cinfo = opj_create_compress(CODEC_J2K);
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the encoder parameters using the current image and using user parameters */
opj_setup_encoder(cinfo, ¶meters, image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
/* encode the image */
bool bSuccess = opj_encode(cinfo, cio, image, NULL);
if (!bSuccess)
{
opj_cio_close(cio);
LL_DEBUGS("Texture") << "Failed to encode image." << LL_ENDL;
return FALSE;
}
codestream_length = cio_tell(cio);
base.copyData(cio->buffer, codestream_length);
base.updateData(); // set width, height
/* close and free the byte stream */
opj_cio_close(cio);
/* free remaining compression structures */
opj_destroy_compress(cinfo);
/* free user parameters structure */
if(parameters.cp_matrice) free(parameters.cp_matrice);
/* free image data */
opj_image_destroy(image);
return TRUE;
}
static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
{
LibOpenJPEGContext *ctx = avctx->priv_data;
int err = AVERROR(ENOMEM);
opj_set_default_encoder_parameters(&ctx->enc_params);
ctx->enc_params.cp_rsiz = ctx->profile;
ctx->enc_params.mode = !!avctx->global_quality;
ctx->enc_params.cp_cinema = ctx->cinema_mode;
ctx->enc_params.prog_order = ctx->prog_order;
ctx->enc_params.numresolution = ctx->numresolution;
ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;
ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;
ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;
ctx->enc_params.tcp_numlayers = ctx->numlayers;
ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;
if (ctx->cinema_mode > 0) {
ctx->enc_params.irreversible = 1;
ctx->enc_params.tcp_mct = 1;
ctx->enc_params.tile_size_on = 0;
/* no subsampling */
ctx->enc_params.cp_tdx=1;
ctx->enc_params.cp_tdy=1;
ctx->enc_params.subsampling_dx = 1;
ctx->enc_params.subsampling_dy = 1;
/* Tile and Image shall be at (0,0) */
ctx->enc_params.cp_tx0 = 0;
ctx->enc_params.cp_ty0 = 0;
ctx->enc_params.image_offset_x0 = 0;
ctx->enc_params.image_offset_y0 = 0;
/* Codeblock size= 32*32 */
ctx->enc_params.cblockw_init = 32;
ctx->enc_params.cblockh_init = 32;
ctx->enc_params.csty |= 0x01;
/* No ROI */
ctx->enc_params.roi_compno = -1;
if (ctx->enc_params.prog_order != CPRL) {
av_log(avctx, AV_LOG_ERROR, "prog_order forced to CPRL\n");
ctx->enc_params.prog_order = CPRL;
}
ctx->enc_params.tp_flag = 'C';
ctx->enc_params.tp_on = 1;
}
ctx->compress = opj_create_compress(ctx->format);
if (!ctx->compress) {
av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");
return AVERROR(ENOMEM);
}
ctx->image = mj2_create_image(avctx, &ctx->enc_params);
if (!ctx->image) {
av_log(avctx, AV_LOG_ERROR, "Error creating the mj2 image\n");
err = AVERROR(EINVAL);
goto fail;
}
avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame) {
av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
goto fail;
}
memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));
ctx->event_mgr.info_handler = info_callback;
ctx->event_mgr.error_handler = error_callback;
ctx->event_mgr.warning_handler = warning_callback;
opj_set_event_mgr((opj_common_ptr) ctx->compress, &ctx->event_mgr, avctx);
return 0;
fail:
opj_destroy_compress(ctx->compress);
ctx->compress = NULL;
opj_image_destroy(ctx->image);
ctx->image = NULL;
av_freep(&avctx->coded_frame);
return err;
}
int write_image (dt_imageio_j2k_t *j2k, const char *filename, const float *in, void *exif, int exif_len, int imgid)
{
opj_cparameters_t parameters; /* compression parameters */
float *rates = NULL;
opj_event_mgr_t event_mgr; /* event manager */
opj_image_t *image = NULL;
int quality = CLAMP(j2k->quality, 1, 100);
/*
configure the event callbacks (not required)
setting of each callback is optionnal
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(¶meters);
/* compression ratio */
/* invert range, from 10-100, 100-1
* where jpeg see's 1 and highest quality (lossless) and 100 is very low quality*/
parameters.tcp_rates[0] = 100 - quality + 1;
parameters.tcp_numlayers = 1; /* only one resolution */
parameters.cp_disto_alloc = 1;
parameters.cp_rsiz = STD_RSIZ;
parameters.cod_format = j2k->format;
parameters.cp_cinema = j2k->preset;
if(parameters.cp_cinema)
{
rates = (float*)malloc(parameters.tcp_numlayers * sizeof(float));
for(int i=0; i< parameters.tcp_numlayers; i++)
{
rates[i] = parameters.tcp_rates[i];
}
cinema_parameters(¶meters);
}
/* Create comment for codestream */
const char comment[] = "Created by "PACKAGE_STRING;
parameters.cp_comment = g_strdup(comment);
/*Converting the image to a format suitable for encoding*/
{
int subsampling_dx = parameters.subsampling_dx;
int subsampling_dy = parameters.subsampling_dy;
int numcomps = 3;
int prec = 12; //TODO: allow other bitdepths!
int w = j2k->width, h = j2k->height;
opj_image_cmptparm_t cmptparm[4]; /* RGBA: max. 4 components */
memset(&cmptparm[0], 0, numcomps * sizeof(opj_image_cmptparm_t));
for(int i = 0; i < numcomps; i++)
{
cmptparm[i].prec = prec;
cmptparm[i].bpp = prec;
cmptparm[i].sgnd = 0;
cmptparm[i].dx = subsampling_dx;
cmptparm[i].dy = subsampling_dy;
cmptparm[i].w = w;
cmptparm[i].h = h;
}
image = opj_image_create(numcomps, &cmptparm[0], CLRSPC_SRGB);
if(!image)
{
fprintf(stderr, "Error: opj_image_create() failed\n");
return 1;
}
/* set image offset and reference grid */
image->x0 = parameters.image_offset_x0;
image->y0 = parameters.image_offset_y0;
image->x1 = parameters.image_offset_x0 + (w - 1) * subsampling_dx + 1;
image->y1 = parameters.image_offset_y0 + (h - 1) * subsampling_dy + 1;
switch(prec)
{
case 8:
for(int i = 0; i < w * h; i++)
{
for(int k = 0; k < numcomps; k++) image->comps[k].data[i] = DOWNSAMPLE_FLOAT_TO_8BIT(in[i*4 + k]);
}
break;
case 12:
for(int i = 0; i < w * h; i++)
{
for(int k = 0; k < numcomps; k++) image->comps[k].data[i] = DOWNSAMPLE_FLOAT_TO_12BIT(in[i*4 + k]);
}
break;
case 16:
for(int i = 0; i < w * h; i++)
{
for(int k = 0; k < numcomps; k++) image->comps[k].data[i] = DOWNSAMPLE_FLOAT_TO_16BIT(in[i*4 + k]);
}
break;
default:
fprintf(stderr, "Error: this shouldn't happen, there is no bit depth of %d for jpeg 2000 images.\n", prec);
return 1;
}
}
/*Encoding image*/
/* Decide if MCT should be used */
parameters.tcp_mct = image->numcomps == 3 ? 1 : 0;
if(parameters.cp_cinema)
{
cinema_setup_encoder(¶meters,image,rates);
}
/* encode the destination image */
/* ---------------------------- */
int rc = 1;
OPJ_CODEC_FORMAT codec;
if(parameters.cod_format == J2K_CFMT) /* J2K format output */
codec = CODEC_J2K;
else
codec = CODEC_JP2;
int codestream_length;
size_t res;
opj_cio_t *cio = NULL;
FILE *f = NULL;
/* get a J2K/JP2 compressor handle */
opj_cinfo_t* cinfo = opj_create_compress(codec);
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the encoder parameters using the current image and user parameters */
opj_setup_encoder(cinfo, ¶meters, image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
/* encode the image */
if(!opj_encode(cinfo, cio, image, NULL))
{
opj_cio_close(cio);
fprintf(stderr, "failed to encode image\n");
return 1;
}
codestream_length = cio_tell(cio);
/* write the buffer to disk */
f = fopen(filename, "wb");
if(!f)
{
fprintf(stderr, "failed to open %s for writing\n", filename);
return 1;
}
res = fwrite(cio->buffer, 1, codestream_length, f);
if(res < (size_t)codestream_length) /* FIXME */
{
fprintf(stderr, "failed to write %d (%s)\n", codestream_length, filename);
fclose(f);
return 1;
}
fclose(f);
/* close and free the byte stream */
opj_cio_close(cio);
/* free remaining compression structures */
opj_destroy_compress(cinfo);
/* add exif data blob. seems to not work for j2k files :( */
if(exif && j2k->format == JP2_CFMT)
rc = dt_exif_write_blob(exif,exif_len,filename);
/* free image data */
opj_image_destroy(image);
/* free user parameters structure */
g_free(parameters.cp_comment);
if(parameters.cp_matrice) free(parameters.cp_matrice);
return ((rc == 1) ? 0 : 1);
}
static GstFlowReturn
gst_openjpeg_enc_handle_frame (GstVideoEncoder * encoder,
GstVideoCodecFrame * frame)
{
GstOpenJPEGEnc *self = GST_OPENJPEG_ENC (encoder);
GstFlowReturn ret = GST_FLOW_OK;
#ifdef HAVE_OPENJPEG_1
opj_cinfo_t *enc;
GstMapInfo map;
guint length;
opj_cio_t *io;
#else
opj_codec_t *enc;
opj_stream_t *stream;
MemStream mstream;
#endif
opj_image_t *image;
GstVideoFrame vframe;
GST_DEBUG_OBJECT (self, "Handling frame");
enc = opj_create_compress (self->codec_format);
if (!enc)
goto initialization_error;
#ifdef HAVE_OPENJPEG_1
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
GST_LEVEL_TRACE)) {
opj_event_mgr_t callbacks;
callbacks.error_handler = gst_openjpeg_enc_opj_error;
callbacks.warning_handler = gst_openjpeg_enc_opj_warning;
callbacks.info_handler = gst_openjpeg_enc_opj_info;
opj_set_event_mgr ((opj_common_ptr) enc, &callbacks, self);
} else {
opj_set_event_mgr ((opj_common_ptr) enc, NULL, NULL);
}
#else
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
GST_LEVEL_TRACE)) {
opj_set_info_handler (enc, gst_openjpeg_enc_opj_info, self);
opj_set_warning_handler (enc, gst_openjpeg_enc_opj_warning, self);
opj_set_error_handler (enc, gst_openjpeg_enc_opj_error, self);
} else {
opj_set_info_handler (enc, NULL, NULL);
opj_set_warning_handler (enc, NULL, NULL);
opj_set_error_handler (enc, NULL, NULL);
}
#endif
if (!gst_video_frame_map (&vframe, &self->input_state->info,
frame->input_buffer, GST_MAP_READ))
goto map_read_error;
image = gst_openjpeg_enc_fill_image (self, &vframe);
if (!image)
goto fill_image_error;
gst_video_frame_unmap (&vframe);
opj_setup_encoder (enc, &self->params, image);
#ifdef HAVE_OPENJPEG_1
io = opj_cio_open ((opj_common_ptr) enc, NULL, 0);
if (!io)
goto open_error;
if (!opj_encode (enc, io, image, NULL))
goto encode_error;
opj_image_destroy (image);
length = cio_tell (io);
ret =
gst_video_encoder_allocate_output_frame (encoder, frame,
length + (self->is_jp2c ? 8 : 0));
if (ret != GST_FLOW_OK)
goto allocate_error;
gst_buffer_fill (frame->output_buffer, self->is_jp2c ? 8 : 0, io->buffer,
length);
if (self->is_jp2c) {
gst_buffer_map (frame->output_buffer, &map, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (map.data, length + 8);
GST_WRITE_UINT32_BE (map.data + 4, GST_MAKE_FOURCC ('j', 'p', '2', 'c'));
gst_buffer_unmap (frame->output_buffer, &map);
}
opj_cio_close (io);
opj_destroy_compress (enc);
#else
stream = opj_stream_create (4096, OPJ_FALSE);
if (!stream)
goto open_error;
mstream.allocsize = 4096;
mstream.data = g_malloc (mstream.allocsize);
mstream.offset = 0;
mstream.size = 0;
opj_stream_set_read_function (stream, read_fn);
opj_stream_set_write_function (stream, write_fn);
opj_stream_set_skip_function (stream, skip_fn);
opj_stream_set_seek_function (stream, seek_fn);
opj_stream_set_user_data (stream, &mstream);
opj_stream_set_user_data_length (stream, mstream.size);
if (!opj_start_compress (enc, image, stream))
goto encode_error;
if (!opj_encode (enc, stream))
goto encode_error;
if (!opj_end_compress (enc, stream))
goto encode_error;
opj_image_destroy (image);
opj_stream_destroy (stream);
opj_destroy_codec (enc);
frame->output_buffer = gst_buffer_new ();
if (self->is_jp2c) {
GstMapInfo map;
GstMemory *mem;
mem = gst_allocator_alloc (NULL, 8, NULL);
gst_memory_map (mem, &map, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (map.data, mstream.size + 8);
GST_WRITE_UINT32_BE (map.data + 4, GST_MAKE_FOURCC ('j', 'p', '2', 'c'));
gst_memory_unmap (mem, &map);
gst_buffer_append_memory (frame->output_buffer, mem);
}
gst_buffer_append_memory (frame->output_buffer,
gst_memory_new_wrapped (0, mstream.data, mstream.allocsize, 0,
mstream.size, NULL, (GDestroyNotify) g_free));
#endif
ret = gst_video_encoder_finish_frame (encoder, frame);
return ret;
initialization_error:
{
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to initialize OpenJPEG encoder"), (NULL));
return GST_FLOW_ERROR;
}
map_read_error:
{
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to map input buffer"), (NULL));
return GST_FLOW_ERROR;
}
fill_image_error:
{
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_frame_unmap (&vframe);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to fill OpenJPEG image"), (NULL));
return GST_FLOW_ERROR;
}
open_error:
{
opj_image_destroy (image);
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to open OpenJPEG data"), (NULL));
return GST_FLOW_ERROR;
}
encode_error:
{
#ifdef HAVE_OPENJPEG_1
opj_cio_close (io);
opj_image_destroy (image);
opj_destroy_compress (enc);
#else
opj_stream_destroy (stream);
g_free (mstream.data);
opj_image_destroy (image);
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, STREAM, ENCODE,
("Failed to encode OpenJPEG stream"), (NULL));
return GST_FLOW_ERROR;
}
#ifdef HAVE_OPENJPEG_1
allocate_error:
{
opj_cio_close (io);
opj_destroy_compress (enc);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to allocate output buffer"), (NULL));
return ret;
}
#endif
}
static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
LibOpenJPEGContext *ctx = avctx->priv_data;
opj_image_t *image = ctx->image;
opj_cinfo_t *compress = NULL;
opj_cio_t *stream = NULL;
int cpyresult = 0;
int ret, len;
AVFrame *gbrframe;
switch (avctx->pix_fmt) {
case AV_PIX_FMT_RGB24:
case AV_PIX_FMT_RGBA:
case AV_PIX_FMT_YA8:
cpyresult = libopenjpeg_copy_packed8(avctx, frame, image);
break;
case AV_PIX_FMT_XYZ12:
cpyresult = libopenjpeg_copy_packed12(avctx, frame, image);
break;
case AV_PIX_FMT_RGB48:
case AV_PIX_FMT_RGBA64:
case AV_PIX_FMT_YA16:
cpyresult = libopenjpeg_copy_packed16(avctx, frame, image);
break;
case AV_PIX_FMT_GBR24P:
case AV_PIX_FMT_GBRP9:
case AV_PIX_FMT_GBRP10:
case AV_PIX_FMT_GBRP12:
case AV_PIX_FMT_GBRP14:
case AV_PIX_FMT_GBRP16:
gbrframe = av_frame_clone(frame);
if (!gbrframe)
return AVERROR(ENOMEM);
gbrframe->data[0] = frame->data[2]; // swap to be rgb
gbrframe->data[1] = frame->data[0];
gbrframe->data[2] = frame->data[1];
gbrframe->linesize[0] = frame->linesize[2];
gbrframe->linesize[1] = frame->linesize[0];
gbrframe->linesize[2] = frame->linesize[1];
if (avctx->pix_fmt == AV_PIX_FMT_GBR24P) {
cpyresult = libopenjpeg_copy_unpacked8(avctx, gbrframe, image);
} else {
cpyresult = libopenjpeg_copy_unpacked16(avctx, gbrframe, image);
}
av_frame_free(&gbrframe);
break;
case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_YUV410P:
case AV_PIX_FMT_YUV411P:
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV440P:
case AV_PIX_FMT_YUV444P:
case AV_PIX_FMT_YUVA420P:
case AV_PIX_FMT_YUVA422P:
case AV_PIX_FMT_YUVA444P:
cpyresult = libopenjpeg_copy_unpacked8(avctx, frame, image);
break;
case AV_PIX_FMT_GRAY16:
case AV_PIX_FMT_YUV420P9:
case AV_PIX_FMT_YUV422P9:
case AV_PIX_FMT_YUV444P9:
case AV_PIX_FMT_YUVA420P9:
case AV_PIX_FMT_YUVA422P9:
case AV_PIX_FMT_YUVA444P9:
case AV_PIX_FMT_YUV444P10:
case AV_PIX_FMT_YUV422P10:
case AV_PIX_FMT_YUV420P10:
case AV_PIX_FMT_YUVA444P10:
case AV_PIX_FMT_YUVA422P10:
case AV_PIX_FMT_YUVA420P10:
case AV_PIX_FMT_YUV420P12:
case AV_PIX_FMT_YUV422P12:
case AV_PIX_FMT_YUV444P12:
case AV_PIX_FMT_YUV420P14:
case AV_PIX_FMT_YUV422P14:
case AV_PIX_FMT_YUV444P14:
case AV_PIX_FMT_YUV444P16:
case AV_PIX_FMT_YUV422P16:
case AV_PIX_FMT_YUV420P16:
case AV_PIX_FMT_YUVA444P16:
case AV_PIX_FMT_YUVA422P16:
case AV_PIX_FMT_YUVA420P16:
cpyresult = libopenjpeg_copy_unpacked16(avctx, frame, image);
break;
default:
av_log(avctx, AV_LOG_ERROR,
"The frame's pixel format '%s' is not supported\n",
av_get_pix_fmt_name(avctx->pix_fmt));
return AVERROR(EINVAL);
break;
}
if (!cpyresult) {
av_log(avctx, AV_LOG_ERROR,
"Could not copy the frame data to the internal image buffer\n");
return -1;
}
compress = opj_create_compress(ctx->format);
if (!compress) {
av_log(avctx, AV_LOG_ERROR, "Error creating the compressor\n");
return AVERROR(ENOMEM);
}
opj_setup_encoder(compress, &ctx->enc_params, image);
stream = opj_cio_open((opj_common_ptr) compress, NULL, 0);
if (!stream) {
av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");
return AVERROR(ENOMEM);
}
memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));
ctx->event_mgr.info_handler = info_callback;
ctx->event_mgr.error_handler = error_callback;
ctx->event_mgr.warning_handler = warning_callback;
opj_set_event_mgr((opj_common_ptr) compress, &ctx->event_mgr, avctx);
if (!opj_encode(compress, stream, image, NULL)) {
av_log(avctx, AV_LOG_ERROR, "Error during the opj encode\n");
return -1;
}
len = cio_tell(stream);
if ((ret = ff_alloc_packet2(avctx, pkt, len)) < 0) {
return ret;
}
memcpy(pkt->data, stream->buffer, len);
pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1;
opj_cio_close(stream);
stream = NULL;
opj_destroy_compress(compress);
compress = NULL;
return 0;
}
BOOL LLImageJ2COJ::encodeImpl(LLImageJ2C &base, const LLImageRaw &raw_image, const char* comment_text, F32 encode_time, BOOL reversible)
{
const S32 MAX_COMPS = 5;
opj_cparameters_t parameters; /* compression parameters */
opj_event_mgr_t event_mgr; /* event manager */
/*
configure the event callbacks (not required)
setting of each callback is optional
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(¶meters);
parameters.cod_format = 0;
parameters.cp_disto_alloc = 1;
if (reversible)
{
parameters.tcp_numlayers = 1;
parameters.tcp_rates[0] = 0.0f;
}
else
{
parameters.tcp_numlayers = 5;
parameters.tcp_rates[0] = 1920.0f;
parameters.tcp_rates[1] = 480.0f;
parameters.tcp_rates[2] = 120.0f;
parameters.tcp_rates[3] = 30.0f;
parameters.tcp_rates[4] = 10.0f;
parameters.irreversible = 1;
if (raw_image.getComponents() >= 3)
{
parameters.tcp_mct = 1;
}
}
std::string comment_metadata;
if (!comment_text)
{
//Inserting owner id, upload time, and dimensions
//See http://wiki.secondlife.com/wiki/Texture_meta-data for details.
extern LLUUID gAgentID;
time_t now = time(NULL);
tm * ptime = gmtime(&now);
//std::string color_avg(llformat("c=%02x%02x%02x%02x")); //Perhaps do this some day...
std::string timestr(llformat("z=%04i%02i%02i%02i%02i%02i",ptime->tm_year+1900,ptime->tm_mon+1,ptime->tm_mday,ptime->tm_hour,ptime->tm_min,ptime->tm_sec));
comment_metadata=llformat("a=%s&%s&h=%u&w=%u",gAgentID.asString().c_str(),timestr.c_str(),(U32)raw_image.getHeight(),(U32)raw_image.getWidth());
parameters.cp_comment = (char *) comment_metadata.c_str();
}
else
{
// Awful hacky cast, too lazy to copy right now.
parameters.cp_comment = (char *) comment_text;
}
//
// Fill in the source image from our raw image
//
OPJ_COLOR_SPACE color_space = CLRSPC_SRGB;
opj_image_cmptparm_t cmptparm[MAX_COMPS];
opj_image_t * image = NULL;
S32 numcomps = llmin((S32)raw_image.getComponents(),(S32)MAX_COMPS); //Clamp avoid overrunning buffer -Shyotl
S32 width = raw_image.getWidth();
S32 height = raw_image.getHeight();
memset(&cmptparm[0], 0, MAX_COMPS * sizeof(opj_image_cmptparm_t));
for(S32 c = 0; c < numcomps; c++) {
cmptparm[c].prec = 8;
cmptparm[c].bpp = 8;
cmptparm[c].sgnd = 0;
cmptparm[c].dx = parameters.subsampling_dx;
cmptparm[c].dy = parameters.subsampling_dy;
cmptparm[c].w = width;
cmptparm[c].h = height;
}
/* create the image */
image = opj_image_create(numcomps, &cmptparm[0], color_space);
image->x1 = width;
image->y1 = height;
S32 i = 0;
const U8 *src_datap = raw_image.getData();
for (S32 y = height - 1; y >= 0; y--)
{
for (S32 x = 0; x < width; x++)
{
const U8 *pixel = src_datap + (y*width + x) * numcomps;
for (S32 c = 0; c < numcomps; c++)
{
image->comps[c].data[i] = *pixel;
pixel++;
}
i++;
}
}
/* encode the destination image */
/* ---------------------------- */
int codestream_length;
opj_cio_t *cio = NULL;
/* get a J2K compressor handle */
opj_cinfo_t* cinfo = opj_create_compress(CODEC_J2K);
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the encoder parameters using the current image and using user parameters */
opj_setup_encoder(cinfo, ¶meters, image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
/* encode the image */
bool bSuccess = opj_encode(cinfo, cio, image, NULL);
if (!bSuccess)
{
opj_cio_close(cio);
llinfos << "Failed to encode image." << llendl;
return FALSE;
}
codestream_length = cio_tell(cio);
base.copyData(cio->buffer, codestream_length);
base.updateData(); // set width, height
/* close and free the byte stream */
opj_cio_close(cio);
/* free remaining compression structures */
opj_destroy_compress(cinfo);
/* free user parameters structure */
if(parameters.cp_matrice) free(parameters.cp_matrice);
/* free image data */
opj_image_destroy(image);
return TRUE;
}
int encode_openjpeg(opendcp_t *opendcp, opj_image_t *opj_image, char *out_file) {
bool result;
int codestream_length;
int max_comp_size;
int max_cs_len;
opj_cparameters_t parameters;
opj_cio_t *cio = NULL;
opj_cinfo_t *cinfo = NULL;
FILE *f = NULL;
int bw;
if (opendcp->j2k.bw) {
bw = opendcp->j2k.bw;
} else {
bw = MAX_DCP_JPEG_BITRATE;
}
/* set the max image and component sizes based on frame_rate */
max_cs_len = ((float)bw)/8/opendcp->frame_rate;
/* adjust cs for 3D */
if (opendcp->stereoscopic) {
max_cs_len = max_cs_len/2;
}
max_comp_size = ((float)max_cs_len)/1.25;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(¶meters);
/* set default cinema parameters */
set_cinema_encoder_parameters(opendcp, ¶meters);
parameters.cp_comment = (char*)malloc(strlen(OPENDCP_NAME)+1);
sprintf(parameters.cp_comment,"%s", OPENDCP_NAME);
/* adjust cinema enum type */
if (opendcp->cinema_profile == DCP_CINEMA4K) {
parameters.cp_cinema = CINEMA4K_24;
} else {
parameters.cp_cinema = CINEMA2K_24;
}
/* Decide if MCT should be used */
parameters.tcp_mct = opj_image->numcomps == 3 ? 1 : 0;
/* set max image */
parameters.max_comp_size = max_comp_size;
parameters.tcp_rates[0]= ((float) (opj_image->numcomps * opj_image->comps[0].w * opj_image->comps[0].h * opj_image->comps[0].prec))/
(max_cs_len * 8 * opj_image->comps[0].dx * opj_image->comps[0].dy);
/* get a J2K compressor handle */
dcp_log(LOG_DEBUG,"%-15.15s: creating compressor %s","encode_openjpeg",out_file);
cinfo = opj_create_compress(CODEC_J2K);
/* set event manager to null (openjpeg 1.3 bug) */
cinfo->event_mgr = NULL;
/* setup the encoder parameters using the current image and user parameters */
dcp_log(LOG_DEBUG,"%-15.15s: setup J2k encoder %s","encode_openjpeg",out_file);
opj_setup_encoder(cinfo, ¶meters, opj_image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
dcp_log(LOG_DEBUG,"%-15.15s: opening J2k output stream %s","encode_openjpeg",out_file);
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
dcp_log(LOG_INFO,"Encoding file %s",out_file);
result = opj_encode(cinfo, cio, opj_image, NULL);
dcp_log(LOG_DEBUG,"%-15.15s: encoding file %s complete","encode_openjepg",out_file);
if (!result) {
dcp_log(LOG_ERROR,"Unable to encode jpeg2000 file %s",out_file);
opj_cio_close(cio);
opj_destroy_compress(cinfo);
return OPENDCP_ERROR;
}
codestream_length = cio_tell(cio);
f = fopen(out_file, "wb");
if (!f) {
dcp_log(LOG_ERROR,"Unable to write jpeg2000 file %s",out_file);
opj_cio_close(cio);
opj_destroy_compress(cinfo);
return OPENDCP_ERROR;
}
fwrite(cio->buffer, 1, codestream_length, f);
fclose(f);
/* free openjpeg structure */
opj_cio_close(cio);
opj_destroy_compress(cinfo);
/* free user parameters structure */
if(parameters.cp_comment) free(parameters.cp_comment);
if(parameters.cp_matrice) free(parameters.cp_matrice);
return OPENDCP_NO_ERROR;
}
bool DotNetEncode(MarshalledImage* image, bool lossless)
{
try
{
opj_cparameters cparameters;
opj_set_default_encoder_parameters(&cparameters);
cparameters.cp_disto_alloc = 1;
if (lossless)
{
cparameters.tcp_numlayers = 1;
cparameters.tcp_rates[0] = 0;
}
else
{
cparameters.tcp_numlayers = 5;
cparameters.tcp_rates[0] = 1920;
cparameters.tcp_rates[1] = 480;
cparameters.tcp_rates[2] = 120;
cparameters.tcp_rates[3] = 30;
cparameters.tcp_rates[4] = 10;
cparameters.irreversible = 1;
if (image->components >= 3)
{
cparameters.tcp_mct = 1;
}
}
cparameters.cp_comment = (char*)"";
opj_image_comptparm comptparm[5];
for (int i = 0; i < image->components; i++)
{
comptparm[i].bpp = 8;
comptparm[i].prec = 8;
comptparm[i].sgnd = 0;
comptparm[i].dx = 1;
comptparm[i].dy = 1;
comptparm[i].x0 = 0;
comptparm[i].y0 = 0;
comptparm[i].w = image->width;
comptparm[i].h = image->height;
}
opj_image_t* jp2_image = opj_image_create(image->components, comptparm, CLRSPC_SRGB);
if (jp2_image == NULL)
throw "opj_image_create failed";
jp2_image->x0 = 0;
jp2_image->y0 = 0;
jp2_image->x1 = image->width;
jp2_image->y1 = image->height;
int n = image->width * image->height;
for (int i = 0; i < image->components; i++)
std::copy(image->decoded + i * n, image->decoded + (i + 1) * n, jp2_image->comps[i].data);
opj_cinfo* cinfo = opj_create_compress(CODEC_J2K);
opj_setup_encoder(cinfo, &cparameters, jp2_image);
opj_cio* cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
if (cio == NULL)
throw "opj_cio_open failed";
if (!opj_encode(cinfo, cio, jp2_image, cparameters.index))
return false;
image->length = cio_tell(cio);
image->encoded = new unsigned char[image->length];
std::copy(cio->buffer, cio->buffer + image->length, image->encoded);
opj_image_destroy(jp2_image);
opj_destroy_compress(cinfo);
opj_cio_close(cio);
return true;
}
catch (...)
{
return false;
}
}
/* Found write info at http://users.ece.gatech.edu/~slabaugh/personal/c/bitmapUnix.c */
int imb_savejp2(struct ImBuf *ibuf, const char *name, int flags) {
int quality = ibuf->ftype & 0xff;
int bSuccess;
opj_cparameters_t parameters; /* compression parameters */
opj_event_mgr_t event_mgr; /* event manager */
opj_image_t *image = NULL;
(void)flags; /* unused */
/*
configure the event callbacks (not required)
setting of each callback is optionnal
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(¶meters);
/* compression ratio */
/* invert range, from 10-100, 100-1
* where jpeg see's 1 and highest quality (lossless) and 100 is very low quality*/
parameters.tcp_rates[0]= ((100-quality)/90.0f*99.0f) + 1;
parameters.tcp_numlayers = 1; // only one resolution
parameters.cp_disto_alloc = 1;
image= ibuftoimage(ibuf, ¶meters);
{ /* JP2 format output */
int codestream_length;
opj_cio_t *cio = NULL;
FILE *f = NULL;
/* get a JP2 compressor handle */
opj_cinfo_t* cinfo = opj_create_compress(CODEC_JP2);
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the encoder parameters using the current image and using user parameters */
opj_setup_encoder(cinfo, ¶meters, image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
/* encode the image */
bSuccess = opj_encode(cinfo, cio, image, NULL); /* last arg used to be parameters.index but this deprecated */
if (!bSuccess) {
opj_cio_close(cio);
fprintf(stderr, "failed to encode image\n");
return 0;
}
codestream_length = cio_tell(cio);
/* write the buffer to disk */
f = fopen(name, "wb");
if (!f) {
fprintf(stderr, "failed to open %s for writing\n", name);
return 1;
}
fwrite(cio->buffer, 1, codestream_length, f);
fclose(f);
fprintf(stderr,"Generated outfile %s\n",name);
/* close and free the byte stream */
opj_cio_close(cio);
/* free remaining compression structures */
opj_destroy_compress(cinfo);
}
/* free image data */
opj_image_destroy(image);
return 1;
}