X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmJpeg.cxx;h=f4e8862c31f16ac27785ec35bddd575664d0b73a;hb=e7768bbebdc9a5972e396d71a3e848f5674ee378;hp=4796cb46f570fc72c8fda1901a40f41cbcb17f88;hpb=b158878c883def8179e3eccc27fcea5bb6035a4c;p=gdcm.git diff --git a/src/gdcmJpeg.cxx b/src/gdcmJpeg.cxx index 4796cb46..f4e8862c 100644 --- a/src/gdcmJpeg.cxx +++ b/src/gdcmJpeg.cxx @@ -1,396 +1,422 @@ -#include -#include "gdcmFile.h" +/*========================================================================= + + Program: gdcm + Module: $RCSfile: gdcmJpeg.cxx,v $ + Language: C++ + Date: $Date: 2007/08/30 17:37:16 $ + Version: $Revision: 1.59 $ + + Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de + l'Image). All rights reserved. See Doc/License.txt or + http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#include "gdcmFileHelper.h" +#include "gdcmJPEGFragment.h" +#include "gdcmDebug.h" + +#if defined(__sgi) && !defined(__GNUC__) +// Try to get rid of the warning: +//cc-3505 CC: WARNING File = /usr/include/internal/setjmp_core.h, Line = 74 +// setjmp not marked as unknown_control_flow because it is not declared as a +// function +// +// #pragma unknown_control_flow (setjmp) +# if (_COMPILER_VERSION >= 730) +# pragma set woff 3505 +# endif +#endif +#ifdef _MSC_VER +// Let us get rid of this funny warning on /W4: +// warning C4611: interaction between '_setjmp' and C++ object +// destruction is non-portable +#pragma warning( disable : 4611 ) +#endif -// for jpeglib defined BITS_IN_JSAMPLE -#include "jpeg/libijg8/jBitsInJsample.h" -// FIXME : find something else when both -// libJpeg8 and libJpeg12 will be active - -#define DEBUG 0 - -/* -DICOM provides a mechanism for supporting the use of JPEG Image Compression -through the Encapsulated Format (see PS 3.3 of the DICOM Standard). -Annex A defines a number of Transfer Syntaxes which reference -the JPEG Standard and provide a number of lossless (bit preserving) -and lossy compression schemes. -In order to facilitate interoperability of implementations conforming -to the DICOM Standard which elect to use one or more -of the Transfer Syntaxes for JPEG Image Compression, the following policy is specified: - - Any implementation which conforms to the DICOM Standard and has elected - to support any one of the Transfer Syntaxes for lossless JPEG Image Compression, - shall support the following lossless compression: - The subset (first-order horizontal prediction [Selection Value 1) of JPEG Process 14 - (DPCM, non-hierarchical with Huffman coding) (see Annex F of the DICOM Standard). - - Any implementation which conforms to the DICOM Standard and has elected - to support any one of the Transfer Syntaxes for 8-bit lossy JPEG Image Compression, - shall support the JPEG Baseline Compression (coding Process 1). - - Any implementation which conforms to the DICOM Standard and has elected - to support any one of the Transfer Syntaxes for 12-bit lossy JPEG Image Compression, - shall support the JPEG Compression Process 4. - -Note: The DICOM conformance statement shall differentiate between implementations -that can simply receive JPEG encoded images and those that can receive and process -JPEG encoded images (see PS 3.2 of the DICOM Standard). - -The use of the DICOM Encapsulated Format to support JPEG Compressed Pixel Data -implies that the Data Elements which are related to the Native Format Pixel Data encoding -(e.g. Bits Allocated, Bits Stored, High Bit, Pixel Representation, Rows, Columns, etc.) -shall contain values which are consistent with the characteristics -of the uncompressed pixel data from which the compressed Data Stream was derived. -The Pixel Data characteristics included in the JPEG Interchange Format -shall be used to decode the compressed data stream. - -Run Length Encoding Compression - -DICOM provides a mechanism for supporting the use of Run Length Encoding (RLE) -Compression which is a byte oriented lossless compression scheme through -the encapsulated Format (see PS 3.3 of this Standard). -Annex G of the DICOM Standard defines RLE Compression and its Transfer Syntax. - -Note: The RLE Compression algorithm described in Annex G -of the DICOM Standard is the compression used in -the TIFF 6.0 specification known as the "PackBits" scheme. - -The use of the DICOM Encapsulated Format to support RLE Compressed Pixel Data -implies that the Data Elements which are related to the Native Format Pixel Data encoding ( -e.g. Bits Allocated, Bits Stored, High Bit, Pixel Representation, Rows, Columns, etc.) -shall contain values which are consistent with the characteristics -of the uncompressed pixel data from which the compressed data is derived -*/ - -/* - * is used for the optional error recovery mechanism shown in - * the second part of the example. - */ - -/* - * Include file for users of JPEG library. - * You will need to have included system headers that define at least - * the typedefs FILE and size_t before you can include jpeglib.h. - * (stdio.h is sufficient on ANSI-conforming systems.) - * You may also wish to include "jerror.h". - */ - -extern "C" { -#include "jpeglib.h" #include -} - -/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/ - -/* This half of the example shows how to read data from the JPEG decompressor. - * It's a bit more refined than the above, in that we show: - * (a) how to modify the JPEG library's standard error-reporting behavior; - * (b) how to allocate workspace using the library's memory manager. - * - * Just to make this example a little different from the first one, we'll - * assume that we do not intend to put the whole image into an in-memory - * buffer, but to send it line-by-line someplace else. We need a one- - * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG - * memory manager allocate it for us. This approach is actually quite useful - * because we don't need to remember to deallocate the buffer separately: it - * will go away automatically when the JPEG object is cleaned up. - */ - -/* - * ERROR HANDLING: - * - * The JPEG library's standard error handler (jerror.c) is divided into - * several "methods" which you can override individually. This lets you - * adjust the behavior without duplicating a lot of code, which you might - * have to update with each future release. - * - * Our example here shows how to override the "error_exit" method so that - * control is returned to the library's caller when a fatal error occurs, - * rather than calling exit() as the standard error_exit method does. - * - * We use C's setjmp/longjmp facility to return control. This means that the - * routine which calls the JPEG library must first execute a setjmp() call to - * establish the return point. We want the replacement error_exit to do a - * longjmp(). But we need to make the setjmp buffer accessible to the - * error_exit routine. To do this, we make a private extension of the - * standard JPEG error handler object. (If we were using C++, we'd say we - * were making a subclass of the regular error handler.) - * - * Here's the extended error handler struct: - */ - -struct my_error_mgr { - struct jpeg_error_mgr pub; /* "public" fields */ - jmp_buf setjmp_buffer; /* for return to caller */ -}; - -typedef struct my_error_mgr * my_error_ptr; - -/* - * Here's the routine that will replace the standard error_exit method: - */ - -METHODDEF(void) -my_error_exit (j_common_ptr cinfo) { - /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ - my_error_ptr myerr = (my_error_ptr) cinfo->err; - - /* Always display the message. */ - /* We could postpone this until after returning, if we chose. */ - (*cinfo->err->output_message) (cinfo); - - /* Return control to the setjmp point */ - longjmp(myerr->setjmp_buffer, 1); -} - - -/* - * Sample routine for JPEG decompression. We assume that the source file name - * is passed in. We want to return 1 on success, 0 on error. +#include + +#if defined(__BORLANDC__) + #include // for memset +#endif + +#include "jdatasrc.cxx" +#include "jdatadst.cxx" + +namespace GDCM_NAME_SPACE +{ + + /** + * \brief routine for JPEG decompression + * @param fp pointer to an already open file descriptor + * 8 significant bits per pixel + * @param im_buf Points to array (of R,G,B-order) data to compress + * @param quality compression quality + * @param image_height Number of rows in image + * @param image_width Number of columns in image + * @return 1 on success, 0 on error */ +bool gdcm_write_JPEG_file (std::ostream *fp, char *inputdata, size_t inputlength, + int image_width, int image_height, int numZ, + int sample_pixel, int bitsallocated, int quality) +{ + (void)bitsallocated; + struct jpeg_compress_struct cinfo; + int row_stride; /* physical row width in image buffer */ -//GLOBAL(int) -int -gdcmFile::gdcm_read_JPEG_file (void * image_buffer) { - -char *pimage; - - /* This struct contains the JPEG decompression parameters and pointers to + /* This struct contains the JPEG compression parameters and pointers to * working space (which is allocated as needed by the JPEG library). + * It is possible to have several such structures, representing multiple + * compression/decompression processes, in existence at once. We refer + * to any one struct (and its associated working data) as a "JPEG object". */ - - struct jpeg_decompress_struct cinfo; - - /* -------------- inside, we found : - JDIMENSION image_width; // input image width - JDIMENSION image_height; // input image height - int input_components; // nb of color components in input image - J_COLOR_SPACE in_color_space; // colorspace of input image - double input_gamma; // image gamma of input image - -------------- */ - - /* We use our private extension JPEG error handler. + //struct jpeg_compress_struct cinfo; + /* This struct represents a JPEG error handler. It is declared separately + * because applications often want to supply a specialized error handler + * (see the second half of this file for an example). But here we just + * take the easy way out and use the standard error handler, which will + * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ - struct my_error_mgr jerr; + struct jpeg_error_mgr jerr; /* More stuff */ - - JSAMPARRAY buffer; /* Output row buffer */ - - // rappel : - // ------ - // typedef unsigned char JSAMPLE; - // typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ - // typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ - // typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ - - - int row_stride; /* physical row width in output buffer */ - - if (DEBUG) printf("entree dans gdcmFile::gdcm_read_JPEG_file, depuis gdcmJpeg\n"); + /* Step 1: allocate and initialize JPEG compression object */ - /* In this example we want to open the input file before doing anything else, - * so that the setjmp() error recovery below can assume the file is open. - * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that - * requires it in order to read binary files. + /* We have to set up the error handler first, in case the initialization + * step fails. (Unlikely, but it could happen if you are out of memory.) + * This routine fills in the contents of struct jerr, and returns jerr's + * address which we place into the link field in cinfo. */ + cinfo.err = jpeg_std_error(&jerr); + /* Now we can initialize the JPEG compression object. */ + jpeg_create_compress(&cinfo); - /* Step 1: allocate and initialize JPEG decompression object */ - - if (DEBUG)printf("Entree Step 1\n"); - - /* We set up the normal JPEG error routines, then override error_exit. */ - - cinfo.err = jpeg_std_error(&jerr.pub); - jerr.pub.error_exit = my_error_exit; - - /* Establish the setjmp return context for my_error_exit to use. */ - - if (setjmp(jerr.setjmp_buffer)) { - /* If we get here, the JPEG code has signaled an error. - * We need to clean up the JPEG object, close the input file, and return. - */ - jpeg_destroy_decompress(&cinfo); - return 0; - } - /* Now we can initialize the JPEG decompression object. */ - jpeg_create_decompress(&cinfo); - - /* Step 2: specify data source (eg, a file) */ - -if (DEBUG) printf("Entree Step 2\n"); - - jpeg_stdio_src(&cinfo, fp); + /* Step 2: specify data destination (eg, a file) */ + /* Note: steps 2 and 3 can be done in either order. */ - /* Step 3: read file parameters with jpeg_read_header() */ + int fragment_size = static_cast< int >( inputlength ); + jpeg_stdio_dest(&cinfo, fp, fragment_size, 1); - if (DEBUG) printf("Entree Step 3\n"); + /* Step 3: set parameters for compression */ - (void) jpeg_read_header(&cinfo, TRUE); - - /* We can ignore the return value from jpeg_read_header since - * (a) suspension is not possible with the stdio data source, and - * (b) we passed TRUE to reject a tables-only JPEG file as an error. - * See libjpeg.doc for more info. + /* First we supply a description of the input image. + * Four fields of the cinfo struct must be filled in: */ - -if (DEBUG) { - printf("--------------Header contents :----------------\n"); - printf("image_width %d image_height %d\n", - cinfo.image_width , cinfo.image_height); - printf("bits of precision in image data %d \n", - cinfo.output_components); - printf("nb of color components returned %d \n", - cinfo.data_precision); -} - - -/* - JDIMENSION image_width; // input image width - JDIMENSION image_height; // input image height - int output_components; // # of color components returned - J_COLOR_SPACE in_color_space; // colorspace of input image - double input_gamma; // image gamma of input image - int data_precision; // bits of precision in image data - -*/ - - /* Step 4: set parameters for decompression */ - - if (DEBUG) printf("Entree Step 4\n"); - - /* In this example, we don't need to change any of the defaults set by - * jpeg_read_header(), so we do nothing here. + cinfo.image_width = image_width;/* image width and height, in pixels */ + cinfo.image_height = image_height; + if ( sample_pixel == 3 ) + { + cinfo.input_components = 3; /* # of color components per pixel */ + cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ + } + else + { + cinfo.input_components = 1; /* # of color components per pixel */ + cinfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */ + } + /* Now use the library's routine to set default compression parameters. + * (You must set at least cinfo.in_color_space before calling this, + * since the defaults depend on the source color space.) + */ + jpeg_set_defaults(&cinfo); + /* + * http://www.koders.com/c/fid80DBBF1D49D004EF71CE7C493C34610C4F17D3D3.aspx + * http://studio.imagemagick.org/pipermail/magick-users/2002-September/004685.html + * You need to set -quality 101 or greater. If quality is 100 or less you + * get regular JPEG output. This is not explained in the documentation, only + * in the comments in coder/jpeg.c. When you have configured libjpeg with + * lossless support, then + * + * quality=predictor*100 + point_transform + * + * If you don't know what these values should be, just use 101. + * They only affect the compression ratio, not the image appearance, + * which is lossless. + */ + jpeg_simple_lossless (&cinfo, 1, 0); + /* Now you can set any non-default parameters you wish to. + * Here we just illustrate the use of quality (quantization table) scaling: */ + jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); - /* Step 5: Start decompressor */ - - if (DEBUG) printf("Entree Step 5\n"); + /* Step 4: Start compressor */ - (void) jpeg_start_decompress(&cinfo); - /* We can ignore the return value since suspension is not possible - * with the stdio data source. + /* TRUE ensures that we will write a complete interchange-JPEG file. + * Pass TRUE unless you are very sure of what you're doing. */ - - /* We may need to do some setup of our own at this point before reading - * the data. After jpeg_start_decompress() we have the correct scaled - * output image dimensions available, as well as the output colormap - * if we asked for color quantization. - * In this example, we need to make an output work buffer of the right size. - */ - - /* JSAMPLEs per row in output buffer */ - row_stride = cinfo.output_width * cinfo.output_components; - - if (DEBUG) printf ("cinfo.output_width %d cinfo.output_components %d row_stride %d\n", - cinfo.output_width, cinfo.output_components,row_stride); - - /* Make a one-row-high sample array that will go away when done with image */ - buffer = (*cinfo.mem->alloc_sarray) - ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); - - /* Step 6: while (scan lines remain to be read) */ - - if (DEBUG) printf("Entree Step 6\n"); + jpeg_start_compress(&cinfo, TRUE); - /* jpeg_read_scanlines(...); */ + /* Step 5: while (scan lines remain to be written) */ + /* jpeg_write_scanlines(...); */ - /* Here we use the library's state variable cinfo.output_scanline as the + /* Here we use the library's state variable cinfo.next_scanline as the * loop counter, so that we don't have to keep track ourselves. + * To keep things simple, we pass one scanline per call; you can pass + * more if you wish, though. */ - - if (DEBUG) printf ("cinfo.output_height %d cinfo.output_width %d\n", - cinfo.output_height,cinfo.output_width); - - pimage=(char *)image_buffer; - - - while (cinfo.output_scanline < cinfo.output_height) { - /* jpeg_read_scanlines expects an array of pointers to scanlines. - * Here the array is only one element long, but you could ask for + if (sample_pixel == 3) + { + row_stride = image_width * 3;/* JSAMPLEs per row in image_buffer */ + } + else + { + assert( sample_pixel == 1 ); + row_stride = image_width * 1;/* JSAMPLEs per row in image_buffer */ + } + + (void)numZ; + + uint8_t* input_buffer = (uint8_t*)inputdata; + //uint8_t *pbuffer = input_buffer; + //int i; + //for(i=0; itellp(); +// std::cerr << "DIFF: " << end-beg << std::endl; - /* Step 8: Release JPEG decompression object */ - -if (DEBUG) printf("Entree Step 8\n"); +// JpegPair &jp = v[i]; +// jp.second = end-beg; + //beg = end; // + // } - /* This is an important step since it will release a good deal of memory. */ - - jpeg_destroy_decompress(&cinfo); + /* Step 6: Finish compression */ - /* After finish_decompress, we can close the input file. - * Here we postpone it until after no more JPEG errors are possible, - * so as to simplify the setjmp error logic above. (Actually, I don't - * think that jpeg_destroy can do an error exit, but why assume anything...) - */ + jpeg_finish_compress(&cinfo); - /* At this point you may want to check to see whether any corrupt-data - * warnings occurred (test whether jerr.pub.num_warnings is nonzero). - */ + /* Step 7: release JPEG compression object */ + + /* This is an important step since it will release a good deal of memory. */ + jpeg_destroy_compress(&cinfo); /* And we're done! */ - - return 1; + + return true; } +//----------------------------------------------------------------------------- +struct my_error_mgr { + struct jpeg_error_mgr pub; /* "public" fields */ + jmp_buf setjmp_buffer; /* for return to caller */ +}; +typedef struct my_error_mgr* my_error_ptr; +//----------------------------------------------------------------------------- + /* - * SOME FINE POINTS: - * - * In the above code, we ignored the return value of jpeg_read_scanlines, - * which is the number of scanlines actually read. We could get away with - * this because we asked for only one line at a time and we weren't using - * a suspending data source. See libjpeg.doc for more info. - * - * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress(); - * we should have done it beforehand to ensure that the space would be - * counted against the JPEG max_memory setting. In some systems the above - * code would risk an out-of-memory error. However, in general we don't - * know the output image dimensions before jpeg_start_decompress(), unless we - * call jpeg_calc_output_dimensions(). See libjpeg.doc for more about this. - * - * Scanlines are returned in the same order as they appear in the JPEG file, - * which is standardly top-to-bottom. If you must emit data bottom-to-top, - * you can use one of the virtual arrays provided by the JPEG memory manager - * to invert the data. See wrbmp.c for an example. - * - * As with compression, some operating modes may require temporary files. - * On some systems you may need to set up a signal handler to ensure that - * temporary files are deleted if the program is interrupted. See libjpeg.doc. + * Here's the routine that will replace the standard error_exit method: */ +extern "C" { +METHODDEF(void) my_error_exit (j_common_ptr cinfo) { + /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ + my_error_ptr myerr = (my_error_ptr) cinfo->err; + + /* Always display the message. */ + /* We could postpone this until after returning, if we chose. */ + (*cinfo->err->output_message) (cinfo); + + /* Return control to the setjmp point */ + longjmp(myerr->setjmp_buffer, 1); +} + +//METHODDEF(void) my_output_message (j_common_ptr cinfo) +//{ +// char buffer[JMSG_LENGTH_MAX]; +// +// /* Create the message */ +// (*cinfo->err->format_message) (cinfo, buffer); +// +// // Custom display message, we could be more fancy and throw an exception: +// gdcmStaticErrorMacro( buffer ); +//} + +} +//----------------------------------------------------------------------------- +/** + * \brief routine for JPEG decompression + * @param fp pointer to an already open file descriptor + * 8 significant bits per pixel + * @param image_buffer to receive uncompressed pixels + * @param statesuspension Suspension State basically it should be 3 otherwise more complex to handle + * @return 1 on success, 0 on error + */ +void *SampBuffer; +bool JPEGFragment::ReadJPEGFile (std::ifstream *fp, void *image_buffer, int &statesuspension) +{ + pImage = (uint8_t*)image_buffer; + // This struct contains the JPEG decompression parameters and pointers to + // working space (which is allocated as needed by the JPEG library). + + static struct jpeg_decompress_struct cinfo; + + // -------------- inside, we found : + // JDIMENSION image_width; // input image width + // JDIMENSION image_height; // input image height + // int input_components; // nb of color components in input image + // J_COLOR_SPACE in_color_space; // colorspace of input image + // double input_gamma; // image gamma of input image + + // We use our private extension JPEG error handler. + // Note that this struct must live as long as the main JPEG parameter + // struct, to avoid dangling-pointer problems. + struct my_error_mgr jerr; + JSAMPARRAY buffer;// Output row buffer + + // rappel : + // ------ + // typedef unsigned char JSAMPLE; + // typedef JSAMPLE FAR *JSAMPROW;/* ptr to one image row of pixel samples. */ + // typedef JSAMPROW *JSAMPARRAY;/* ptr to some rows (a 2-D sample array) */ + // typedef JSAMPARRAY *JSAMPIMAGE;/* a 3-D sample array: top index is color */ + + int row_stride;// physical row width in output buffer + + // We set up the normal JPEG error routines, then override error_exit. + + cinfo.err = jpeg_std_error(&jerr.pub); + // for any jpeg error call my_error_exit + jerr.pub.error_exit = my_error_exit; + // for any output message call my_output_message + //jerr.pub.output_message = my_output_message; + // Establish the setjmp return context for my_error_exit to use. + if (setjmp(jerr.setjmp_buffer)) + { + // If we get here, the JPEG code has signaled an error. + // We need to clean up the JPEG object, close the input file, and return. + gdcmErrorMacro( "Serious Problem !" ); + jpeg_destroy_decompress(&cinfo); + return 0; + } + // Now we can initialize the JPEG decompression object. + if ( statesuspension == 0 ) + { + jpeg_create_decompress(&cinfo); + jpeg_stdio_src(&cinfo, fp, this, 1); + } + else + { + jpeg_stdio_src(&cinfo, fp, this, 0); + } + // Step 3: read file parameters with jpeg_read_header() + + if ( statesuspension < 2 ) + { + if ( jpeg_read_header(&cinfo, TRUE) == JPEG_SUSPENDED ) + { + // Suspension in jpeg_read_header + statesuspension = 2; + } + // Step 4: set parameters for decompression + // prevent the library from performing any color space conversion + if ( cinfo.process == JPROC_LOSSLESS ) + { + cinfo.jpeg_color_space = JCS_UNKNOWN; + cinfo.out_color_space = JCS_UNKNOWN; + } + } + + // Step 5: Start decompressor + if (statesuspension < 3 ) + { + if ( jpeg_start_decompress(&cinfo) == FALSE ) + { + // Suspension: jpeg_start_decompress + statesuspension = 3; + } + + // JSAMPLEs per row in output buffer + row_stride = cinfo.output_width * cinfo.output_components*2; + + // Make a one-row-high sample array that will go away when done with image + buffer = (*cinfo.mem->alloc_sarray) + ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); + + // Step 6: while (scan lines remain to be read) + + // Save the buffer in case of suspension to be able to reuse it later: + SampBuffer = buffer; + } + else + { + // Suspension: re-use the buffer: + buffer = (JSAMPARRAY)SampBuffer; + } + int bufsize = cinfo.output_width * cinfo.output_components; + size_t rowsize = bufsize * sizeof(JSAMPLE); + + while (cinfo.output_scanline < cinfo.output_height) + { + if ( jpeg_read_scanlines(&cinfo, buffer, 1) == 0 ) + { + // Suspension in jpeg_read_scanlines + statesuspension = 3; + return true; + } +// The ijg has no notion of big endian, therefore always swap the jpeg stream +#if (defined(GDCM_WORDS_BIGENDIAN) || defined(GDCM_FORCE_BIGENDIAN_EMULATION)) && (CMAKE_BITS_IN_JSAMPLE != 8) + uint16_t *buffer16 = (uint16_t*)*buffer; + uint16_t *pimage16 = (uint16_t*)pImage; + for(unsigned int i=0;i> 8) | (buffer16[i] << 8 ); +#else + memcpy( pImage, *buffer,rowsize); +#endif //GDCM_WORDS_BIGENDIAN + pImage+=rowsize; + } + + // Step 7: Finish decompression + if ( jpeg_finish_decompress(&cinfo) == FALSE ) + { + // Suspension: jpeg_finish_decompress + statesuspension = 4; + } + + // Step 8: Release JPEG decompression object + jpeg_destroy_decompress(&cinfo); + + // At this point you may want to check to see whether any corrupt-data + // warnings occurred (test whether jerr.pub.num_warnings is nonzero). + + return true; +} + +#ifdef _MSC_VER +// Put the warning back +#pragma warning( default : 4611 ) +#endif +} // end namespace gdcm