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