Author: Alastair McKinstry Description: Remove jasper from Debian Forwarded: not-needed Last-Updated: 2018-02-4 Index: g2clib-1.6.2/enc_jpeg2000.c =================================================================== --- g2clib-1.6.2.orig/enc_jpeg2000.c +++ g2clib-1.6.2/enc_jpeg2000.c @@ -1,8 +1,8 @@ /** @file */ -#ifndef USE_JPEG2000 +#ifndef USE_JASPER void dummy_enc_jpeg2000(void) {} -#else /* USE_JPEG2000 */ +#else /* USE_JASPER */ #include #include Index: g2clib-1.6.2/dec_jpeg2000.c =================================================================== --- g2clib-1.6.2.orig/dec_jpeg2000.c +++ g2clib-1.6.2/dec_jpeg2000.c @@ -1,8 +1,8 @@ /** @file */ -#ifndef USE_JPEG2000 +#ifndef USE_JASPER void dummy_dec_jpeg200(void) {} -#else /* USE_JPEG2000 */ +#else /* USE_JASPER */ #include #include #include Index: g2clib-1.6.2/makefile =================================================================== --- g2clib-1.6.2.orig/makefile +++ g2clib-1.6.2/makefile @@ -10,7 +10,7 @@ SHELL=/bin/sh # # In addition, INC must include all directories where the above # mentioned include files can be found. -DEFS=-DUSE_JPEG2000 -DUSE_PNG +DEFS=-DUSE_OPENJPEG -DUSE_PNG # # Please make sure to include all idirectories where include files @@ -18,6 +18,7 @@ DEFS=-DUSE_JPEG2000 -DUSE_PNG # #INC=-I/usrx/local/prod/packages/gnu/4.8.5/jasper/1.900.1/include +INC=$(shell pkg-config --cflags libopenjp2) # # This "C" source code contains many uses of the C++ @@ -103,7 +104,7 @@ $(LIB): $(LIB)(gridtemplates.o) \ clean: rm -f *.o *.a *.so grib2c.pc lib* -LIBS= `pkg-config --libs libpng` -ljasper -lm +LIBS= `pkg-config --libs libpng` -lopenjp2 -lm OBJS:= gridtemplates.o \ drstemplates.o \ pdstemplates.o \ @@ -137,6 +138,7 @@ OBJS:= gridtemplates.o \ pngunpack.o \ dec_jpeg2000.o \ enc_jpeg2000.o \ + jpeg2000_openjpeg.o \ dec_png.o \ enc_png.o \ g2_create.o \ Index: g2clib-1.6.2/jpeg2000_openjpeg.c =================================================================== --- /dev/null +++ g2clib-1.6.2/jpeg2000_openjpeg.c @@ -0,0 +1,415 @@ +#ifndef USE_OPENJPEG + void dummy_openjpeg(void) {} +#else +#include +#include +#include +#include +#include +#include "grib2.h" +#include "openjpeg.h" + +#define GRIB_SUCCESS 0 +#define GRIB_DECODING_ERROR -3 +#define GRIB_ENCODING_ERROR -14 /* match openjpeg in grib_api */ + +/* opj_* Helper code from https://groups.google.com/forum/#!topic/openjpeg/8cebr0u7JgY */ +typedef struct +{ + OPJ_UINT8* pData; + OPJ_SIZE_T dataSize; + OPJ_SIZE_T offset; + // j2k_encode_helper *helper; +} opj_memory_stream; + + +static void openjpeg_warning(const char *msg, void *client_data) +{ + fprintf(stderr,"OPENJPEG: %s",msg); +} + +static void openjpeg_error(const char *msg, void *client_data) +{ + fprintf(stderr,"OPENJPEG ERROR: %s",msg); +} + +static void openjpeg_info(const char *msg, void *client_data) +{ + fprintf(stderr,"OPENJPEG INFO: %s",msg); +} + + +static OPJ_SIZE_T opj_memory_stream_read(void *buffer, OPJ_SIZE_T nb_bytes, void * p_user_data) +{ + opj_memory_stream* mstream = (opj_memory_stream*) p_user_data; //Our data. + OPJ_SIZE_T nb_bytes_read = nb_bytes; + + //Check if the current offset is outside our data buffer. + if (mstream->offset >= mstream->dataSize) + return (OPJ_SIZE_T) -1; + + //Check if we are reading more than we have. + if (nb_bytes > (mstream->dataSize - mstream->offset)) + nb_bytes_read = mstream->dataSize - mstream->offset; + + memcpy(buffer, &(mstream->pData[mstream->offset]), nb_bytes_read); + mstream->offset += nb_bytes_read; + return nb_bytes_read; +} + +static OPJ_SIZE_T opj_memory_stream_write(void *buffer, OPJ_SIZE_T nb_bytes, void *user_data) +{ + opj_memory_stream* mstream = (opj_memory_stream*) user_data; // our data + OPJ_SIZE_T nb_bytes_write = nb_bytes; + + if (mstream->offset >= mstream->dataSize) + return (OPJ_SIZE_T)-1; + if (nb_bytes > (mstream->dataSize - mstream->offset)) + nb_bytes_write = mstream->dataSize - mstream->offset; + + memcpy(&(mstream->pData[mstream->offset]), buffer, nb_bytes_write); + mstream->offset += nb_bytes_write; + return nb_bytes_write; +} + +static OPJ_OFF_T opj_memory_stream_skip(OPJ_OFF_T nb_bytes, void *user_data) +{ + opj_memory_stream* mstream = (opj_memory_stream*) user_data; + OPJ_SIZE_T l_nb_bytes; + + if (nb_bytes < 0) + return -1; + l_nb_bytes = (OPJ_SIZE_T) nb_bytes; + if (l_nb_bytes > mstream->dataSize - mstream->offset) + nb_bytes = mstream->dataSize - mstream->offset; + mstream->offset += l_nb_bytes; + return l_nb_bytes; +} + +static OPJ_BOOL opj_memory_stream_seek(OPJ_OFF_T nb_bytes, void * user_data) +{ + opj_memory_stream* mstream = (opj_memory_stream*) user_data; + + if (nb_bytes < 0) + return OPJ_FALSE; + if (nb_bytes >(OPJ_OFF_T) mstream->dataSize) + return OPJ_FALSE; + mstream->offset = (OPJ_SIZE_T) nb_bytes; +} + +static void opj_memory_stream_do_nothing(void * p_user_data) +{ + OPJ_ARG_NOT_USED(p_user_data); +} + +// Create a stream to use memory as the input or output +static opj_stream_t* opj_stream_create_default_memory_stream(opj_memory_stream* memoryStream, OPJ_BOOL is_read_stream) +{ + opj_stream_t* stream; + + if (!(stream = opj_stream_default_create(is_read_stream))) + return (NULL); + if (is_read_stream) + opj_stream_set_read_function(stream, opj_memory_stream_read); + else + opj_stream_set_write_function(stream, opj_memory_stream_write); + + opj_stream_set_seek_function(stream, opj_memory_stream_seek); + opj_stream_set_skip_function(stream, opj_memory_stream_skip); + opj_stream_set_user_data(stream, memoryStream, opj_memory_stream_do_nothing); + opj_stream_set_user_data_length(stream, memoryStream->dataSize); + return stream; +} + +int dec_jpeg2000(char *injpc,g2int bufsize,g2int *outfld) +/*$$$ SUBPROGRAM DOCUMENTATION BLOCK +* . . . . +* SUBPROGRAM: dec_jpeg2000 Decodes JPEG2000 code stream +* PRGMMR: McKinstry DATE: 2016-08-29 +* +* ABSTRACT: This Function decodes a JPEG2000 code stream specified in the +* JPEG2000 Part-1 standard (i.e., ISO/IEC 15444-1) using Openpeg +* Software version 2.1 +* Openjpeg is available at http://www.openjpeg.org/ +* +* PROGRAM HISTORY LOG: +* 2016-08-29 Alastair McKinstry +* +* USAGE: int dec_jpeg2000(char *injpc,g2int bufsize,g2int *outfld) +* +* INPUT ARGUMENTS: +* injpc - Input JPEG2000 code stream. +* bufsize - Length (in bytes) of the input JPEG2000 code stream. +* +* OUTPUT ARGUMENTS: +* outfld - Output matrix of grayscale image values. +* +* RETURN VALUES : +* 0 = Successful decode +* -3 = Error decode jpeg2000 code stream. +* -5 = decoded image had multiple color components. +* Only grayscale is expected. +* +* REMARKS: +* +* Requires OpenJPEG software, 2.1 or later. +* +* ATTRIBUTES: +* LANGUAGE: C +* +*$$$*/ + +{ + int err = GRIB_SUCCESS; + g2int i; + unsigned long mask; + size_t n_vals, count; + double *val; + + opj_dparameters_t parameters = {0,}; /* decompression parameters */ + opj_codec_t *codec = NULL; + opj_image_t *image = NULL; + opj_stream_t *stream = NULL; + opj_image_comp_t comp = {0,}; + opj_image_cmptparm_t cmptparm = {0,}; + opj_memory_stream mstream; + + /* set decoding parameters to default values */ + opj_set_default_decoder_parameters(¶meters); + parameters.decod_format = 1; /* J + + /* get a decoder handle */ + codec = opj_create_decompress(OPJ_CODEC_J2K); + + opj_set_info_handler(codec, openjpeg_info, NULL); + opj_set_warning_handler(codec, openjpeg_warning, NULL); + opj_set_error_handler(codec, openjpeg_error,NULL); + + /* initialize our memory stream */ + mstream.pData = injpc; + mstream.dataSize = bufsize; + mstream.offset = 0; + /* open a byte stream from memory stream */ + stream = opj_stream_create_default_memory_stream( &mstream, OPJ_STREAM_READ); + + /* setup the decoder decoding parameters using user parameters */ + if (!opj_setup_decoder(codec, ¶meters)) { + err = GRIB_DECODING_ERROR; + goto cleanup; + } + + if (!opj_read_header(stream, codec, &image)) { + err = GRIB_DECODING_ERROR; + goto cleanup; + } + if (!opj_decode(codec, stream, image)) { + err = GRIB_DECODING_ERROR; + goto cleanup; + } + + // sanity checks + //if ( !(*n_vals <= image->comps[0].w * image->comps[0].h) ) { + // err = GRIB_DECODING_ERROR; + // goto cleanup; + //} + if ( (image->numcomps != 1) || !(image->x1 * image->y1) ) { + err = GRIB_DECODING_ERROR; + goto cleanup; + } + assert(image->comps[0].sgnd == 0); + assert(comp.prec <= sizeof(image->comps[0].data[0])*8 - 1); /* BR: -1 because I don't know what happens if the sign bit is set */ + + assert(image->comps[0].prec < sizeof(mask)*8-1); + + outfld = image->comps[0].data; + mask = (1 << image->comps[0].prec) - 1; + + count = image->comps[0].w * image->comps[0].h; + val = (double *) outfld; + for(i = 0; i 0 = Length in bytes of encoded JPEG2000 code stream + * -3 = Error decode jpeg2000 code stream. + * -5 = decoded image had multiple color components. + * Only grayscale is expected. + * + * ATTRIBUTES: + * LANGUAGE: C + */ +{ + int err = GRIB_SUCCESS; + int rwcnt, i; + const int numcomps = 1; + opj_cparameters_t parameters = {0,}; /* compression parameters */ + opj_image_t *image = NULL; + opj_image_cmptparm_t cmptparm = {0,}; + opj_codec_t *codec = NULL; + opj_stream_t *stream = NULL; + int *data; + long num_values; + double *values; + double reference_value = 0; /* FIXME need to set these */ + double divisor = 1; + double decimal = 0; + opj_memory_stream mstream; + + /* set encoding parameters to default values */ + opj_set_default_encoder_parameters(¶meters); + parameters.tcp_numlayers = 1; + parameters.cp_disto_alloc = 1; + if (ltype) { + parameters.tcp_rates[0] = ratio; /* target compression ratio */ + } else { + parameters.tcp_rates[0] = 0.0; + } + + /* initialize image component */ + cmptparm.prec = nbits; + cmptparm.bpp = nbits; /* Not sure about this one and the previous. What is the difference? */ + cmptparm.sgnd = 0; + cmptparm.dx = 1; + cmptparm.dy = 1; + cmptparm.w = width; + cmptparm.h = height; + + /* open a byte stream */ + stream = opj_stream_default_create(true); + + /* create the image */ + image = opj_image_create(numcomps, &cmptparm, OPJ_CLRSPC_GRAY); + if(!image) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + image->x0 = 0; + image->y0 = 0; + image->x1 = width; + image->y1 = height; + num_values = width * height; + + assert(cmptparm.prec <= sizeof(image->comps[0].data[0])*8 - 1); /* BR: -1 because I don't know what happens if the sign bit is set */ + assert(num_values == image->comps[0].h * image->comps[0].w); + + /* Simple packing */ + data = image->comps[0].data; + for(i=0;i< num_values;i++){ + unsigned long unsigned_val = (unsigned long)((((values[i]*decimal)-(reference_value))*divisor)+0.5); + data[i] = unsigned_val; + } + + /* get a J2K compressor handle */ + codec = opj_create_compress(OPJ_CODEC_J2K); + + /* catch events using our callbacks and give a local context */ + opj_set_info_handler(codec, openjpeg_warning, NULL); + opj_set_warning_handler(codec, openjpeg_warning, NULL); + opj_set_error_handler(codec, openjpeg_error,NULL); + + /* setup the encoder parameters using the current image and user parameters */ + if (!opj_setup_encoder(codec, ¶meters, image)) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + /* get a J2K compressor handle */ + codec = opj_create_compress(OPJ_CODEC_J2K); + + opj_set_info_handler(codec, openjpeg_info, NULL); + opj_set_warning_handler(codec, openjpeg_warning, NULL); + opj_set_error_handler(codec, openjpeg_error, NULL); + + /* setup the encoder parameters using the current image and user parameters */ + if (!opj_setup_encoder(codec, ¶meters, image)) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + /* open a byte stream for writing */ + mstream.pData = (OPJ_UINT8*) outjpc; + mstream.offset = 0; + // mstream.dataSize = helper->buffer_size; + if (! (stream = opj_stream_create_default_memory_stream( &mstream, OPJ_STREAM_WRITE)) ) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + if (!opj_start_compress(codec, image, stream)) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + /* encode image */ + if (!opj_encode(codec, stream)) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + if (!opj_end_compress(codec, stream)) { + err = GRIB_ENCODING_ERROR; + goto cleanup; + } + + cleanup: + if (codec) opj_destroy_codec(codec); + if (stream) opj_stream_destroy(stream); + if (image) opj_image_destroy(image); + + // return length if ok, err otherwise + return (err < 0 ? err : mstream.offset); +} + +#endif /* USE_OPENJPEG */