Update libjpeg-turbo to r722.

turbojpeg.c

 /*
  * Copyright (C)2009-2011 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
@@ skipping 114 matching lines @@
                 }
                 else
                 {
                         if(flags&TJ_BGR) return TJPF_BGRX;
                         else return TJPF_RGBX;
                 }
         }
         return -1;
 }
 
-static void setCompDefaults(struct jpeg_compress_struct *cinfo,
+static int setCompDefaults(struct jpeg_compress_struct *cinfo,
         int pixelFormat, int subsamp, int jpegQual)
 {
+        int retval=0;
+
         switch(pixelFormat)
         {
                 case TJPF_GRAY:
                         cinfo->in_color_space=JCS_GRAYSCALE;  break;
                 #if JCS_EXTENSIONS==1
                 case TJPF_RGB:
                         cinfo->in_color_space=JCS_EXT_RGB;  break;
                 case TJPF_BGR:
                         cinfo->in_color_space=JCS_EXT_BGR;  break;
                 case TJPF_RGBX:
@@ skipping 27 matching lines @@
                 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 void setDecompDefaults(struct jpeg_decompress_struct *dinfo,
+static int setDecompDefaults(struct jpeg_decompress_struct *dinfo,
         int pixelFormat)
 {
+        int retval=0;
+
         switch(pixelFormat)
         {
                 case TJPF_GRAY:
                         dinfo->out_color_space=JCS_GRAYSCALE;  break;
                 #if JCS_EXTENSIONS==1
                 case TJPF_RGB:
                         dinfo->out_color_space=JCS_EXT_RGB;  break;
                 case TJPF_BGR:
                         dinfo->out_color_space=JCS_EXT_BGR;  break;
                 case TJPF_RGBX:
                         dinfo->out_color_space=JCS_EXT_RGBX;  break;
                 case TJPF_BGRX:
                         dinfo->out_color_space=JCS_EXT_BGRX;  break;
                 case TJPF_XRGB:
                         dinfo->out_color_space=JCS_EXT_XRGB;  break;
                 case TJPF_XBGR:
                         dinfo->out_color_space=JCS_EXT_XBGR;  break;
                 #else
                 case TJPF_RGB:
                         if(RGB_RED==0 && RGB_GREEN==1 && RGB_BLUE==2 && RGB_PIXELSIZE==3)
                         {
                                 dinfo->out_color_space=JCS_RGB;  break;
                         }
                 default:
                         _throw("Unsupported pixel format");
                 #endif
         }
+
+        #if JCS_EXTENSIONS!=1
+        bailout:
+        #endif
+        return retval;
 }
 
 
 static int getSubsamp(j_decompress_ptr dinfo)
 {
         int retval=-1, i, k;
         for(i=0; i<NUMSUBOPT; i++)
         {
                 if(dinfo->num_components==pixelsize[i])
                 {
@@ skipping 182 matching lines @@
 
         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);
         }
         jpeg_mem_dest_tj(cinfo, jpegBuf, jpegSize, alloc);
-        setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual);
+        if(setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual)==-1)
+                return -1;
 
         jpeg_start_compress(cinfo, TRUE);
         if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
                 _throw("tjCompress2(): Memory allocation failure");
         for(i=0; i<height; i++)
         {
                 if(flags&TJFLAG_BOTTOMUP) row_pointer[i]=&srcBuf[(height-i-1)*pitch];
                 else row_pointer[i]=&srcBuf[i*pitch];
         }
         while(cinfo->next_scanline<cinfo->image_height)
@@ skipping 70 matching lines @@
 
         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);
-        setCompDefaults(cinfo, pixelFormat, subsamp, -1);
+        if(setCompDefaults(cinfo, pixelFormat, subsamp, -1)==-1) return -1;
 
         jpeg_start_compress(cinfo, TRUE);
         pw=PAD(width, cinfo->max_h_samp_factor);
         ph=PAD(height, cinfo->max_v_samp_factor);
 
         if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*ph))==NULL)
                 _throw("tjEncodeYUV2(): Memory allocation failure");
         for(i=0; i<height; i++)
         {
                 if(flags&TJFLAG_BOTTOMUP) row_pointer[i]=&srcBuf[(height-i-1)*pitch];
@@ skipping 201 matching lines @@
 
         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);
-        setDecompDefaults(dinfo, pixelFormat);
+        if(setDecompDefaults(dinfo, pixelFormat)==-1) return -1;
 
         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]);
@@ skipping 273 matching lines @@
                         w=dinfo->image_width;  h=dinfo->image_height;
                 }
                 else
                 {
                         w=xinfo[i].crop_width;  h=xinfo[i].crop_height;
                 }
                 if(flags&TJFLAG_NOREALLOC)
                 {
                         alloc=0;  dstSizes[i]=tjBufSize(w, h, jpegSubsamp);
                 }
-                jpeg_mem_dest_tj(cinfo, &dstBufs[i], &dstSizes[i], alloc);
+                if(!(t[i].options&TJXOPT_NOOUTPUT))
+                        jpeg_mem_dest_tj(cinfo, &dstBufs[i], &dstSizes[i], alloc);
                 jpeg_copy_critical_parameters(dinfo, cinfo);
                 dstcoefs=jtransform_adjust_parameters(dinfo, cinfo, srccoefs,
                         &xinfo[i]);
-                jpeg_write_coefficients(cinfo, dstcoefs);
-                jcopy_markers_execute(dinfo, cinfo, JCOPYOPT_ALL);
+                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]);
-                jpeg_finish_compress(cinfo);
+                if(t[i].customFilter)
+                {
+                        int ci, by, y;
+                        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)
+                                                ((j_common_ptr)dinfo, dstcoefs[ci], by, compptr->v_samp_factor,
+                                                TRUE);
+                                        for(y=0; y<compptr->v_samp_factor; y++)
+                                        {
+                                                if(t[i].customFilter(barray[y][0], arrayRegion, planeRegion,
+                                                        ci, i, &t[i])==-1)
+                                                        _throw("tjTransform(): Error in custom filter");
+                                                arrayRegion.y+=DCTSIZE;
+                                        }
+                                }
+                        }
+                }
+                if(!(t[i].options&TJXOPT_NOOUTPUT)) jpeg_finish_compress(cinfo);
         }
 
         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;
 }