src/lib/openjpip/jp2k_decoder.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2014, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <stdlib.h>
  34 #include <assert.h>
  35 #include <limits.h>
  36 #include "jp2k_decoder.h"
  37 #include "openjpeg.h"
  38
  39
  40 static void error_callback(const char *msg, void *client_data);
  41 static void warning_callback(const char *msg, void *client_data);
  42 static void info_callback(const char *msg, void *client_data);
  43
  44 static Byte_t * imagetopnm(opj_image_t *image, ihdrbox_param_t **ihdrbox);
  45
  46 Byte_t * j2k_to_pnm(const char *fn, ihdrbox_param_t **ihdrbox)
  47 {
  48     Byte_t *pnmstream = NULL;
  49     opj_dparameters_t parameters; /* decompression parameters */
  50     opj_image_t *image = NULL;
  51     opj_codec_t *l_codec = NULL;  /* handle to a decompressor */
  52     opj_stream_t *l_stream = NULL;
  53
  54     /* set decoding parameters to default values */
  55     opj_set_default_decoder_parameters(&parameters);
  56
  57     /* set a byte stream */
  58     l_stream = opj_stream_create_default_file_stream(fn, OPJ_TRUE);
  59     if (!l_stream) {
  60         fprintf(stderr, "ERROR -> failed to create the stream from the file\n");
  61         return NULL;
  62     }
  63
  64     /* decode the code-stream */
  65     /* ---------------------- */
  66
  67     /* JPEG-2000 codestream */
  68     /* get a decoder handle */
  69     l_codec = opj_create_decompress(OPJ_CODEC_J2K);
  70
  71     /* catch events using our callbacks and give a local context */
  72     opj_set_info_handler(l_codec, info_callback, 00);
  73     opj_set_warning_handler(l_codec, warning_callback, 00);
  74     opj_set_error_handler(l_codec, error_callback, 00);
  75
  76     /* setup the decoder decoding parameters using user parameters */
  77     if (!opj_setup_decoder(l_codec, &parameters)) {
  78         fprintf(stderr, "ERROR -> j2k_dump: failed to setup the decoder\n");
  79         return NULL;
  80     }
  81
  82     /* Read the main header of the codestream and if necessary the JP2 boxes*/
  83     if (! opj_read_header(l_stream, l_codec, &image)) {
  84         fprintf(stderr, "ERROR -> j2k_to_image: failed to read the header\n");
  85         opj_stream_destroy(l_stream);
  86         opj_destroy_codec(l_codec);
  87         opj_image_destroy(image);
  88         return NULL;
  89     }
  90
  91 #ifdef TODO /*decode area could be set from j2k_to_pnm call, modify the protocol between JPIP viewer and opj_dec_server*/
  92     if (! opj_set_decode_area(l_codec, image, parameters.DA_x0, parameters.DA_y0,
  93                               parameters.DA_x1, parameters.DA_y1)) {
  94         fprintf(stderr, "ERROR -> j2k_to_image: failed to set the decoded area\n");
  95         opj_stream_destroy(l_stream);
  96         opj_destroy_codec(l_codec);
  97         opj_image_destroy(image);
  98         return NULL;
  99     }
 100 #endif /*TODO*/
 101
 102     /* Get the decoded image */
 103     if (!(opj_decode(l_codec, l_stream, image) &&
 104             opj_end_decompress(l_codec, l_stream))) {
 105         fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
 106         opj_stream_destroy(l_stream);
 107         opj_destroy_codec(l_codec);
 108         opj_image_destroy(image);
 109         return NULL;
 110     }
 111
 112     fprintf(stderr, "image is decoded!\n");
 113
 114     /* close the byte stream */
 115     opj_stream_destroy(l_stream);
 116
 117     /* create output image */
 118     /* ------------------- */
 119     if ((pnmstream = imagetopnm(image, ihdrbox)) == NULL) {
 120         fprintf(stderr, "PNM image not generated\n");
 121     }
 122
 123     /* free remaining structures */
 124     if (l_codec) {
 125         opj_destroy_codec(l_codec);
 126     }
 127
 128     /* free image data structure */
 129     opj_image_destroy(image);
 130
 131     return pnmstream;
 132 }
 133
 134
 135 /**
 136    sample error callback expecting a FILE* client object
 137 */
 138 static void error_callback(const char *msg, void *client_data)
 139 {
 140     FILE *stream = (FILE*)client_data;
 141     fprintf(stream, "[ERROR] %s", msg);
 142 }
 143 /**
 144    sample warning callback expecting a FILE* client object
 145 */
 146 static void warning_callback(const char *msg, void *client_data)
 147 {
 148     FILE *stream = (FILE*)client_data;
 149     fprintf(stream, "[WARNING] %s", msg);
 150 }
 151 /**
 152    sample debug callback expecting no client object
 153 */
 154 static void info_callback(const char *msg, void *client_data)
 155 {
 156     (void)client_data;
 157     (void)msg;
 158     /*  fprintf(stdout, "[INFO] %s", msg); */
 159 }
 160
 161
 162 static Byte_t * imagetopnm(opj_image_t *image, ihdrbox_param_t **ihdrbox)
 163 {
 164     OPJ_UINT32 adjustR, adjustG = 0, adjustB = 0;
 165     OPJ_SIZE_T datasize;
 166     Byte_t *pix = NULL, *ptr = NULL;
 167     OPJ_UINT32 i;
 168
 169     if (*ihdrbox) {
 170         if ((*ihdrbox)->nc != image->numcomps) {
 171             fprintf(stderr,
 172                     "Exception: num of components not identical, codestream: %d, ihdrbox: %d\n",
 173                     image->numcomps, (*ihdrbox)->nc);
 174         }
 175
 176         if ((*ihdrbox)->width != image->comps[0].w) {
 177             (*ihdrbox)->width = image->comps[0].w;
 178         }
 179
 180         if ((*ihdrbox)->height != image->comps[0].h) {
 181             (*ihdrbox)->height = image->comps[0].h;
 182         }
 183
 184         if ((*ihdrbox)->bpc != image->comps[0].prec) {
 185             fprintf(stderr,
 186                     "Exception: bits per component not identical, codestream: %d, ihdrbox: %d\n",
 187                     image->comps[0].prec, (*ihdrbox)->bpc);
 188         }
 189     } else {
 190         *ihdrbox = (ihdrbox_param_t *)malloc(sizeof(ihdrbox_param_t));
 191         (*ihdrbox)->width  = image->comps[0].w;
 192         (*ihdrbox)->height = image->comps[0].h;
 193         assert(image->comps[0].prec < 256);
 194         (*ihdrbox)->bpc    = (Byte_t)image->comps[0].prec;
 195         assert(image->numcomps < USHRT_MAX);
 196         (*ihdrbox)->nc     = (Byte2_t)image->numcomps;
 197     }
 198
 199     datasize = (image->numcomps) * (image->comps[0].w) * (image->comps[0].h);
 200
 201     if (image->comps[0].prec > 8) {
 202         adjustR = image->comps[0].prec - 8;
 203         printf("PNM CONVERSION: Truncating component 0 from %d bits to 8 bits\n",
 204                image->comps[0].prec);
 205     } else {
 206         adjustR = 0;
 207     }
 208
 209     if (image->numcomps == 3) {
 210         if (image->comps[1].prec > 8) {
 211             adjustG = image->comps[1].prec - 8;
 212             printf("PNM CONVERSION: Truncating component 1 from %d bits to 8 bits\n",
 213                    image->comps[1].prec);
 214         } else {
 215             adjustG = 0;
 216         }
 217
 218         if (image->comps[2].prec > 8) {
 219             adjustB = image->comps[2].prec - 8;
 220             printf("PNM CONVERSION: Truncating component 2 from %d bits to 8 bits\n",
 221                    image->comps[2].prec);
 222         } else {
 223             adjustB = 0;
 224         }
 225     }
 226
 227     pix = (Byte_t *)malloc(datasize);
 228     ptr = pix;
 229
 230     for (i = 0; i < image->comps[0].w * image->comps[0].h; i++) {
 231         int r, g, b;
 232         r = image->comps[0].data[i];
 233         r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
 234
 235         /*    if( adjustR > 0) */
 236         *(ptr++) = (Byte_t)((r >> adjustR) + ((r >> (adjustR - 1)) % 2));
 237
 238         if (image->numcomps == 3) {
 239             g = image->comps[1].data[i];
 240             g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
 241             *(ptr++) = (Byte_t)((g >> adjustG) + ((g >> (adjustG - 1)) % 2));
 242
 243             b = image->comps[2].data[i];
 244             b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
 245             *(ptr++) = (Byte_t)((b >> adjustB) + ((b >> (adjustB - 1)) % 2));
 246         }
 247     }
 248
 249     return pix;
 250 }