From: Carlos Maddela Date: Wed, 9 Nov 2016 05:05:01 +1100 Subject: Add support for linking with openjpeg 2.x library. Description: Add support for linking with openjpeg 2.x library. Even though the Debian package attempted to build with the openjpeg 2.x library, the resulting binaries didn't support conversion of images with dimensions of 256x256 or greater, since autoconf was incorrectly trying to find libopenjpeg2 instead of libopenjp2. Changes were also required to address the API differences between openjpeg 1.x and openjpeg 2.x. (Closes: #844055) Author: Carlos Maddela Origin: vendor Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=844055 Last-Update: 2016-11-12 --- This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ --- src/icns_jp2.c | 264 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 256 insertions(+), 8 deletions(-) diff --git a/src/icns_jp2.c b/src/icns_jp2.c index 6d809fb..e994f58 100644 --- a/src/icns_jp2.c +++ b/src/icns_jp2.c @@ -125,19 +125,19 @@ int icns_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t #ifdef ICNS_JASPER error = icns_jas_image_to_jp2(image, dataSizeOut, dataPtrOut); - #else - #ifdef ICNS_OPENJPEG + #elif (ICNS_OPENJPEG == 1) // OpenJPEG is broken for RGB+A images for now. See a possible patch here: // http://groups.google.com/group/openjpeg/browse_thread/thread/1cb7807b2053592e // error = icns_opj_image_to_jp2(image, dataSizeOut, dataPtrOut); icns_print_err("icns_image_to_jp2: Saving JP2 data with OpenJPEG is not yet supported!\n"); error = ICNS_STATUS_UNSUPPORTED; + #elif (ICNS_OPENJPEG == 2) + error = icns_opj_image_to_jp2(image, dataSizeOut, dataPtrOut); #else *dataPtrOut = NULL; error = ICNS_STATUS_UNSUPPORTED; #endif - #endif - + return error; } @@ -547,9 +547,136 @@ int icns_opj_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image return error; } +#if (ICNS_OPENJPEG == 2) + +typedef struct mem_stream +{ + OPJ_BYTE *buffer; + OPJ_SIZE_T bufferSize; + OPJ_OFF_T offset; + OPJ_BOOL readOnly; + opj_stream_t *stream; +} mem_stream_t; + +static OPJ_SIZE_T read_mem_stream(void *buffer, OPJ_SIZE_T numBytes, void *userData) +{ + mem_stream_t *memStream = (mem_stream_t *) userData; + OPJ_SIZE_T remaining = memStream->bufferSize - memStream->offset; + OPJ_SIZE_T bytesRead = (remaining < numBytes) ? remaining : numBytes; + memcpy(buffer, memStream->buffer + memStream->offset, bytesRead); + memStream->offset += bytesRead; + return bytesRead ? bytesRead : (OPJ_SIZE_T) -1; +} + +static OPJ_SIZE_T write_mem_stream(void *buffer, OPJ_SIZE_T numBytes, void *userData) +{ + mem_stream_t *memStream = (mem_stream_t *) userData; + if(!memStream->readOnly) { + OPJ_SIZE_T remaining = memStream->bufferSize - memStream->offset; + if(remaining < numBytes) { + OPJ_SIZE_T newBufferSize = memStream->bufferSize + numBytes; + OPJ_BYTE *newBuffer = (OPJ_BYTE *) realloc(memStream->buffer, newBufferSize); + if(!newBuffer) { + return (OPJ_SIZE_T) -1; + } + memStream->buffer = newBuffer; + memStream->bufferSize = newBufferSize; + opj_stream_set_user_data_length(memStream->stream, newBufferSize); + } + memcpy(memStream->buffer + memStream->offset, buffer, numBytes); + memStream->offset += numBytes; + return numBytes ? numBytes : (OPJ_SIZE_T) -1; + } + return (OPJ_SIZE_T) -1; +} + +static OPJ_OFF_T skip_mem_stream(OPJ_OFF_T offset, void *userData) +{ + mem_stream_t *memStream = (mem_stream_t *) userData; + OPJ_OFF_T remaining = memStream->bufferSize - memStream->offset; + if(offset > remaining) { + if(!memStream->readOnly) { + OPJ_SIZE_T newBufferSize = memStream->bufferSize + offset; + OPJ_BYTE *newBuffer = (OPJ_BYTE *) realloc(memStream->buffer, newBufferSize); + if(!newBuffer) { + return (OPJ_OFF_T) -1; + } + memStream->buffer = newBuffer; + memStream->bufferSize = newBufferSize; + opj_stream_set_user_data_length(memStream->stream, newBufferSize); + } else { + offset = remaining; + } + } + memStream->offset += offset; + if(memStream->offset < 0) { + offset -= memStream->offset; + memStream->offset = 0; + } + return offset ? offset : (OPJ_OFF_T) -1; +} + +static OPJ_BOOL seek_mem_stream(OPJ_OFF_T offset, void *userData) +{ + mem_stream_t *memStream = (mem_stream_t *) userData; + if(offset < 0) { + return OPJ_FALSE; + } + if((OPJ_SIZE_T) offset > memStream->bufferSize) { + if(!memStream->readOnly) { + OPJ_SIZE_T newBufferSize = offset; + OPJ_BYTE *newBuffer = (OPJ_BYTE *) realloc(memStream->buffer, newBufferSize); + if(!newBuffer) { + return OPJ_FALSE; + } + memStream->buffer = newBuffer; + memStream->bufferSize = newBufferSize; + opj_stream_set_user_data_length(memStream->stream, newBufferSize); + } else { + return OPJ_FALSE; + } + } + memStream->offset = offset; + return OPJ_TRUE; +} + +static opj_stream_t *create_mem_stream(OPJ_BYTE *buffer, OPJ_SIZE_T bufferSize, OPJ_BOOL readOnly, mem_stream_t **memStreamOut) +{ + opj_stream_t *stream = opj_stream_default_create(readOnly); + if(stream) { + mem_stream_t *memStream = malloc(sizeof(*memStream)); + if(memStream) { + memStream->buffer = buffer; + memStream->bufferSize = bufferSize; + memStream->offset = 0; + memStream->readOnly = readOnly; + memStream->stream = stream; + if(memStreamOut) { + *memStreamOut = memStream; + } + opj_stream_set_user_data(stream, memStream, free); + opj_stream_set_user_data_length(stream, bufferSize); + opj_stream_set_read_function(stream, read_mem_stream); + if(!readOnly) { + opj_stream_set_write_function(stream, write_mem_stream); + } + opj_stream_set_skip_function(stream, skip_mem_stream); + opj_stream_set_seek_function(stream, seek_mem_stream); + } else { + opj_stream_destroy(stream); + stream = NULL; + } + } + return stream; +} + +#endif /* (ICNS_OPENJPEG == 2) */ + // Decode jp2 data using OpenJPEG int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **imageOut) { +#if (ICNS_OPENJPEG == 1) + opj_event_mgr_t event_mgr; opj_dparameters_t parameters; opj_dinfo_t *dinfo = NULL; @@ -583,6 +710,59 @@ int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **i opj_destroy_decompress(dinfo); return ICNS_STATUS_OK; + +#else /* (ICNS_OPENJPEG == 2) */ + + opj_dparameters_t parameters; + opj_codec_t *decoder = NULL; + opj_stream_t *stream = NULL; + opj_image_t *image = NULL; + + *imageOut = NULL; + + decoder = opj_create_decompress(OPJ_CODEC_JP2); + if(!decoder) { + icns_print_err("icns_opj_jp2_dec: failed to create decoder!\n"); + return ICNS_STATUS_NO_MEMORY; + } + + opj_set_error_handler(decoder, icns_opj_error_callback, stderr); + opj_set_warning_handler(decoder, icns_opj_warning_callback, stderr); + opj_set_info_handler(decoder, icns_opj_info_callback, stderr); + + opj_set_default_decoder_parameters(¶meters); + opj_setup_decoder(decoder, ¶meters); + + stream = create_mem_stream(dataPtr, dataSize, OPJ_TRUE, NULL); + if(!stream) { + icns_print_err("icns_opj_jp2_dec: failed to create stream!\n"); + opj_destroy_codec(decoder); + return ICNS_STATUS_NO_MEMORY; + } + + if(!opj_read_header(stream, decoder, &image)) { + icns_print_err("icns_opj_jp2_dec: failed to read header!\n"); + opj_stream_destroy(stream); + opj_destroy_codec(decoder); + return ICNS_STATUS_INVALID_DATA; + } + + if(!opj_decode(decoder, stream, image) || !opj_end_decompress(decoder, stream)) { + icns_print_err("icns_opj_jp2_dec: failed to decode image!\n"); + opj_image_destroy(image); + opj_stream_destroy(stream); + opj_destroy_codec(decoder); + return ICNS_STATUS_INVALID_DATA; + } + + *imageOut = image; + + opj_stream_destroy(stream); + opj_destroy_codec(decoder); + + return ICNS_STATUS_OK; + +#endif /* (ICNS_OPENJPEG == 2) */ } // Convert from opj_image_t to icns_image_t @@ -666,18 +846,30 @@ int icns_opj_to_image(opj_image_t *opjImg, icns_image_t *iconImg) int icns_opj_image_to_jp2(icns_image_t *iconImg, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut) { - int error = ICNS_STATUS_OK; +#if (ICNS_OPENJPEG == 1) + int error = ICNS_STATUS_OK; opj_event_mgr_t event_mgr; +#endif /* (ICNS_OPENJPEG == 1) */ opj_cparameters_t parameters; +#if (ICNS_OPENJPEG == 1) OPJ_COLOR_SPACE color_space = CLRSPC_SRGB; +#else /* (ICNS_OPENJPEG == 2) */ + OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_SRGB; +#endif /* (ICNS_OPENJPEG == 2) */ opj_image_cmptparm_t cmptparm[4]; opj_image_t *opjImg = NULL; icns_byte_t *dataPtr = NULL; int i, j; int rowOffset, colOffset; +#if (ICNS_OPENJPEG == 1) opj_cinfo_t *cinfo = NULL; opj_cio_t *cio = NULL; int success = 0; +#else /* (ICNS_OPENJPEG == 2) */ + opj_codec_t *encoder = NULL; + opj_stream_t *stream = NULL; + mem_stream_t *memStream = NULL; +#endif /* (ICNS_OPENJPEG == 2) */ if(iconImg == NULL) { @@ -713,12 +905,14 @@ int icns_opj_image_to_jp2(icns_image_t *iconImg, icns_size_t *dataSizeOut, icns_ *dataSizeOut = 0; *dataPtrOut = NULL; - + +#if (ICNS_OPENJPEG == 1) memset(&event_mgr, 0, sizeof(opj_event_mgr_t)); event_mgr.error_handler = icns_opj_error_callback; event_mgr.warning_handler = icns_opj_warning_callback; event_mgr.info_handler = icns_opj_info_callback; - +#endif /* (ICNS_OPENJPEG == 1) */ + opj_set_default_encoder_parameters(¶meters); parameters.tcp_numlayers = 1; @@ -766,7 +960,9 @@ int icns_opj_image_to_jp2(icns_image_t *iconImg, icns_size_t *dataSizeOut, icns_ opjImg->comps[3].data[p] = src_pixel->a; } } - + +#if (ICNS_OPENJPEG == 1) + cinfo = opj_create_compress(CODEC_JP2); opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr); opj_setup_encoder(cinfo, ¶meters, opjImg); @@ -810,6 +1006,58 @@ exception: } return error; + +#else /* (ICNS_OPENJPEG == 2) */ + + encoder = opj_create_compress(OPJ_CODEC_JP2); + if(!encoder) { + icns_print_err("icns_opj_image_to_jp2: failed to create encoder!\n"); + opj_image_destroy(opjImg); + return ICNS_STATUS_NO_MEMORY; + } + + opj_set_error_handler(encoder, icns_opj_error_callback, stderr); + opj_set_warning_handler(encoder, icns_opj_warning_callback, stderr); + opj_set_info_handler(encoder, icns_opj_info_callback, stderr); + + opj_setup_encoder(encoder, ¶meters, opjImg); + + stream = create_mem_stream(NULL, 0, OPJ_FALSE, &memStream); + if(!stream) { + icns_print_err("icns_opj_image_to_jp2: failed to create stream!\n"); + opj_image_destroy(opjImg); + opj_destroy_codec(encoder); + return ICNS_STATUS_NO_MEMORY; + } + + if(!opj_start_compress(encoder, opjImg, stream) || !opj_encode(encoder, stream) || !opj_end_compress(encoder, stream)) { + icns_print_err("icns_opj_image_to_jp2: Error while encoding jp2 data!\n"); + opj_image_destroy(opjImg); + opj_stream_destroy(stream); + opj_destroy_codec(encoder); + return ICNS_STATUS_INVALID_DATA; + } + + *dataSizeOut = memStream->bufferSize + 34; + *dataPtrOut = (icns_byte_t *) realloc(memStream->buffer, *dataSizeOut); + + if(!(*dataPtrOut)) + { + icns_print_err("icns_opj_image_to_jp2: Unable to allocate memory block of size: %d!\n", (int) *dataSizeOut); + opj_image_destroy(opjImg); + opj_stream_destroy(stream); + opj_destroy_codec(encoder); + return ICNS_STATUS_NO_MEMORY; + } + + icns_place_jp2_cdef(*dataPtrOut, *dataSizeOut); + + opj_image_destroy(opjImg); + opj_stream_destroy(stream); + opj_destroy_codec(encoder); + + return ICNS_STATUS_OK; +#endif /* (ICNS_OPENJPEG == 2) */ } void icns_opj_error_callback(const char *msg, void *client_data) {