X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmJpeg.cxx;h=f4e8862c31f16ac27785ec35bddd575664d0b73a;hb=b06cbd9177331d793223eac6bf8b2bccf874e7e3;hp=fbfe8de15d823e12e4584633c91b712dad968aa7;hpb=746c9ec7ec0fbe389b0894c80a8393ecd5472479;p=gdcm.git diff --git a/src/gdcmJpeg.cxx b/src/gdcmJpeg.cxx index fbfe8de1..f4e8862c 100644 --- a/src/gdcmJpeg.cxx +++ b/src/gdcmJpeg.cxx @@ -1,133 +1,240 @@ -// gdcmJpeg.cxx -//----------------------------------------------------------------------------- -#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 -#define BITS_IN_JSAMPLE 8 +#include +#include -/* -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 -*/ +#if defined(__BORLANDC__) + #include // for memset +#endif -/* - * is used for the optional error recovery mechanism shown in - * the second part of the example. - */ +#include "jdatasrc.cxx" +#include "jdatadst.cxx" -/* - * 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". +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 */ -extern "C" { -#include "jpeglib.h" -#include -} +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 */ + + /* 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_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 jpeg_error_mgr jerr; + /* More stuff */ + + /* Step 1: allocate and initialize JPEG compression object */ + + /* 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 2: specify data destination (eg, a file) */ + /* Note: steps 2 and 3 can be done in either order. */ + + int fragment_size = static_cast< int >( inputlength ); + jpeg_stdio_dest(&cinfo, fp, fragment_size, 1); + + /* Step 3: set parameters for compression */ + + /* First we supply a description of the input image. + * Four fields of the cinfo struct must be filled in: + */ + 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 4: Start compressor */ + + /* TRUE ensures that we will write a complete interchange-JPEG file. + * Pass TRUE unless you are very sure of what you're doing. + */ + jpeg_start_compress(&cinfo, TRUE); + + /* Step 5: while (scan lines remain to be written) */ + /* jpeg_write_scanlines(...); */ + + /* 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 (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; -/* - * 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: - */ +// JpegPair &jp = v[i]; +// jp.second = end-beg; + //beg = end; // + // } + + /* Step 6: Finish compression */ + + jpeg_finish_compress(&cinfo); + + /* 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 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; //----------------------------------------------------------------------------- -typedef struct my_error_mgr * my_error_ptr; /* * 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; @@ -140,45 +247,51 @@ METHODDEF(void) my_error_exit (j_common_ptr cinfo) { 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 ); +//} + +} //----------------------------------------------------------------------------- -/* - * 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. - */ - /** - * \ingroup gdcmFile +/** * \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 */ - -bool gdcmFile::gdcm_read_JPEG_file (FILE *fp,void * image_buffer) { - char *pimage; - - /* This struct contains the JPEG decompression parameters and pointers to - * working space (which is allocated as needed by the JPEG library). - */ - 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. - */ +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; - /* More stuff */ - JSAMPARRAY buffer;/* Output row buffer */ + JSAMPARRAY buffer;// Output row buffer // rappel : // ------ @@ -187,213 +300,123 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE *fp,void * image_buffer) { // 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 */ + int row_stride;// physical row width in output buffer -#ifdef GDCM_JPG_DEBUG - printf("entree dans gdcmFile::gdcm_read_JPEG_file12, depuis gdcmJpeg\n"); -#endif //GDCM_JPG_DEBUG - - /* 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. - */ - - /* Step 1: allocate and initialize JPEG decompression object */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 1\n"); -#endif //GDCM_JPG_DEBUG - - /* We set up the normal JPEG error routines, then override error_exit. */ + // 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; - - /* 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. - */ + // 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. */ - jpeg_create_decompress(&cinfo); - - /* Step 2: specify data source (eg, a file) */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 2\n"); -#endif //GDCM_JPG_DEBUG - - jpeg_stdio_src(&cinfo, fp); - - /* Step 3: read file parameters with jpeg_read_header() */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 3\n"); -#endif //GDCM_JPG_DEBUG - - (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. - */ - -#ifdef GDCM_JPG_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); -#endif //GDCM_JPG_DEBUG - - - /* - * 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 */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 4\n"); -#endif //GDCM_JPG_DEBUG - /* In this example, we don't need to change any of the defaults set by - * jpeg_read_header(), so we do nothing here. - */ - - /* Step 5: Start decompressor */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 5\n"); -#endif //GDCM_JPG_DEBUG - - (void) jpeg_start_decompress(&cinfo); - /* We can ignore the return value since suspension is not possible - * with the stdio data source. - */ - - /* 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; + // 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; -#ifdef GDCM_JPG_DEBUG - printf ("cinfo.output_width %d cinfo.output_components %d row_stride %d\n", - cinfo.output_width, cinfo.output_components,row_stride); -#endif //GDCM_JPG_DEBUG - - /* Make a one-row-high sample array that will go away when done with image */ - buffer = (*cinfo.mem->alloc_sarray) + // 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) */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 6\n"); -#endif //GDCM_JPG_DEBUG - /* jpeg_read_scanlines(...); */ - - /* Here we use the library's state variable cinfo.output_scanline as the - * loop counter, so that we don't have to keep track ourselves. - */ -#ifdef GDCM_JPG_DEBUG - printf ("cinfo.output_height %d cinfo.output_width %d\n", - cinfo.output_height,cinfo.output_width); -#endif //GDCM_JPG_DEBUG - 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 - * more than one scanline at a time if that's more convenient. - */ - - // l'image est deja allouée (et passée en param) - // on ecrit directement les pixels - // (on DEVRAIT pouvoir) - - //(void) jpeg_read_scanlines(&cinfo, pimage, 1); - - (void) jpeg_read_scanlines(&cinfo, buffer, 1); - - if ( BITS_IN_JSAMPLE == 8) { - memcpy( pimage, buffer[0],row_stride); - pimage+=row_stride; - } else { - memcpy( pimage, buffer[0],row_stride*2 ); // FIXME : *2 car 16 bits?!? - pimage+=row_stride*2; // FIXME : *2 car 16 bits?!? + // 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 7: Finish decompression */ -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 7\n"); -#endif //GDCM_JPG_DEBUG - - (void) jpeg_finish_decompress(&cinfo); - /* We can ignore the return value since suspension is not possible - * with the stdio data source. - */ - - /* Step 8: Release JPEG decompression object */ - -#ifdef GDCM_JPG_DEBUG - printf("Entree Step 8\n"); -#endif //GDCM_JPG_DEBUG - - /* This is an important step since it will release a good deal of memory. */ - + // Step 8: Release JPEG decompression object jpeg_destroy_decompress(&cinfo); - /* 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...) - */ - - /* At this point you may want to check to see whether any corrupt-data - * warnings occurred (test whether jerr.pub.num_warnings is nonzero). - */ + // At this point you may want to check to see whether any corrupt-data + // warnings occurred (test whether jerr.pub.num_warnings is nonzero). - /* And we're done! */ - - return(true); + return true; } -/* - * 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. - */ - -//---------------------------------------------------------------------------- +#ifdef _MSC_VER +// Put the warning back +#pragma warning( default : 4611 ) +#endif + +} // end namespace gdcm