Update libjpeg-turbo.

turbojpeg.c

 /*
- * Copyright (C)2009-2011 D. R. Commander.  All Rights Reserved.
+ * Copyright (C)2009-2012 D. R. Commander.  All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * - Redistributions of source code must retain the above copyright notice,
  *   this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice,
  *   this list of conditions and the following disclaimer in the documentation
  *   and/or other materials provided with the distribution.
  * - Neither the name of the libjpeg-turbo Project nor the names of its
@@ skipping 72 matching lines @@
 } tjinstance;
 
 static const int pixelsize[TJ_NUMSAMP]={3, 3, 3, 1, 3};
 
 static const JXFORM_CODE xformtypes[TJ_NUMXOP]=
 {
         JXFORM_NONE, JXFORM_FLIP_H, JXFORM_FLIP_V, JXFORM_TRANSPOSE,
         JXFORM_TRANSVERSE, JXFORM_ROT_90, JXFORM_ROT_180, JXFORM_ROT_270
 };
 
-#define NUMSF 4
+#define NUMSF 16
 static const tjscalingfactor sf[NUMSF]={
+        {2, 1},
+        {15, 8},
+        {7, 4},
+        {13, 8},
+        {3, 2},
+        {11, 8},
+        {5, 4},
+        {9, 8},
         {1, 1},
+        {7, 8},
+        {3, 4},
+        {5, 8},
         {1, 2},
+        {3, 8},
         {1, 4},
         {1, 8}
 };
 
 #define _throw(m) {snprintf(errStr, JMSG_LENGTH_MAX, "%s", m);  \
         retval=-1;  goto bailout;}
 #define getinstance(handle) tjinstance *this=(tjinstance *)handle;  \
         j_compress_ptr cinfo=NULL;  j_decompress_ptr dinfo=NULL;  \
         if(!this) {snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle");  \
                 return -1;}  \
@@ skipping 44 matching lines @@
                 case TJPF_BGRA:
                         cinfo->in_color_space=JCS_EXT_BGRX;  break;
                 case TJPF_XRGB:
                 case TJPF_ARGB:
                         cinfo->in_color_space=JCS_EXT_XRGB;  break;
                 case TJPF_XBGR:
                 case TJPF_ABGR:
                         cinfo->in_color_space=JCS_EXT_XBGR;  break;
                 #else
                 case TJPF_RGB:
-                        if(RGB_RED==0 && RGB_GREEN==1 && RGB_BLUE==2 && RGB_PIXELSIZE==3)
-                        {
-                                cinfo->in_color_space=JCS_RGB;  break;
-                        }
-                default:
-                        _throw("Unsupported pixel format");
+                case TJPF_BGR:
+                case TJPF_RGBX:
+                case TJPF_BGRX:
+                case TJPF_XRGB:
+                case TJPF_XBGR:
+                case TJPF_RGBA:
+                case TJPF_BGRA:
+                case TJPF_ARGB:
+                case TJPF_ABGR:
+                        cinfo->in_color_space=JCS_RGB;  pixelFormat=TJPF_RGB;
+                        break;
                 #endif
         }
 
         cinfo->input_components=tjPixelSize[pixelFormat];
         jpeg_set_defaults(cinfo);
         if(jpegQual>=0)
         {
                 jpeg_set_quality(cinfo, jpegQual, TRUE);
                 if(jpegQual>=96) cinfo->dct_method=JDCT_ISLOW;
                 else cinfo->dct_method=JDCT_FASTEST;
         }
         if(subsamp==TJSAMP_GRAY)
                 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
         else
                 jpeg_set_colorspace(cinfo, JCS_YCbCr);
 
         cinfo->comp_info[0].h_samp_factor=tjMCUWidth[subsamp]/8;
         cinfo->comp_info[1].h_samp_factor=1;
         cinfo->comp_info[2].h_samp_factor=1;
         cinfo->comp_info[0].v_samp_factor=tjMCUHeight[subsamp]/8;
         cinfo->comp_info[1].v_samp_factor=1;
         cinfo->comp_info[2].v_samp_factor=1;
 
-        #if JCS_EXTENSIONS!=1
-        bailout:
-        #endif
         return retval;
 }
 
 static int setDecompDefaults(struct jpeg_decompress_struct *dinfo,
         int pixelFormat)
 {
         int retval=0;
 
         switch(pixelFormat)
         {
@@ skipping 17 matching lines @@
                         dinfo->out_color_space=JCS_EXT_RGBA;  break;
                 case TJPF_BGRA:
                         dinfo->out_color_space=JCS_EXT_BGRA;  break;
                 case TJPF_ARGB:
                         dinfo->out_color_space=JCS_EXT_ARGB;  break;
                 case TJPF_ABGR:
                         dinfo->out_color_space=JCS_EXT_ABGR;  break;
                 #endif
                 #else
                 case TJPF_RGB:
-                        if(RGB_RED==0 && RGB_GREEN==1 && RGB_BLUE==2 && RGB_PIXELSIZE==3)
-                        {
-                                dinfo->out_color_space=JCS_RGB;  break;
-                        }
+                case TJPF_BGR:
+                case TJPF_RGBX:
+                case TJPF_BGRX:
+                case TJPF_XRGB:
+                case TJPF_XBGR:
+                case TJPF_RGBA:
+                case TJPF_BGRA:
+                case TJPF_ARGB:
+                case TJPF_ABGR:
+                        dinfo->out_color_space=JCS_RGB;  break;
                 #endif
                 default:
                         _throw("Unsupported pixel format");
         }
 
         bailout:
         return retval;
 }
 
 
@@ skipping 18 matching lines @@
                                 {
                                         retval=i;  break;
                                 }
                         }
                 }
         }
         return retval;
 }
 
 
+#ifndef JCS_EXTENSIONS
+
+/* Conversion functions to emulate the colorspace extensions.  This allows the
+   TurboJPEG wrapper to be used with libjpeg */
+
+#define TORGB(PS, ROFFSET, GOFFSET, BOFFSET) {  \
+        int rowPad=pitch-width*PS;  \
+        while(height--)  \
+        {  \
+                unsigned char *endOfRow=src+width*PS;  \
+                while(src<endOfRow)  \
+                {  \
+                        dst[RGB_RED]=src[ROFFSET];  \
+                        dst[RGB_GREEN]=src[GOFFSET];  \
+                        dst[RGB_BLUE]=src[BOFFSET];  \
+                        dst+=RGB_PIXELSIZE;  src+=PS;  \
+                }  \
+                src+=rowPad;  \
+        }  \
+}
+
+static unsigned char *toRGB(unsigned char *src, int width, int pitch,
+        int height, int pixelFormat, unsigned char *dst)
+{
+        unsigned char *retval=src;
+        switch(pixelFormat)
+        {
+                case TJPF_RGB:
+                        #if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
+                        retval=dst;  TORGB(3, 0, 1, 2);
+                        #endif
+                        break;
+                case TJPF_BGR:
+                        #if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
+                        retval=dst;  TORGB(3, 2, 1, 0);
+                        #endif
+                        break;
+                case TJPF_RGBX:
+                case TJPF_RGBA:
+                        #if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+                        retval=dst;  TORGB(4, 0, 1, 2);
+                        #endif
+                        break;
+                case TJPF_BGRX:
+                case TJPF_BGRA:
+                        #if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+                        retval=dst;  TORGB(4, 2, 1, 0);
+                        #endif
+                        break;
+                case TJPF_XRGB:
+                case TJPF_ARGB:
+                        #if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+                        retval=dst;  TORGB(4, 1, 2, 3);
+                        #endif
+                        break;
+                case TJPF_XBGR:
+                case TJPF_ABGR:
+                        #if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+                        retval=dst;  TORGB(4, 3, 2, 1);
+                        #endif
+                        break;
+        }
+        return retval;
+}
+
+#define FROMRGB(PS, ROFFSET, GOFFSET, BOFFSET, SETALPHA) {  \
+        int rowPad=pitch-width*PS;  \
+        while(height--)  \
+        {  \
+                unsigned char *endOfRow=dst+width*PS;  \
+                while(dst<endOfRow)  \
+                {  \
+                        dst[ROFFSET]=src[RGB_RED];  \
+                        dst[GOFFSET]=src[RGB_GREEN];  \
+                        dst[BOFFSET]=src[RGB_BLUE];  \
+                        SETALPHA  \
+                        dst+=PS;  src+=RGB_PIXELSIZE;  \
+                }  \
+                dst+=rowPad;  \
+        }  \
+}
+
+static void fromRGB(unsigned char *src, unsigned char *dst, int width,
+        int pitch, int height, int pixelFormat)
+{
+        switch(pixelFormat)
+        {
+                case TJPF_RGB:
+                        #if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
+                        FROMRGB(3, 0, 1, 2,);
+                        #endif
+                        break;
+                case TJPF_BGR:
+                        #if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
+                        FROMRGB(3, 2, 1, 0,);
+                        #endif
+                        break;
+                case TJPF_RGBX:
+                        #if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 0, 1, 2,);
+                        #endif
+                        break;
+                case TJPF_RGBA:
+                        #if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 0, 1, 2, dst[3]=0xFF;);
+                        #endif
+                        break;
+                case TJPF_BGRX:
+                        #if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 2, 1, 0,);
+                        #endif
+                        break;
+                case TJPF_BGRA:
+                        #if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 2, 1, 0, dst[3]=0xFF;);  return;
+                        #endif
+                        break;
+                case TJPF_XRGB:
+                        #if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 1, 2, 3,);  return;
+                        #endif
+                        break;
+                case TJPF_ARGB:
+                        #if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 1, 2, 3, dst[0]=0xFF;);  return;
+                        #endif
+                        break;
+                case TJPF_XBGR:
+                        #if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 3, 2, 1,);  return;
+                        #endif
+                        break;
+                case TJPF_ABGR:
+                        #if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+                        FROMRGB(4, 3, 2, 1, dst[0]=0xFF;);  return;
+                        #endif
+                        break;
+        }
+}
+
+#endif
+
+
 /* General API functions */
 
 DLLEXPORT char* DLLCALL tjGetErrorStr(void)
 {
         return errStr;
 }
 
 
 DLLEXPORT int DLLCALL tjDestroy(tjhandle handle)
 {
@@ skipping 120 matching lines @@
 {
         return tjBufSizeYUV(width, height, subsamp);
 }
 
 
 DLLEXPORT int DLLCALL tjCompress2(tjhandle handle, unsigned char *srcBuf,
         int width, int pitch, int height, int pixelFormat, unsigned char **jpegBuf,
         unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
 {
         int i, retval=0, alloc=1;  JSAMPROW *row_pointer=NULL;
+        #ifndef JCS_EXTENSIONS
+        unsigned char *rgbBuf=NULL;
+        #endif
 
         getinstance(handle)
         if((this->init&COMPRESS)==0)
                 _throw("tjCompress2(): Instance has not been initialized for compression");
 
         if(srcBuf==NULL || width<=0 || pitch<0 || height<=0 || pixelFormat<0
                 || pixelFormat>=TJ_NUMPF || jpegBuf==NULL || jpegSize==NULL
                 || jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT || jpegQual<0 || jpegQual>100)
                 _throw("tjCompress2(): Invalid argument");
 
         if(setjmp(this->jerr.setjmp_buffer))
         {
                 /* If we get here, the JPEG code has signaled an error. */
                 retval=-1;
                 goto bailout;
         }
 
         if(pitch==0) pitch=width*tjPixelSize[pixelFormat];
 
+        #ifndef JCS_EXTENSIONS
+        if(pixelFormat!=TJPF_GRAY)
+        {
+                rgbBuf=(unsigned char *)malloc(width*height*RGB_PIXELSIZE);
+                if(!rgbBuf) _throw("tjCompress2(): Memory allocation failure");
+                srcBuf=toRGB(srcBuf, width, pitch, height, pixelFormat, rgbBuf);
+                pitch=width*RGB_PIXELSIZE;
+        }
+        #endif
+
         cinfo->image_width=width;
         cinfo->image_height=height;
 
         if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
         else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
         else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
 
         if(flags&TJFLAG_NOREALLOC)
         {
                 alloc=0;  *jpegSize=tjBufSize(width, height, jpegSubsamp);
@@ skipping 12 matching lines @@
         }
         while(cinfo->next_scanline<cinfo->image_height)
         {
                 jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
                         cinfo->image_height-cinfo->next_scanline);
         }
         jpeg_finish_compress(cinfo);
 
         bailout:
         if(cinfo->global_state>CSTATE_START) jpeg_abort_compress(cinfo);
+        #ifndef JCS_EXTENSIONS
+        if(rgbBuf) free(rgbBuf);
+        #endif
         if(row_pointer) free(row_pointer);
         return retval;
 }
 
 DLLEXPORT int DLLCALL tjCompress(tjhandle handle, unsigned char *srcBuf,
         int width, int pitch, int height, int pixelSize, unsigned char *jpegBuf,
         unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
 {
         int retval=0;  unsigned long size;
         if(flags&TJ_YUV)
@@ skipping 16 matching lines @@
 DLLEXPORT int DLLCALL tjEncodeYUV2(tjhandle handle, unsigned char *srcBuf,
         int width, int pitch, int height, int pixelFormat, unsigned char *dstBuf,
         int subsamp, int flags)
 {
         int i, retval=0;  JSAMPROW *row_pointer=NULL;
         JSAMPLE *_tmpbuf[MAX_COMPONENTS], *_tmpbuf2[MAX_COMPONENTS];
         JSAMPROW *tmpbuf[MAX_COMPONENTS], *tmpbuf2[MAX_COMPONENTS];
         JSAMPROW *outbuf[MAX_COMPONENTS];
         int row, pw, ph, cw[MAX_COMPONENTS], ch[MAX_COMPONENTS];
         JSAMPLE *ptr=dstBuf;
-  unsigned long yuvsize=0;
+        unsigned long yuvsize=0;
         jpeg_component_info *compptr;
+        #ifndef JCS_EXTENSIONS
+        unsigned char *rgbBuf=NULL;
+        #endif
 
         getinstance(handle);
         if((this->init&COMPRESS)==0)
                 _throw("tjEncodeYUV2(): Instance has not been initialized for compression");
 
         for(i=0; i<MAX_COMPONENTS; i++)
         {
                 tmpbuf[i]=NULL;  _tmpbuf[i]=NULL;
                 tmpbuf2[i]=NULL;  _tmpbuf2[i]=NULL;  outbuf[i]=NULL;
         }
 
         if(srcBuf==NULL || width<=0 || pitch<0 || height<=0 || pixelFormat<0
                 || pixelFormat>=TJ_NUMPF || dstBuf==NULL || subsamp<0
                 || subsamp>=NUMSUBOPT)
                 _throw("tjEncodeYUV2(): Invalid argument");
 
         if(setjmp(this->jerr.setjmp_buffer))
         {
                 /* If we get here, the JPEG code has signaled an error. */
                 retval=-1;
                 goto bailout;
         }
 
         if(pitch==0) pitch=width*tjPixelSize[pixelFormat];
 
+        #ifndef JCS_EXTENSIONS
+        if(pixelFormat!=TJPF_GRAY)
+        {
+                rgbBuf=(unsigned char *)malloc(width*height*RGB_PIXELSIZE);
+                if(!rgbBuf) _throw("tjEncodeYUV2(): Memory allocation failure");
+                srcBuf=toRGB(srcBuf, width, pitch, height, pixelFormat, rgbBuf);
+                pitch=width*RGB_PIXELSIZE;
+        }
+        #endif
+
         cinfo->image_width=width;
         cinfo->image_height=height;
 
         if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
         else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
         else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
 
         yuvsize=tjBufSizeYUV(width, height, subsamp);
         jpeg_mem_dest_tj(cinfo, &dstBuf, &yuvsize, 0);
         if(setCompDefaults(cinfo, pixelFormat, subsamp, -1)==-1) return -1;
@@ skipping 62 matching lines @@
                 for(i=0, compptr=cinfo->comp_info; i<cinfo->num_components; i++, compptr++)
                         jcopy_sample_rows(tmpbuf2[i], 0, outbuf[i],
                                 row*compptr->v_samp_factor/cinfo->max_v_samp_factor,
                                 compptr->v_samp_factor, cw[i]);
         }
         cinfo->next_scanline+=height;
         jpeg_abort_compress(cinfo);
 
         bailout:
         if(cinfo->global_state>CSTATE_START) jpeg_abort_compress(cinfo);
+        #ifndef JCS_EXTENSIONS
+        if(rgbBuf) free(rgbBuf);
+        #endif
         if(row_pointer) free(row_pointer);
         for(i=0; i<MAX_COMPONENTS; i++)
         {
                 if(tmpbuf[i]!=NULL) free(tmpbuf[i]);
                 if(_tmpbuf[i]!=NULL) free(_tmpbuf[i]);
                 if(tmpbuf2[i]!=NULL) free(tmpbuf2[i]);
                 if(_tmpbuf2[i]!=NULL) free(_tmpbuf2[i]);
                 if(outbuf[i]!=NULL) free(outbuf[i]);
         }
         return retval;
@@ skipping 107 matching lines @@
         return (tjscalingfactor *)sf;
 }
 
 
 DLLEXPORT int DLLCALL tjDecompress2(tjhandle handle, unsigned char *jpegBuf,
         unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
         int height, int pixelFormat, int flags)
 {
         int i, retval=0;  JSAMPROW *row_pointer=NULL;
         int jpegwidth, jpegheight, scaledw, scaledh;
+        #ifndef JCS_EXTENSIONS
+        unsigned char *rgbBuf=NULL;
+        unsigned char *_dstBuf=NULL;  int _pitch=0;
+        #endif
 
         getinstance(handle);
         if((this->init&DECOMPRESS)==0)
                 _throw("tjDecompress2(): Instance has not been initialized for decompression");
 
         if(jpegBuf==NULL || jpegSize<=0 || dstBuf==NULL || width<0 || pitch<0
                 || height<0 || pixelFormat<0 || pixelFormat>=TJ_NUMPF)
                 _throw("tjDecompress2(): Invalid argument");
 
         if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
         else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
         else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
 
         if(setjmp(this->jerr.setjmp_buffer))
         {
                 /* If we get here, the JPEG code has signaled an error. */
                 retval=-1;
                 goto bailout;
         }
 
         jpeg_mem_src_tj(dinfo, jpegBuf, jpegSize);
         jpeg_read_header(dinfo, TRUE);
-        if(setDecompDefaults(dinfo, pixelFormat)==-1) return -1;
+        if(setDecompDefaults(dinfo, pixelFormat)==-1)
+        {
+                retval=-1;  goto bailout;
+        }
 
         if(flags&TJFLAG_FASTUPSAMPLE) dinfo->do_fancy_upsampling=FALSE;
 
         jpegwidth=dinfo->image_width;  jpegheight=dinfo->image_height;
         if(width==0) width=jpegwidth;
         if(height==0) height=jpegheight;
         for(i=0; i<NUMSF; i++)
         {
                 scaledw=TJSCALED(jpegwidth, sf[i]);
                 scaledh=TJSCALED(jpegheight, sf[i]);
                 if(scaledw<=width && scaledh<=height)
                                 break;
         }
         if(scaledw>width || scaledh>height)
                 _throw("tjDecompress2(): Could not scale down to desired image dimensions");
         width=scaledw;  height=scaledh;
         dinfo->scale_num=sf[i].num;
         dinfo->scale_denom=sf[i].denom;
 
         jpeg_start_decompress(dinfo);
         if(pitch==0) pitch=dinfo->output_width*tjPixelSize[pixelFormat];
+
+        #ifndef JCS_EXTENSIONS
+        if(pixelFormat!=TJPF_GRAY &&
+                (RGB_RED!=tjRedOffset[pixelFormat] ||
+                        RGB_GREEN!=tjGreenOffset[pixelFormat] ||
+                        RGB_BLUE!=tjBlueOffset[pixelFormat] ||
+                        RGB_PIXELSIZE!=tjPixelSize[pixelFormat]))
+        {
+                rgbBuf=(unsigned char *)malloc(width*height*3);
+                if(!rgbBuf) _throw("tjDecompress2(): Memory allocation failure");
+                _pitch=pitch;  pitch=width*3;
+                _dstBuf=dstBuf;  dstBuf=rgbBuf;
+        }
+        #endif
+
         if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)
                 *dinfo->output_height))==NULL)
                 _throw("tjDecompress2(): Memory allocation failure");
         for(i=0; i<(int)dinfo->output_height; i++)
         {
                 if(flags&TJFLAG_BOTTOMUP)
                         row_pointer[i]=&dstBuf[(dinfo->output_height-i-1)*pitch];
                 else row_pointer[i]=&dstBuf[i*pitch];
         }
         while(dinfo->output_scanline<dinfo->output_height)
         {
                 jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
                         dinfo->output_height-dinfo->output_scanline);
         }
         jpeg_finish_decompress(dinfo);
 
+        #ifndef JCS_EXTENSIONS
+        fromRGB(rgbBuf, _dstBuf, width, _pitch, height, pixelFormat);
+        #endif
+
         bailout:
         if(dinfo->global_state>DSTATE_START) jpeg_abort_decompress(dinfo);
+        #ifndef JCS_EXTENSIONS
+        if(rgbBuf) free(rgbBuf);
+        #endif
         if(row_pointer) free(row_pointer);
         return retval;
 }
 
 DLLEXPORT int DLLCALL tjDecompress(tjhandle handle, unsigned char *jpegBuf,
         unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
         int height, int pixelSize, int flags)
 {
         if(flags&TJ_YUV)
                 return tjDecompressToYUV(handle, jpegBuf, jpegSize, dstBuf, flags);
@@ skipping 249 matching lines @@
                 if(!(t[i].options&TJXOPT_NOOUTPUT))
                 {
                         jpeg_write_coefficients(cinfo, dstcoefs);
                         jcopy_markers_execute(dinfo, cinfo, JCOPYOPT_ALL);
                 }
                 else jinit_c_master_control(cinfo, TRUE);
                 jtransform_execute_transformation(dinfo, cinfo, srccoefs,
                         &xinfo[i]);
                 if(t[i].customFilter)
                 {
-                        int ci, by, y;
+                        int ci, y;  JDIMENSION by;
                         for(ci=0; ci<cinfo->num_components; ci++)
                         {
                                 jpeg_component_info *compptr=&cinfo->comp_info[ci];
                                 tjregion arrayRegion={0, 0, compptr->width_in_blocks*DCTSIZE,
                                         DCTSIZE};
                                 tjregion planeRegion={0, 0, compptr->width_in_blocks*DCTSIZE,
                                         compptr->height_in_blocks*DCTSIZE};
                                 for(by=0; by<compptr->height_in_blocks; by+=compptr->v_samp_factor)
                                 {
                                         JBLOCKARRAY barray=(dinfo->mem->access_virt_barray)
@@ skipping 13 matching lines @@
         }
 
         jpeg_finish_decompress(dinfo);
 
         bailout:
         if(cinfo->global_state>CSTATE_START) jpeg_abort_compress(cinfo);
         if(dinfo->global_state>DSTATE_START) jpeg_abort_decompress(dinfo);
         if(xinfo) free(xinfo);
         return retval;
 }