]> Creatis software - gdcm.git/blob - src/gdcmJpeg2000.cxx
Avoid warnings
[gdcm.git] / src / gdcmJpeg2000.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmJpeg2000.cxx,v $
5   Language:  C++
6   Date:      $Date: 2007/10/25 07:52:59 $
7   Version:   $Revision: 1.46 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18 #include "gdcmFileHelper.h"
19 #include "gdcmDebug.h"
20
21 #include <iostream>
22 #include <fstream>
23
24 #if defined(__BORLANDC__)
25    #include <mem.h> // for memset
26    #include <stdlib.h>
27 #endif
28
29 extern "C" {
30   #include <openjpeg.h>
31
32 /**
33 sample error callback expecting a FILE* client object
34 */
35 void error_callback(const char *msg, void *) {
36   std::cerr << "Error in gdcmopenjpeg" << msg << std::endl;
37 }
38 /**
39 sample warning callback expecting a FILE* client object
40 */
41 void warning_callback(const char *msg, void *) {
42   std::cerr << "Warning in gdcmopenjpeg" << msg << std::endl;
43 }
44 /**
45 sample debug callback expecting no client object
46 */
47 void info_callback(const char *msg, void *) {
48   std::cerr << "Info in gdcmopenjpeg" << msg << std::endl;
49 }
50 }
51
52 namespace GDCM_NAME_SPACE 
53 {
54 //-----------------------------------------------------------------------------
55  /**
56  * \brief   routine for JPEG decompression 
57  * @param raw raw
58  * @param inputdata inputdata
59  * @param inputlength inputlength 
60  * @return 1 on success, 0 on error
61  */
62
63 /**
64 sample error callback expecting a FILE* client object
65 */
66 void error_callback(const char *msg, void *) {
67   std::cerr << "Error in gdcmopenjpeg" << msg << std::endl;
68 }
69 /**
70 sample warning callback expecting a FILE* client object
71 */
72 void warning_callback(const char *msg, void *) {
73   std::cerr << "Warning in gdcmopenjpeg" << msg << std::endl;
74 }
75 /**
76 sample debug callback expecting no client object
77 */
78 void info_callback(const char *msg, void *) {
79   std::cerr << "Info in gdcmopenjpeg" << msg << std::endl;
80 }
81
82 #define J2K_CFMT 0
83 #define JP2_CFMT 1
84 #define JPT_CFMT 2
85 #define MJ2_CFMT 3
86 #define PXM_DFMT 0
87 #define PGX_DFMT 1
88 #define BMP_DFMT 2
89 #define YUV_DFMT 3
90
91 /*
92  * Divide an integer by a power of 2 and round upwards.
93  *
94  * a divided by 2^b
95  */
96 inline int int_ceildivpow2(int a, int b) {
97   return (a + (1 << b) - 1) >> b;
98 }
99
100 /*
101  * The following function was copy paste from j2k_to_image.c with part from convert.c
102  */
103 bool gdcm_read_JPEG2000_file (void* raw, char *inputdata, size_t inputlength)
104 {
105   opj_dparameters_t parameters;  /* decompression parameters */
106   opj_event_mgr_t event_mgr;    /* event manager */
107   opj_image_t *image;
108   opj_dinfo_t* dinfo;  /* handle to a decompressor */
109   opj_cio_t *cio;
110   unsigned char *src = (unsigned char*)inputdata; 
111   int file_length = static_cast< int >( inputlength );
112
113   /* configure the event callbacks (not required) */
114   memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
115   event_mgr.error_handler = error_callback;
116   event_mgr.warning_handler = warning_callback;
117   event_mgr.info_handler = info_callback;
118
119   /* set decoding parameters to default values */
120   opj_set_default_decoder_parameters(&parameters);
121  
122    // default blindly copied
123    parameters.cp_layer=0;
124    parameters.cp_reduce=0;
125 //   parameters.decod_format=-1;
126 //   parameters.cod_format=-1;
127
128       /* JPEG-2000 codestream */
129     parameters.decod_format = J2K_CFMT;
130     assert(parameters.decod_format == J2K_CFMT);
131   parameters.cod_format = PGX_DFMT;
132   assert(parameters.cod_format == PGX_DFMT);
133
134       /* get a decoder handle */
135       dinfo = opj_create_decompress(CODEC_J2K);
136
137       /* catch events using our callbacks and give a local context */
138       opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, NULL);
139
140       /* setup the decoder decoding parameters using user parameters */
141       opj_setup_decoder(dinfo, &parameters);
142
143       /* open a byte stream */
144       cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
145
146       /* decode the stream and fill the image structure */
147       image = opj_decode(dinfo, cio);
148       if(!image) {
149         opj_destroy_decompress(dinfo);
150         opj_cio_close(cio);
151         return 1;
152       }
153       
154       /* close the byte stream */
155       opj_cio_close(cio);
156
157   /* free the memory containing the code-stream */
158   delete[] src;  //FIXME
159
160    // Copy buffer
161    for (int compno = 0; compno < image->numcomps; compno++)
162    {
163       opj_image_comp_t *comp = &image->comps[compno];
164
165       int w = image->comps[compno].w;
166       int wr = int_ceildivpow2(image->comps[compno].w, image->comps[compno].factor);
167
168       //int h = image.comps[compno].h;
169       int hr = int_ceildivpow2(image->comps[compno].h, image->comps[compno].factor);
170
171       if (comp->prec <= 8)
172       {
173          uint8_t *data8 = (uint8_t*)raw + compno;
174          for (int i = 0; i < wr * hr; i++)
175          {
176             int v = image->comps[compno].data[i / wr * w + i % wr];
177             *data8 = (uint8_t)v;
178             data8 += image->numcomps;
179          }
180       }
181       else if (comp->prec <= 16)
182       {
183          uint16_t *data16 = (uint16_t*)raw + compno;
184          for (int i = 0; i < wr * hr; i++)
185          {
186             int v = image->comps[compno].data[i / wr * w + i % wr];
187             *data16 = (uint16_t)v;
188             data16 += image->numcomps;
189          }
190       }
191       else
192       {
193          uint32_t *data32 = (uint32_t*)raw + compno;
194          for (int i = 0; i < wr * hr; i++)
195          {
196             int v = image->comps[compno].data[i / wr * w + i % wr];
197             *data32 = (uint32_t)v;
198             data32 += image->numcomps;
199          }
200       }
201       //free(image.comps[compno].data);
202    }
203
204
205   /* free remaining structures */
206   if(dinfo) {
207     opj_destroy_decompress(dinfo);
208   }
209
210   /* free image data structure */
211   opj_image_destroy(image);
212
213   return true;
214 }
215
216 template<typename T>
217 void rawtoimage_fill(T *inputbuffer, int w, int h, int numcomps, opj_image_t *image)
218 {
219   T *p = inputbuffer;
220   for (int i = 0; i < w * h; i++)
221     {
222     for(int compno = 0; compno < numcomps; compno++)
223       {
224       /* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
225       image->comps[compno].data[i] = *p;
226       ++p;
227       }
228     }
229 }
230
231 opj_image_t* rawtoimage(char *inputbuffer, opj_cparameters_t *parameters,
232   int fragment_size, int image_width, int image_height, int sample_pixel,
233   int bitsallocated, int sign, int quality)
234 {
235   (void)quality;
236   (void)fragment_size;
237   int w, h;
238   int numcomps;
239   OPJ_COLOR_SPACE color_space;
240   opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
241   opj_image_t * image = NULL;
242
243   assert( sample_pixel == 1 || sample_pixel == 3 );
244   if( sample_pixel == 1 )
245     {
246     numcomps = 1;
247     color_space = CLRSPC_GRAY;
248     }
249   else // sample_pixel == 3
250     {
251     numcomps = 3;
252     color_space = CLRSPC_SRGB;
253     }
254   int subsampling_dx = parameters->subsampling_dx;
255   int subsampling_dy = parameters->subsampling_dy;
256
257   // FIXME
258   w = image_width;
259   h = image_height;
260
261   /* initialize image components */
262   memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
263   //assert( bitsallocated == 8 );
264   for(int i = 0; i < numcomps; i++) {
265     cmptparm[i].prec = bitsallocated;
266     cmptparm[i].bpp = bitsallocated;
267     cmptparm[i].sgnd = sign;
268     cmptparm[i].dx = subsampling_dx;
269     cmptparm[i].dy = subsampling_dy;
270     cmptparm[i].w = w;
271     cmptparm[i].h = h;
272   }
273
274   /* create the image */
275   image = opj_image_create(numcomps, &cmptparm[0], color_space);
276   if(!image) {
277     return NULL;
278   }
279   /* set image offset and reference grid */
280   image->x0 = parameters->image_offset_x0;
281   image->y0 = parameters->image_offset_y0;
282   image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
283   image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
284
285   /* set image data */
286
287   //assert( fragment_size == numcomps*w*h*(bitsallocated/8) );
288   if (bitsallocated <= 8)
289     {
290     if( sign )
291       {
292       rawtoimage_fill<int8_t>((int8_t*)inputbuffer,w,h,numcomps,image);
293       }
294     else
295       {
296       rawtoimage_fill<uint8_t>((uint8_t*)inputbuffer,w,h,numcomps,image);
297       }
298     }
299   else if (bitsallocated <= 16)
300     {
301     if( sign )
302       {
303       rawtoimage_fill<int16_t>((int16_t*)inputbuffer,w,h,numcomps,image);
304       }
305     else
306       {
307       rawtoimage_fill<uint16_t>((uint16_t*)inputbuffer,w,h,numcomps,image);
308       }
309     }
310   else if (bitsallocated <= 32)
311     {
312     if( sign )
313       {
314       rawtoimage_fill<int32_t>((int32_t*)inputbuffer,w,h,numcomps,image);
315       }
316     else
317       {
318       rawtoimage_fill<uint32_t>((uint32_t*)inputbuffer,w,h,numcomps,image);
319       }
320     }
321   else
322     {
323     abort();
324     }
325
326   return image;
327 }
328
329 /*
330  * The following function was copy paste from image_to_j2k.c with part from convert.c
331  */
332 bool gdcm_write_JPEG2000_file (std::ostream *fp, char *inputdata, size_t inputlength, 
333   int image_width, int image_height, int numZ, int sample_pixel, int bitsallocated,
334   int sign, int quality)
335 {
336 //// input_buffer is ONE image
337 //// fragment_size is the size of this image (fragment)
338   (void)numZ;
339   bool bSuccess;
340   //bool delete_comment = true;
341   opj_cparameters_t parameters;  /* compression parameters */
342   opj_event_mgr_t event_mgr;    /* event manager */
343   opj_image_t *image = NULL;
344   //quality = 100;
345
346   /*
347   configure the event callbacks (not required)
348   setting of each callback is optionnal
349   */
350   memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
351   event_mgr.error_handler = error_callback;
352   event_mgr.warning_handler = warning_callback;
353   event_mgr.info_handler = info_callback;
354
355   /* set encoding parameters to default values */
356   memset(&parameters, 0, sizeof(parameters));
357   opj_set_default_encoder_parameters(&parameters);
358
359   /* if no rate entered, lossless by default */
360   parameters.tcp_rates[0] = 0;
361   parameters.tcp_numlayers = 1;
362   parameters.cp_disto_alloc = 1;
363
364   if(parameters.cp_comment == NULL) {
365     const char comment[] = "Created by GDCM/OpenJPEG version 1.0";
366     parameters.cp_comment = (char*)malloc(strlen(comment) + 1);
367     strcpy(parameters.cp_comment, comment);
368     /* no need to delete parameters.cp_comment on exit */
369     //delete_comment = false;
370   }
371
372   
373   /* decode the source image */
374   /* ----------------------- */
375
376   image = rawtoimage((char*)inputdata, &parameters, 
377     static_cast<int>( inputlength ), 
378     image_width, image_height,
379     sample_pixel, bitsallocated, sign, quality);
380   if (!image) {
381     return 1;
382   }
383
384     /* encode the destination image */
385   /* ---------------------------- */
386    parameters.cod_format = J2K_CFMT; /* J2K format output */
387     int codestream_length;
388     opj_cio_t *cio = NULL;
389     //FILE *f = NULL;
390
391     /* get a J2K compressor handle */
392     opj_cinfo_t* cinfo = opj_create_compress(CODEC_J2K);
393
394     /* catch events using our callbacks and give a local context */
395     opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
396
397     /* setup the encoder parameters using the current image and using user parameters */
398     opj_setup_encoder(cinfo, &parameters, image);
399
400     /* open a byte stream for writing */
401     /* allocate memory for all tiles */
402     cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
403
404     /* encode the image */
405     bSuccess = opj_encode(cinfo, cio, image, parameters.index);
406     if (!bSuccess) {
407       opj_cio_close(cio);
408       fprintf(stderr, "failed to encode image\n");
409       return 1;
410     }
411     codestream_length = cio_tell(cio);
412
413     /* write the buffer to disk */
414     //f = fopen(parameters.outfile, "wb");
415     //if (!f) {
416     //  fprintf(stderr, "failed to open %s for writing\n", parameters.outfile);
417     //  return 1;
418     //}
419     //fwrite(cio->buffer, 1, codestream_length, f);
420 //#define MDEBUG
421 #ifdef MDEBUG
422     static int c = 0;
423     std::ostringstream os;
424     os << "/tmp/debug";
425     os << c;
426     c++;
427     os << ".j2k";
428     std::ofstream debug(os.str().c_str());
429     debug.write((char*)(cio->buffer), codestream_length);
430     debug.close();
431 #endif
432     fp->write((char*)(cio->buffer), codestream_length);
433     //fclose(f);
434
435     /* close and free the byte stream */
436     opj_cio_close(cio);
437
438     /* free remaining compression structures */
439     opj_destroy_compress(cinfo);
440
441
442       /* free user parameters structure */
443   //if(delete_comment) {
444     if(parameters.cp_comment) free(parameters.cp_comment);
445   //}
446   if(parameters.cp_matrice) free(parameters.cp_matrice);
447
448   /* free image data */
449   opj_image_destroy(image);
450
451
452
453
454   return true;
455 }
456
457 #if 0
458 // For openjpeg 0.97
459 bool gdcm_read_JPEG2000_file (void* raw, char *inputdata, size_t inputlength)
460 {
461    j2k_image_t img;
462    j2k_cp_t cp;
463  
464    // default blindly copied
465    cp.layer=0;
466    cp.reduce=0;
467    cp.decod_format=-1;
468    cp.cod_format=-1;
469  
470    cp.cod_format=J2K_CFMT;
471    cp.decod_format = PGX_DFMT;
472    int len = inputlength;
473    unsigned char *src = (unsigned char*)inputdata;
474  
475    // Decompression
476    if (!j2k_decode(src, len, &img, &cp))
477    {
478       gdcmStaticErrorMacro( "ERROR -> j2k_to_image: failed to decode image!" );
479       return false;
480    }
481  
482    // Copy buffer
483    for (int compno = 0; compno < img.numcomps; compno++)
484    {
485       j2k_comp_t *comp = &img.comps[compno];
486   
487       int w = img.comps[compno].w;
488       int wr = int_ceildivpow2(img.comps[compno].w, img.comps[compno].factor);
489   
490       //int h = img.comps[compno].h;
491       int hr = int_ceildivpow2(img.comps[compno].h, img.comps[compno].factor);
492   
493       if (comp->prec <= 8)
494       {
495          uint8_t *data8 = (uint8_t*)raw;
496          for (int i = 0; i < wr * hr; i++) 
497          {
498             int v = img.comps[compno].data[i / wr * w + i % wr];
499             *data8++ = (uint8_t)v;
500          }
501       }
502       else if (comp->prec <= 16)
503       {
504          uint16_t *data16 = (uint16_t*)raw;
505          for (int i = 0; i < wr * hr; i++) 
506          {
507             int v = img.comps[compno].data[i / wr * w + i % wr];
508             *data16++ = (uint16_t)v;
509          }
510       }
511       else
512       {
513          uint32_t *data32 = (uint32_t*)raw;
514          for (int i = 0; i < wr * hr; i++) 
515          {
516             int v = img.comps[compno].data[i / wr * w + i % wr];
517             *data32++ = (uint32_t)v;
518          }
519       }
520       free(img.comps[compno].data);
521    }
522  
523    // Free remaining structures
524    j2k_dec_release();
525    // FIXME
526    delete[] inputdata;
527  
528    return true;
529 }
530 #endif
531
532 #if 0
533 bool gdcm_read_JASPER_file (void* raw, char *inputdata, size_t inputlength)
534 {
535 #if 0
536   std::cerr << "Inputlenght=" << inputlength << std::endl;
537   std::ofstream out("/tmp/jpeg2000.jpc", std::ios::binary);
538   out.write((char*)inputdata,inputlength);
539   out.close();
540 #endif
541   jas_init(); //important...
542   jas_stream_t *jasStream = 
543     jas_stream_memopen((char *)inputdata, inputlength);
544     
545   int fmtid;
546   if ((fmtid = jas_image_getfmt(jasStream)) < 0) 
547     {
548     gdcmErrorMacro("unknown image format");
549     return false;
550     }
551
552   // Decode the image. 
553   jas_image_t *jasImage /* = NULL*/; // Useless assignation
554   if (!(jasImage = jas_image_decode(jasStream, fmtid, 0))) 
555     {
556     gdcmErrorMacro("cannot decode image");
557     return false;
558     }
559
560   // close the stream. 
561   jas_stream_close(jasStream);
562   int numcmpts = jas_image_numcmpts(jasImage);
563   int width = jas_image_cmptwidth(jasImage, 0);
564   int height = jas_image_cmptheight(jasImage, 0);
565   int prec = jas_image_cmptprec(jasImage, 0);
566   int i, j, k;
567
568   // The following should serioulsy be rewritten I cannot believe we need to
569   // do a per pixel decompression, there should be a way to read a full
570   // scanline...
571   if (prec == 8)
572     {
573     uint8_t *data8 = (uint8_t*)raw;
574     for ( i = 0; i < height; i++)
575       for ( j = 0; j < width; j++)
576         for ( k= 0; k < numcmpts; k++)
577           *data8++ = (uint8_t)(jas_image_readcmptsample(jasImage, k, j ,i ));
578     }
579   else if (prec <= 16)
580     {
581     uint16_t *data16 = (uint16_t*)raw;
582     for ( i = 0; i < height; i++) 
583       for ( j = 0; j < width; j++) 
584         for ( k= 0; k < numcmpts; k++)
585           *data16++ = (uint16_t)(jas_image_readcmptsample(jasImage, k, j ,i ));
586     }
587   else if (prec <= 32)
588     {
589     uint32_t *data32 = (uint32_t*)raw;
590     for ( i = 0; i < height; i++) 
591       for ( j = 0; j < width; j++) 
592         for ( k= 0; k < numcmpts; k++)
593           *data32++ = (uint32_t)(jas_image_readcmptsample(jasImage, k, j ,i ));
594     }
595
596   jas_image_destroy(jasImage);
597   jas_image_clearfmts();
598
599   //FIXME
600   //delete the jpeg temp buffer
601 #if 0
602   std::ofstream rawout("/tmp/jpeg2000.raw");
603   rawout.write((char*)raw,height*width*numcmpts*((prec+4)/8));
604   rawout.close();
605 #endif
606   delete[] inputdata;
607
608   return true;
609 }
610 #endif
611
612 //-----------------------------------------------------------------------------
613 } // end namespace gdcm
614