]> Creatis software - gdcm.git/blob - src/gdcmJpeg.cxx
- Color problems taken in to account
[gdcm.git] / src / gdcmJpeg.cxx
1 #include <stdio.h>
2 #include "gdcmFile.h"
3
4 // for jpeglib defined BITS_IN_JSAMPLE
5 #include "jpeg/libijg8/jBitsInJsample.h"
6 // FIXME : find something else when both 
7 // libJpeg8 and libJpeg12 will be active
8
9 #define DEBUG 0
10
11 /*
12 DICOM provides a mechanism for supporting the use of JPEG Image Compression 
13 through the Encapsulated Format (see PS 3.3 of the DICOM Standard). 
14 Annex A defines a number of Transfer Syntaxes which reference 
15 the JPEG Standard and provide a number of lossless (bit preserving) 
16 and lossy compression schemes.
17 In order to facilitate interoperability of implementations conforming 
18 to the DICOM Standard which elect to use one or more 
19 of the Transfer Syntaxes for JPEG Image Compression, the following policy is specified:
20
21   Any implementation which conforms to the DICOM Standard and has elected 
22   to support any one of the Transfer Syntaxes for lossless JPEG Image Compression, 
23   shall support the following lossless compression: 
24   The subset (first-order horizontal prediction [Selection Value 1) of JPEG Process 14 
25   (DPCM, non-hierarchical with Huffman coding) (see Annex F of the DICOM Standard).
26
27    Any implementation which conforms to the DICOM Standard and has elected 
28    to support any one of the Transfer Syntaxes for 8-bit lossy JPEG Image Compression, 
29    shall support the JPEG Baseline Compression (coding Process 1).
30
31    Any implementation which conforms to the DICOM Standard and has elected 
32    to support any one of the Transfer Syntaxes for 12-bit lossy JPEG Image Compression, 
33    shall support the JPEG Compression Process 4.
34
35 Note: The DICOM conformance statement shall differentiate between implementations 
36 that can simply receive JPEG encoded images and those that can receive and process 
37 JPEG encoded images (see PS 3.2 of the DICOM Standard).
38
39 The use of the DICOM Encapsulated Format to support JPEG Compressed Pixel Data 
40 implies that the Data Elements which are related to the Native Format Pixel Data encoding
41 (e.g. Bits Allocated, Bits Stored, High Bit, Pixel Representation, Rows, Columns, etc.) 
42 shall contain values which are consistent with the characteristics 
43 of the uncompressed pixel data from which the compressed Data Stream was derived. 
44 The Pixel Data characteristics included in the JPEG Interchange Format 
45 shall be used to decode the compressed data stream.
46
47 Run Length Encoding Compression
48
49 DICOM provides a mechanism for supporting the use of Run Length Encoding (RLE) 
50 Compression which is a byte oriented lossless compression scheme through 
51 the encapsulated Format (see PS 3.3 of this Standard). 
52 Annex G of the DICOM Standard defines RLE Compression and its Transfer Syntax.
53
54 Note: The RLE Compression algorithm described in Annex G 
55 of the DICOM Standard is the compression used in 
56 the TIFF 6.0 specification known as the "PackBits" scheme.
57
58 The use of the DICOM Encapsulated Format to support RLE Compressed Pixel Data 
59 implies that the Data Elements which are related to the Native Format Pixel Data encoding (
60 e.g. Bits Allocated, Bits Stored, High Bit, Pixel Representation, Rows, Columns, etc.) 
61 shall contain values which are consistent with the characteristics 
62 of the uncompressed pixel data from which the compressed data is derived
63 */
64
65 /*
66  * <setjmp.h> is used for the optional error recovery mechanism shown in
67  * the second part of the example.
68  */
69
70 /*
71  * Include file for users of JPEG library.
72  * You will need to have included system headers that define at least
73  * the typedefs FILE and size_t before you can include jpeglib.h.
74  * (stdio.h is sufficient on ANSI-conforming systems.)
75  * You may also wish to include "jerror.h".
76  */
77
78 extern "C" {
79 #include "jpeglib.h"
80 #include <setjmp.h>
81 }
82
83 /******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
84
85 /* This half of the example shows how to read data from the JPEG decompressor.
86  * It's a bit more refined than the above, in that we show:
87  *   (a) how to modify the JPEG library's standard error-reporting behavior;
88  *   (b) how to allocate workspace using the library's memory manager.
89  *
90  * Just to make this example a little different from the first one, we'll
91  * assume that we do not intend to put the whole image into an in-memory
92  * buffer, but to send it line-by-line someplace else.  We need a one-
93  * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG
94  * memory manager allocate it for us.  This approach is actually quite useful
95  * because we don't need to remember to deallocate the buffer separately: it
96  * will go away automatically when the JPEG object is cleaned up.
97  */
98
99 /*
100  * ERROR HANDLING:
101  *
102  * The JPEG library's standard error handler (jerror.c) is divided into
103  * several "methods" which you can override individually.  This lets you
104  * adjust the behavior without duplicating a lot of code, which you might
105  * have to update with each future release.
106  *
107  * Our example here shows how to override the "error_exit" method so that
108  * control is returned to the library's caller when a fatal error occurs,
109  * rather than calling exit() as the standard error_exit method does.
110  *
111  * We use C's setjmp/longjmp facility to return control.  This means that the
112  * routine which calls the JPEG library must first execute a setjmp() call to
113  * establish the return point.  We want the replacement error_exit to do a
114  * longjmp().  But we need to make the setjmp buffer accessible to the
115  * error_exit routine.  To do this, we make a private extension of the
116  * standard JPEG error handler object.  (If we were using C++, we'd say we
117  * were making a subclass of the regular error handler.)
118  *
119  * Here's the extended error handler struct:
120  */
121
122 struct my_error_mgr {
123   struct jpeg_error_mgr pub;    /* "public" fields */
124   jmp_buf setjmp_buffer;        /* for return to caller */
125 };
126
127 typedef struct my_error_mgr * my_error_ptr;
128
129 /*
130  * Here's the routine that will replace the standard error_exit method:
131  */
132
133 METHODDEF(void)
134 my_error_exit (j_common_ptr cinfo) {
135   /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
136   my_error_ptr myerr = (my_error_ptr) cinfo->err;
137
138   /* Always display the message. */
139   /* We could postpone this until after returning, if we chose. */
140   (*cinfo->err->output_message) (cinfo);
141
142   /* Return control to the setjmp point */
143   longjmp(myerr->setjmp_buffer, 1);
144 }
145
146
147 /*
148  * Sample routine for JPEG decompression.  We assume that the source file name
149  * is passed in.  We want to return 1 on success, 0 on error.
150  */
151
152
153 //GLOBAL(int)
154 int
155 gdcmFile::gdcm_read_JPEG_file (void * image_buffer) {
156
157 char *pimage;
158
159   /* This struct contains the JPEG decompression parameters and pointers to
160    * working space (which is allocated as needed by the JPEG library).
161    */
162    
163   struct jpeg_decompress_struct cinfo;
164   
165   /* -------------- inside, we found :
166   JDIMENSION image_width;       // input image width 
167   JDIMENSION image_height;      // input image height 
168   int input_components;         // nb of color components in input image 
169   J_COLOR_SPACE in_color_space; // colorspace of input image 
170   double input_gamma;           // image gamma of input image 
171      -------------- */
172   
173   /* We use our private extension JPEG error handler.
174    * Note that this struct must live as long as the main JPEG parameter
175    * struct, to avoid dangling-pointer problems.
176    */
177   struct my_error_mgr jerr;
178   /* More stuff */
179  
180   JSAMPARRAY buffer;            /* Output row buffer */
181   
182   // rappel :
183   // ------
184   // typedef unsigned char JSAMPLE;
185   // typedef JSAMPLE FAR *JSAMPROW;     /* ptr to one image row of pixel samples. */
186   // typedef JSAMPROW *JSAMPARRAY;      /* ptr to some rows (a 2-D sample array) */
187   // typedef JSAMPARRAY *JSAMPIMAGE;    /* a 3-D sample array: top index is color */
188   
189  
190   int row_stride;               /* physical row width in output buffer */
191   
192  if (DEBUG) printf("entree dans gdcmFile::gdcm_read_JPEG_file, depuis gdcmJpeg\n");
193
194
195   /* In this example we want to open the input file before doing anything else,
196    * so that the setjmp() error recovery below can assume the file is open.
197    * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
198    * requires it in order to read binary files.
199    */
200
201   /* Step 1: allocate and initialize JPEG decompression object */
202   
203   if (DEBUG)printf("Entree Step 1\n");
204
205   /* We set up the normal JPEG error routines, then override error_exit. */
206   
207   cinfo.err = jpeg_std_error(&jerr.pub);
208   jerr.pub.error_exit = my_error_exit;
209   
210   /* Establish the setjmp return context for my_error_exit to use. */
211   
212   if (setjmp(jerr.setjmp_buffer)) {
213     /* If we get here, the JPEG code has signaled an error.
214      * We need to clean up the JPEG object, close the input file, and return.
215      */
216     jpeg_destroy_decompress(&cinfo);
217     return 0;
218   }
219   /* Now we can initialize the JPEG decompression object. */
220   jpeg_create_decompress(&cinfo);
221
222   /* Step 2: specify data source (eg, a file) */
223   
224 if (DEBUG) printf("Entree Step 2\n");
225
226   jpeg_stdio_src(&cinfo, fp);
227
228   /* Step 3: read file parameters with jpeg_read_header() */
229
230  if (DEBUG) printf("Entree Step 3\n");
231
232   (void) jpeg_read_header(&cinfo, TRUE);
233    
234   /* We can ignore the return value from jpeg_read_header since
235    *   (a) suspension is not possible with the stdio data source, and
236    *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
237    * See libjpeg.doc for more info.
238    */
239
240 if (DEBUG) {   
241         printf("--------------Header contents :----------------\n");
242         printf("image_width %d image_height %d\n", 
243                                 cinfo.image_width , cinfo.image_height);
244         printf("bits of precision in image data  %d \n", 
245                                 cinfo.output_components);
246         printf("nb of color components returned  %d \n", 
247                                 cinfo.data_precision);
248 }
249
250
251 /*
252   JDIMENSION image_width;       // input image width 
253   JDIMENSION image_height;      // input image height 
254   int output_components;        // # of color components returned 
255   J_COLOR_SPACE in_color_space; // colorspace of input image 
256   double input_gamma;           // image gamma of input image
257   int data_precision;           // bits of precision in image data 
258  
259 */
260
261   /* Step 4: set parameters for decompression */
262   
263  if (DEBUG) printf("Entree Step 4\n");
264
265   /* In this example, we don't need to change any of the defaults set by
266    * jpeg_read_header(), so we do nothing here.
267    */
268
269   /* Step 5: Start decompressor */
270   
271  if (DEBUG) printf("Entree Step 5\n");
272
273   (void) jpeg_start_decompress(&cinfo);
274   /* We can ignore the return value since suspension is not possible
275    * with the stdio data source.
276    */
277    
278   /* We may need to do some setup of our own at this point before reading
279    * the data.  After jpeg_start_decompress() we have the correct scaled
280    * output image dimensions available, as well as the output colormap
281    * if we asked for color quantization.
282    * In this example, we need to make an output work buffer of the right size.
283    */ 
284    
285   /* JSAMPLEs per row in output buffer */
286   row_stride = cinfo.output_width * cinfo.output_components;
287   
288  if (DEBUG) printf ("cinfo.output_width %d cinfo.output_components %d  row_stride %d\n",
289         cinfo.output_width, cinfo.output_components,row_stride);
290         
291   /* Make a one-row-high sample array that will go away when done with image */
292   buffer = (*cinfo.mem->alloc_sarray)
293                 ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
294
295   /* Step 6: while (scan lines remain to be read) */
296   
297  if (DEBUG)  printf("Entree Step 6\n"); 
298
299   /*           jpeg_read_scanlines(...); */
300
301   /* Here we use the library's state variable cinfo.output_scanline as the
302    * loop counter, so that we don't have to keep track ourselves.
303    */
304    
305  if (DEBUG)  printf ("cinfo.output_height %d  cinfo.output_width %d\n",
306                         cinfo.output_height,cinfo.output_width);
307  
308   pimage=(char *)image_buffer;
309   
310   
311   while (cinfo.output_scanline < cinfo.output_height) {
312     /* jpeg_read_scanlines expects an array of pointers to scanlines.
313      * Here the array is only one element long, but you could ask for
314      * more than one scanline at a time if that's more convenient.
315      */
316      
317      // l'image est deja allouée (et passée en param)
318      // on ecrit directement les pixels
319      // (on DEVRAIT pouvoir)
320     
321     //(void) jpeg_read_scanlines(&cinfo, pimage, 1);
322     
323      (void) jpeg_read_scanlines(&cinfo, buffer, 1);
324       
325      if ( BITS_IN_JSAMPLE == 8) {
326          memcpy( pimage, buffer[0],row_stride); 
327          pimage+=row_stride;
328      } else {
329          memcpy( pimage, buffer[0],row_stride*2 ); // FIXME : *2  car 16 bits?!?
330          pimage+=row_stride*2;                     // FIXME : *2 car 16 bits?!?     
331      }
332   }
333  
334   /* Step 7: Finish decompression */
335   
336 if (DEBUG)  printf("Entree Step 7\n");
337
338   (void) jpeg_finish_decompress(&cinfo);
339   /* We can ignore the return value since suspension is not possible
340    * with the stdio data source.
341    */
342
343   /* Step 8: Release JPEG decompression object */
344   
345 if (DEBUG) printf("Entree Step 8\n");
346
347   /* This is an important step since it will release a good deal of memory. */
348   
349   jpeg_destroy_decompress(&cinfo);
350
351   /* After finish_decompress, we can close the input file.
352    * Here we postpone it until after no more JPEG errors are possible,
353    * so as to simplify the setjmp error logic above.  (Actually, I don't
354    * think that jpeg_destroy can do an error exit, but why assume anything...)
355    */
356
357   /* At this point you may want to check to see whether any corrupt-data
358    * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
359    */
360
361   /* And we're done! */
362   
363   return 1;
364 }
365
366 /*
367  * SOME FINE POINTS:
368  *
369  * In the above code, we ignored the return value of jpeg_read_scanlines,
370  * which is the number of scanlines actually read.  We could get away with
371  * this because we asked for only one line at a time and we weren't using
372  * a suspending data source.  See libjpeg.doc for more info.
373  *
374  * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();
375  * we should have done it beforehand to ensure that the space would be
376  * counted against the JPEG max_memory setting.  In some systems the above
377  * code would risk an out-of-memory error.  However, in general we don't
378  * know the output image dimensions before jpeg_start_decompress(), unless we
379  * call jpeg_calc_output_dimensions().  See libjpeg.doc for more about this.
380  *
381  * Scanlines are returned in the same order as they appear in the JPEG file,
382  * which is standardly top-to-bottom.  If you must emit data bottom-to-top,
383  * you can use one of the virtual arrays provided by the JPEG memory manager
384  * to invert the data.  See wrbmp.c for an example.
385  *
386  * As with compression, some operating modes may require temporary files.
387  * On some systems you may need to set up a signal handler to ensure that
388  * temporary files are deleted if the program is interrupted.  See libjpeg.doc.
389  */
390  
391
392
393
394
395  
396