X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmJpeg.cxx;h=280adce3eb4dd6936c40d6023167409b0e7d8d39;hb=9f643008e8a960617fb30ed9dcd454612657e5d2;hp=e2b42ab883cd89d4b9cd37e03025da455d0df681;hpb=fe180328806c1528b6d7a8518780569c866dff40;p=gdcm.git

diff --git a/src/gdcmJpeg.cxx b/src/gdcmJpeg.cxx
index e2b42ab8..280adce3 100644
--- a/src/gdcmJpeg.cxx
+++ b/src/gdcmJpeg.cxx
@@ -1,420 +1,325 @@
-#include "iddcmjpeg.h"
-#include <stdlib.h>	
-	
-static ClbJpeg* ClbJpegAlloc(void);
-static void 	ClbJpegInit (ClbJpeg *); 
-static int 	ClbJpegDecodeDiff(ClbJpeg *);
-static BOOL 	ClbJpegDecodeData(ClbJpeg *);
-static int 	ClbJpegReadBit(ClbJpeg *);
-static BOOL 	ClbJpegReadHeader(ClbJpeg *);
-static BOOL 	ClbJpegStart(ClbJpeg *,FILE *);	
-static BOOL 	ClbJpegFillHuffTable(ClbJpeg *);
-
-
-
-
-void _IdDcmJpegFree(ClbJpeg *jpg)
-{
-	 free(jpg->DataImg);
-	 free(jpg);
+#include <stdio.h>
+#include "gdcmFile.h"
+
+#define DEBUG 0
+
+/*
+ * <setjmp.h> 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 <setjmp.h>
 }
 
-
-ClbJpeg * _IdDcmJpegRead (FILE * fp){
-ClbJpeg * jpg=NULL;
-	jpg=ClbJpegAlloc();
-	if(!jpg) {
-	   printf("Fail to ClbJpegAlloc \n");
-	   return(NULL);
-	}
-	ClbJpegInit (jpg); 
-	if(!ClbJpegStart(jpg, fp)) {
-	   printf("Fail to ClbJpegStart \n");
-	   return (NULL);
-	}
-	return (jpg);
+/******************** 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);
 }
 
 
-	
-static void ClbJpegInit (ClbJpeg *jpg) {
-int n;
-	for (n=0;n<256;n++)
-	{
-		jpg->lHuffTable[n].HufCode=0;
-		jpg->lHuffTable[n].HufSz=0;
-		jpg->lHuffTable[n].HufVal=0;
-	}
-	jpg->ValCurByte=0;
-	jpg->PosCurBit=10;
-	jpg->MarkerFound=0;
-	jpg->RestartInterval=0;
-}
-
-static ClbJpeg *ClbJpegAlloc(void) {
-ClbJpeg * jpg;
-	jpg = (ClbJpeg *)malloc(sizeof(ClbJpeg));
-	ClbJpegInit(jpg);	
-return jpg;
-}
+/*
+ * 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.
+ */
+
+
+//GLOBAL(int)
+int
+gdcmFile::gdcm_read_JPEG_file (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.
+   */
+  struct my_error_mgr jerr;
+  /* More stuff */
  
-
-
-static BOOL ClbJpegFillHuffTable(ClbJpeg *jpg)
-{
-	unsigned char c;
-	//int testindex=0;
-	int n=0;
-	int NiDHT=0;
-	int indexY=0;
-	int k, Code, Si, i;
-
-	for (c=0;c<255;c++)
-		jpg->RawDHTstart[c]=0;
-
-	c=fgetc(jpg->infp);
-
-
-	jpg->MaxHuffSz=0;
-	jpg->MaxHuffVal=0;
-
-	for (n=1;n<17;n++)
-	{
-		jpg->RawDHT[n]=fgetc(jpg->infp);
-		NiDHT+=jpg->RawDHT[n];
-		if (jpg->RawDHT[n]!=0)
-			jpg->MaxHuffSz=n;
-	}
-
-	for(n=1;n<16;n++)
-	{
-		if(jpg->RawDHT[n]>0)
-		{
-			jpg->RawDHTstart[n]=indexY+1;
-			for (i=1;i<(jpg->RawDHT[n]+1);i++)
-			{
-				indexY+=1;
-				c=fgetc(jpg->infp);
-				jpg->lHuffTable[indexY].HufVal=c;
-				jpg->MaxHuffVal=c;
-				jpg->lHuffTable[indexY].HufSz=n;
-			}
-		}
-	}
-	k=1;
-	Code=0;
-	
-	Si=jpg->lHuffTable[k].HufSz;
-
-	while(1)
-	{
-		if (k>=NiDHT) break;
-		while( Si==jpg->lHuffTable[k].HufSz)
-		{
-			jpg->lHuffTable[k].HufCode=Code;
-			Code+=1;
-			k+=1;
-		}
-		if (k<NiDHT)
-		{
-			while (jpg->lHuffTable[k].HufSz>Si)
-			{
-				Code=Code<<1;
-				Si+=1;
-			}
-		}
-	}
-
-	return 1;
-}
-
-	
-
-static BOOL ClbJpegStart(ClbJpeg *jpg, FILE *inputfp)
-{
-	jpg->infp=inputfp;
-	if (!ClbJpegReadHeader(jpg)) {
-	   printf("Fail to ClbJpegReadHeader\n");
-	   return 0;
-	}
-	//printf("sortie ClbJpegReadHeader\n");
-	if (!ClbJpegDecodeData(jpg)) {
-	   printf("Fail to ClbJpegDecodeData\n");
-	   return 0;
-	}	
-	//printf("sortie ClbJpegDecodeData\n");
-	return 1;
+  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");
+
+
+  /* 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 */
+  
+  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 3: read file parameters with jpeg_read_header() */
+
+ if (DEBUG) printf("Entree Step 3\n");
+
+  (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.
+   */
+
+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);
 }
 
-static BOOL ClbJpegReadHeader(ClbJpeg *jpg)
-{
-	unsigned char gr;
-	unsigned char el;
-	unsigned char l2;
-	unsigned char l1;
-	unsigned int sztag;
-	long ouca=0;
-	BOOL HeaderEnd=0;
-	BOOL isLossLess=0;
-	
-	int tp;
-
-	gr=fgetc(jpg->infp);  //FF
-	el=fgetc(jpg->infp);  //D8
-
-	while(!HeaderEnd)
-	{
-		gr=fgetc(jpg->infp);  
-		if(gr!=0xFF) {
-		   printf("gr!=0xFF (=%02x)\n",gr);
-		   return 0;
-		}
-		el=fgetc(jpg->infp);
-
-		if ( (el==0xFF) || (el==0x01) || (el==0xD8) ||(el==0xD9) ||( (el>=0xD0) && (el<=0xD7) ))
-			;
-		else
-		{
-			l1=fgetc(jpg->infp);
-			l2=fgetc(jpg->infp);
-			sztag=(l1*256)+l2-2; //tag lengh
-			ouca=ftell(jpg->infp);
-
-			if (el==0xC3)
-			{
-				jpg->lSof.precision=fgetc(jpg->infp);
-
-				l1=fgetc(jpg->infp);
-				l2=fgetc(jpg->infp);
-				jpg->lSof.Himg=(l1*256)+l2;
-
-				l1=fgetc(jpg->infp);
-				l2=fgetc(jpg->infp);
-				jpg->lSof.Wimg=(l1*256)+l2;
-
-				jpg->lSof.NbComponent=fgetc(jpg->infp); 
-
-				jpg->lSof.SofTabPos=ftell(jpg->infp);
-
-				isLossLess=1; // TRUE
-			}
-
-			if (el==0xC4)
-			{
-				ClbJpegFillHuffTable(jpg);
-			}
-			if (el==0xDA)
-			{
-				jpg->lSos.CompCount=fgetc(jpg->infp);
-				for (tp=0;tp<jpg->lSos.CompCount;tp++)
-				{
-					jpg->lSos.CompId=fgetc(jpg->infp);
-					jpg->lSos.CompDc=fgetc(jpg->infp);
-				}
-				jpg->lSos.SpectralSelStart=fgetc(jpg->infp);
-				jpg->lSos.SpectralSelEnd=fgetc(jpg->infp);
-				jpg->lSos.SuccessiveAp=fgetc(jpg->infp);
-				jpg->lSos.Sospttrans=(jpg->lSos.SuccessiveAp & 16);
-				HeaderEnd=1;
-			}
-			if (el==0xDD)
-			{
-				l1=fgetc(jpg->infp);
-				l2=fgetc(jpg->infp);
-				jpg->RestartInterval=(l1*256)+l2;
-			}
-
-			fseek(jpg->infp,(ouca+sztag),0);
-		}
-	}
-
-	if (!isLossLess) {
-	   printf("NOT isLossLess\n");
-	   return 0;
-	}
-	return 1;
-
-}
 
-static int ClbJpegReadBit(ClbJpeg *jpg)
-{
-	int r=0;
-	unsigned char c;
-	if(jpg->PosCurBit>8) // need lire octet suivant
-	{
-		jpg->ValCurByte=fgetc(jpg->infp);
-		if (jpg->ValCurByte==0xFF)
-		{
-			c=fgetc(jpg->infp);// est 00 ou restart marker: a skiper
-			if (c!=0)
-			{
-				jpg->ValCurByte=fgetc(jpg->infp);
-				jpg->PosCurBit=1;
-				jpg->MarkerFound=1;
-				return 0; 
-			}
-		}
-		jpg->PosCurBit=2;
-		return (jpg->ValCurByte>>7);
-	}
-	else
-	{
-		r=(1&(jpg->ValCurByte>>(8-jpg->PosCurBit)));
-		jpg->PosCurBit+=1;
-		return r;
-	}
+/*
+  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.
+   */
+
+  /* Step 5: Start decompressor */
+  
+ if (DEBUG) printf("Entree Step 5\n");
+
+  (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;
+  
+ 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_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.
+   */
+   
+ 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
+     * 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); 
+     memcpy( pimage, buffer[0],row_stride*2 ); // FIXME : *2  car 16 bits?!?
+     
+    pimage+=row_stride*2;  // FIXME : *2 car 16 bits?!?
+  }
+ 
+  /* Step 7: Finish decompression */
+  
+if (DEBUG)  printf("Entree Step 7\n");
+
+  (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 */
+  
+if (DEBUG) printf("Entree Step 8\n");
+
+  /* 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! */
+  
+  return 1;
 }
 
+/*
+ * 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.
+ */
+ 
 
-static BOOL ClbJpegDecodeData(ClbJpeg *jpg)
-{
-	int iX,iY;
-	int lbInc=0;
-	unsigned int mask; 
-	  
-	int lPredicted=(1<<(jpg->lSof.precision-1-jpg->lSos.Sospttrans));
-
-	jpg->ValCurByte=jpg->lSos.SuccessiveAp;
-	jpg->PosCurBit=9;
-	
-	if (jpg->lSof.precision==8)
-		mask=0xFF;
-	if (jpg->lSof.precision==12)
-		mask=0xFFF;
-	if (jpg->lSof.precision==16)
-		mask=0xFFFF;
-
-	 jpg->DataImg=(int*)malloc(jpg->lSof.Himg*jpg->lSof.Wimg*sizeof(*jpg->DataImg));
-	memset( jpg->DataImg,0,(jpg->lSof.Himg*jpg->lSof.Wimg*sizeof(*jpg->DataImg)));
-
-	if (!jpg->RestartInterval)
-	{
-		for(iX=0;iX<jpg->lSof.Wimg;iX++) // lit première ligne
-		{
-			lbInc+=1;
-			if (lbInc>1)
-				lPredicted= jpg->DataImg[lbInc-1];
-			 jpg->DataImg[lbInc]=lPredicted+ClbJpegDecodeDiff(jpg);
-
-			if (  jpg->DataImg[lbInc] > ((1<<(jpg->lSof.precision))-1) )
-				 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-			if ( jpg->DataImg[lbInc]<0) 
-				 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-		}
-
-		for (iY=1;iY<jpg->lSof.Himg;iY++) //lit la suite
-		{
-			lbInc+=1;
-			if (lbInc>(jpg->lSof.Himg*jpg->lSof.Wimg-1)) break;
-			lPredicted= jpg->DataImg[lbInc-jpg->lSof.Wimg];	// se base % premier é ligne d'avant
-			 jpg->DataImg[lbInc]=lPredicted+ClbJpegDecodeDiff(jpg);
-
-			if (  jpg->DataImg[lbInc] > ((1<<(jpg->lSof.precision))-1) ) 
-				 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-			if ( jpg->DataImg[lbInc]<0) 
-				 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-
-			for(iX=1;iX<jpg->lSof.Wimg;iX++)
-			{
-				lbInc+=1;
-				if (lbInc>(jpg->lSof.Himg*jpg->lSof.Wimg-1)) break;
-				if (jpg->lSos.SpectralSelStart==7) // si spectral
-					lPredicted=( jpg->DataImg[lbInc-1]+ jpg->DataImg[lbInc-jpg->lSof.Wimg])>>1;
-				else
-					lPredicted= jpg->DataImg[lbInc-1];		// se base%pixel juste avant
-				 jpg->DataImg[lbInc]=lPredicted+ClbJpegDecodeDiff(jpg);
-
-				if (  jpg->DataImg[lbInc] > ((1<<(jpg->lSof.precision))-1) ) 
-					 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-				if ( jpg->DataImg[lbInc]<0) 
-					 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-
-			}
-		}
-	}
-	else // il y a un define interval
-	{
-		while(1)
-		{
-			jpg->MarkerFound=0;
-			lPredicted=(1<<(jpg->lSof.precision - 1 - jpg->lSos.Sospttrans));
-			for (iY=0;iY<jpg->RestartInterval;iY++) 
-			{
-				 jpg->DataImg[lbInc]=lPredicted+ClbJpegDecodeDiff(jpg);
-
-				if (  jpg->DataImg[lbInc] > ((1<<(jpg->lSof.precision))-1) ) 
-					 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-				if ( jpg->DataImg[lbInc]<0) 
-					 jpg->DataImg[lbInc]= jpg->DataImg[lbInc]&mask;
-
-				lbInc+=1;
-				if (lbInc>(jpg->lSof.Himg*jpg->lSof.Wimg-1)) return 1;
-
-				if (jpg->lSos.SpectralSelStart==7) // si spectral
-					lPredicted=( jpg->DataImg[lbInc-1]+ jpg->DataImg[lbInc-jpg->lSof.Wimg])>>1;
-				else
-					lPredicted= jpg->DataImg[lbInc-1];
-			}
-			while (!jpg->MarkerFound)
-			{
-				ClbJpegReadBit(jpg); // skip bits restant avant restart marker
-			}
-		}
-	}
-	return 1;
-}
-
-static int ClbJpegDecodeDiff(ClbJpeg *jpg)
-{
-	int lInput;
-	int lInputBits;
-	int lHufVal;
-	int lDiff;
-	int lI;
-	int resultat;
-	lHufVal = 666;
-	lInput = 0;
-	lInputBits = 0;
-	
-	
-	while (1)
-	{
-		lInputBits+=1;
-		lInput=(lInput<<1)+ClbJpegReadBit(jpg);
-		if (jpg->RawDHT[lInputBits]!=0)
-		{
-			for(lI=jpg->RawDHTstart[lInputBits];lI<(jpg->RawDHTstart[lInputBits]+jpg->RawDHT[lInputBits]);lI++)
-			{
-				if (lInput==jpg->lHuffTable[lI].HufCode)
-					lHufVal=jpg->lHuffTable[lI].HufVal;
-			}
-		}
-		if (lInputBits>=jpg->MaxHuffSz)
-			lHufVal=jpg->MaxHuffVal;
-		if (lHufVal<255) break;
-	}
-	if (lHufVal==0) resultat= 0;
-
-	if ( (lHufVal>0) && (lHufVal<16))
-	{
-		lDiff=0;
-		if( ClbJpegReadBit(jpg)==1)
-		{
-			for (lI=1;lI<lHufVal;lI++)
-			{
-				lDiff=(lDiff<<1)+ClbJpegReadBit(jpg);
-			}
-
-			resultat= (lDiff+(1<<(lHufVal-1)));
-		}
-		else
-		{
-			for (lI=1;lI<lHufVal;lI++)
-				lDiff=(lDiff<<1)+1-ClbJpegReadBit(jpg);
-			resultat= -(lDiff+(1<<(lHufVal-1)));
-		}
-	}
-
-	return resultat;
-	
-}