X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmJpeg.cxx;h=9749edd9fba303fa5f41d81149875b08faab690c;hb=4dca895b33bbd4fd9e21a30e004026ba00a4feb5;hp=d632432f97c200fb6dd428c82383e7ea76f1c8d8;hpb=e62d57cbd05c8e864fd2ba197a271cdcac9a2128;p=gdcm.git diff --git a/src/gdcmJpeg.cxx b/src/gdcmJpeg.cxx index d632432f..9749edd9 100644 --- a/src/gdcmJpeg.cxx +++ b/src/gdcmJpeg.cxx @@ -1,14 +1,22 @@ -// gdcmJpeg.cxx -//----------------------------------------------------------------------------- -#include +/*========================================================================= + + Program: gdcm + Module: $RCSfile: gdcmJpeg.cxx,v $ + Language: C++ + Date: $Date: 2005/01/12 19:02:13 $ + Version: $Revision: 1.31 $ + + 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 "gdcmFile.h" -#define BITS_IN_JSAMPLE 8 - -#ifdef GDCM_DEBUG -#define GDCM_jpr_DEBUG 0 -#endif //GDCM_DEBUG - /* DICOM provides a mechanism for supporting the use of JPEG Image Compression through the Encapsulated Format (see PS 3.3 of the DICOM Standard). @@ -76,12 +84,13 @@ of the uncompressed pixel data from which the compressed data is derived * You may also wish to include "jerror.h". */ -extern "C" { -#include "jpeglib.h" #include -} - +#include +#include "jdatasrc.cxx" +#include "jdatadst.cxx" +namespace gdcm +{ /******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/ /* This half of the example shows how to feed data into the JPEG compressor. @@ -105,7 +114,6 @@ extern "C" { * RGB color and is described by: */ -// FIXME : JPR //extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */ //extern int image_height; /* Number of rows in image */ @@ -119,18 +127,18 @@ extern "C" { */ /** - * \ingroup gdcmFile + * \ingroup File * \brief routine for JPEG decompression * @param fp pointer to an already open file descriptor * 8 significant bits per pixel - * @param image_buffer Points to array (of R,G,B-order) data to compress + * @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 (FILE* fp, void* im_buf, +bool gdcm_write_JPEG_file (std::ofstream* fp, void* im_buf, int image_width, int image_height, int quality) { @@ -349,7 +357,6 @@ METHODDEF(void) my_error_exit (j_common_ptr cinfo) { */ /** - * \ingroup gdcmFile * \brief routine for JPEG decompression * @param fp pointer to an already open file descriptor * 8 significant bits per pixel @@ -357,7 +364,8 @@ METHODDEF(void) my_error_exit (j_common_ptr cinfo) { * @return 1 on success, 0 on error */ -bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { +bool gdcm_read_JPEG_file ( std::ifstream* fp, void* image_buffer ) +{ char* pimage; /* This struct contains the JPEG decompression parameters and pointers to @@ -392,7 +400,7 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { int row_stride;/* physical row width in output buffer */ #ifdef GDCM_JPG_DEBUG - printf("entree dans gdcmFile::gdcm_read_JPEG_file (i.e. 8), depuis gdcmJpeg\n"); + printf("entree dans File::gdcm_read_JPEG_file (i.e. 8), depuis gdcmJpeg\n"); #endif //GDCM_JPG_DEBUG /* In this example we want to open the input file before doing anything else, @@ -412,7 +420,8 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ - if (setjmp(jerr.setjmp_buffer)) { + 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. */ @@ -442,6 +451,14 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { * See libjpeg.doc for more info. */ + // 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; + } + + #ifdef GDCM_JPG_DEBUG printf("--------------Header contents :----------------\n"); printf("image_width %d image_height %d\n", @@ -488,7 +505,7 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { */ /* JSAMPLEs per row in output buffer */ - row_stride = cinfo.output_width * cinfo.output_components; + 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", @@ -514,29 +531,29 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { #endif //GDCM_JPG_DEBUG pimage=(char *)image_buffer; + int bufsize = cinfo.output_width * cinfo.output_components; + size_t rowsize = bufsize * sizeof(JSAMPLE); + 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?!? - } - } - + + //printf( "scanlines: %d\n",cinfo.output_scanline); + (void) jpeg_read_scanlines(&cinfo, buffer, 1); +// The ijg has no notion of big endian, therefore always swap the jpeg stream +#if defined(GDCM_WORDS_BIGENDIAN) && (CMAKE_BITS_IN_JSAMPLE != 8) + uint16_t *buffer16 = (uint16_t*)*buffer; + uint16_t *pimage16 = (uint16_t*)pimage; + for(int i=0;i> 8) | (buffer16[i] << 8 ); +#else + memcpy( pimage, *buffer,rowsize); +#endif //GDCM_WORDS_BIGENDIAN + pimage+=rowsize; + } + /* Step 7: Finish decompression */ #ifdef GDCM_JPG_DEBUG printf("Entree Step 7\n"); @@ -570,7 +587,7 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { /* And we're done! */ - return(true); + return true; } @@ -600,3 +617,261 @@ bool gdcmFile::gdcm_read_JPEG_file (FILE* fp, void* image_buffer) { */ //---------------------------------------------------------------------------- + + +/** + * \brief routine for JPEG decompression from a memory buffer. + * routine for JPEG decompression from a memory buffer. This routine + * only reads one JPEG image at a time, but returns information about + * how many bytes have been consumed from the \c input_buffer, and + * how many bytes have been written into the output \c image_buffer. + * + * @param input_buffer pointer to a memory buffer containing the jpeg + * compressed data. + * @param buflen length of the memory buffer. + * @param image_buffer pointer to the location where the decompressed + * image will be filled. + * @param howManyRead returns how many bytes have been consumed from the + * input_buffer. + * @param howManyWritten returns how many bytes have been written into + * the output image_buffer. + * @return 1 on success, 0 on error + */ + +bool gdcm_read_JPEG_memory ( const JOCTET* input_buffer, const size_t buflen, + void* image_buffer, + size_t *howManyRead, size_t *howManyWritten) +{ + char* pimage=(char *)image_buffer; + JOCTET* input = (JOCTET*) input_buffer; + + /* 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. + */ + struct my_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 */ + +#ifdef GDCM_JPG_DEBUG + printf("entree dans File::gdcm_read_JPEG_file (i.e. 8), 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. */ + + 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); + + *howManyRead += input - input_buffer; + *howManyWritten += pimage - (char *)image_buffer; + 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_memory_src(&cinfo, input, buflen); + + /* 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. + */ + + // 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; + } + +#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*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) + ((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 + + int bufsize = cinfo.output_width * cinfo.output_components; + size_t rowsize = bufsize * sizeof(JSAMPLE); + + 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. + */ + + //printf( "scanlines: %d\n",cinfo.output_scanline); + (void) jpeg_read_scanlines(&cinfo, buffer, 1); +#if defined(GDCM_WORDS_BIGENDIAN) && (CMAKE_BITS_IN_JSAMPLE != 8) + uint16_t *buffer16 = (uint16_t*)*buffer; + uint16_t *pimage16 = (uint16_t*)pimage; + for(int i=0;i> 8) | (buffer16[i] << 8 ); +#else + memcpy( pimage, *buffer,rowsize); +#endif //GDCM_WORDS_BIGENDIAN + pimage+=rowsize; + } + + /* Step 7: Finish decompression */ +#ifdef GDCM_JPG_DEBUG + printf("Entree Step 7\n"); +#endif //GDCM_JPG_DEBUG + + input = (JOCTET *)cinfo.src->next_input_byte; + + (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. */ + + 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). + */ + + /* And we're done! */ + *howManyRead += input - input_buffer; + *howManyWritten += pimage - (char *)image_buffer; + + return true; +} + +} // end namespace gdcm