Merge branch 'turbovnc'

Conflicts, resolved manually:
	AUTHORS

18 files changed, 3652 insertions, 596 deletions

diff --git a/AUTHORS b/AUTHORS
index f87975d..76b17b5 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -35,7 +35,7 @@ Noriaki Yamazaki, Ben Klopfenstein, Vic Lee, Christian Beier,
 Alexander Dorokhine, Corentin Chary, Wouter Van Meir, George Kiagiadakis,
 Joel Martin, Gernot Tenchio, William Roberts, Cristian Rodríguez,
 George Fleury, Kan-Ru Chen, Steve Guo, Luca Stauble, Peter Watkins,
-Kyle J. McKay, Mateus Cesar Groess and Philip Van Hoof.
+Kyle J. McKay, Mateus Cesar Groess, Philip Van Hoof and D. R. Commander.
 
 Probably I forgot quite a few people sending a patch here and there, which
 really made a difference. Without those, some obscure bugs still would
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6e7b837..b9a67ca 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,6 +5,9 @@ include(CheckFunctionExists)
 include(CheckIncludeFile)
 include(CheckTypeSize)
 include(TestBigEndian)
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+include(CheckCSourceRuns)
 
 set(PACKAGE_NAME           "LibVNCServer")
 set(FULL_PACKAGE_NAME      "LibVNCServer")
@@ -30,6 +33,40 @@ find_package(X11)
 find_package(OpenSSL)
 find_library(LIBGCRYPT_LIBRARIES gcrypt)
 
+# Check whether the version of libjpeg we found was libjpeg-turbo and print a
+# warning if not.
+set(CMAKE_REQUIRED_LIBRARIES ${JPEG_LIBRARIES})
+set(CMAKE_REQUIRED_FLAGS -I${JPEG_INCLUDE_DIR})
+
+set(JPEG_TEST_SOURCE "\n
+  #include <stdio.h>\n
+  #include <jpeglib.h>\n
+  int main(void) {\n
+    struct jpeg_compress_struct cinfo;\n
+    struct jpeg_error_mgr jerr;\n
+    cinfo.err=jpeg_std_error(&jerr);\n
+    jpeg_create_compress(&cinfo);\n
+    cinfo.input_components = 3;\n
+    jpeg_set_defaults(&cinfo);\n
+    cinfo.in_color_space = JCS_EXT_RGB;\n
+    jpeg_default_colorspace(&cinfo);\n
+    return 0;\n
+  }")
+
+if(CMAKE_CROSSCOMPILING)
+  check_c_source_compiles("${JPEG_TEST_SOURCE}" FOUND_LIBJPEG_TURBO)
+else()
+  check_c_source_runs("${JPEG_TEST_SOURCE}" FOUND_LIBJPEG_TURBO)
+endif()
+
+set(CMAKE_REQUIRED_LIBRARIES)
+set(CMAKE_REQUIRED_FLAGS)
+set(CMAKE_REQUIRED_DEFINITIONS)
+
+if(NOT FOUND_LIBJPEG_TURBO)
+  message(WARNING "*** The libjpeg library you are building against is not libjpeg-turbo.  Performance will be reduced.  You can obtain libjpeg-turbo from:  https://sourceforge.net/projects/libjpeg-turbo/files/ ***")
+endif()
+
 set(CMAKE_REQUIRED_LIBRARIES resolv)
 check_function_exists(__b64_ntop HAVE_B64)
 
@@ -166,13 +203,13 @@ endif(ZLIB_FOUND)
 if(JPEG_FOUND)
   add_definitions(-DLIBVNCSERVER_HAVE_LIBJPEG)
   include_directories(${JPEG_INCLUDE_DIR})
-  set(TIGHT_C ${LIBVNCSERVER_DIR}/tight.c)
+  set(TIGHT_C ${LIBVNCSERVER_DIR}/tight.c ${COMMON_DIR}/turbojpeg.c)
 endif(JPEG_FOUND)
 
 if(PNG_FOUND)
   add_definitions(-DLIBVNCSERVER_HAVE_LIBPNG)
   include_directories(${PNG_INCLUDE_DIR})
-  set(TIGHT_C ${LIBVNCSERVER_DIR}/tight.c)
+  set(TIGHT_C ${LIBVNCSERVER_DIR}/tight.c ${COMMON_DIR}/turbojpeg.c)
 endif(PNG_FOUND)
 
 set(LIBVNCSERVER_SOURCES
diff --git a/common/turbojpeg.c b/common/turbojpeg.c
new file mode 100644
index 0000000..b3877ec
--- /dev/null
+++ b/common/turbojpeg.c
@@ -0,0 +1,849 @@
+/*
+ * 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
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* TurboJPEG/OSS:  this implements the TurboJPEG API using libjpeg-turbo */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef JCS_EXTENSIONS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+#include <jpeglib.h>
+#include <jerror.h>
+#include <setjmp.h>
+#include "./turbojpeg.h"
+
+#define PAD(v, p) ((v+(p)-1)&(~((p)-1)))
+
+#define CSTATE_START 100
+#define DSTATE_START 200
+#define MEMZERO(ptr, size) memset(ptr, 0, size)
+
+#ifndef min
+ #define min(a,b) ((a)<(b)?(a):(b))
+#endif
+
+#ifndef max
+ #define max(a,b) ((a)>(b)?(a):(b))
+#endif
+
+
+/* Error handling (based on example in example.c) */
+
+static char errStr[JMSG_LENGTH_MAX]="No error";
+
+struct my_error_mgr
+{
+	struct jpeg_error_mgr pub;
+	jmp_buf setjmp_buffer;
+};
+typedef struct my_error_mgr *my_error_ptr;
+
+static void my_error_exit(j_common_ptr cinfo)
+{
+	my_error_ptr myerr=(my_error_ptr)cinfo->err;
+	(*cinfo->err->output_message)(cinfo);
+	longjmp(myerr->setjmp_buffer, 1);
+}
+
+/* Based on output_message() in jerror.c */
+
+static void my_output_message(j_common_ptr cinfo)
+{
+	(*cinfo->err->format_message)(cinfo, errStr);
+}
+
+
+/* Global structures, macros, etc. */
+
+enum {COMPRESS=1, DECOMPRESS=2};
+
+typedef struct _tjinstance
+{
+	struct jpeg_compress_struct cinfo;
+	struct jpeg_decompress_struct dinfo;
+	struct jpeg_destination_mgr jdst;
+	struct jpeg_source_mgr jsrc;
+	struct my_error_mgr jerr;
+	int init;
+} tjinstance;
+
+static const int pixelsize[TJ_NUMSAMP]={3, 3, 3, 1, 3};
+
+#define NUMSF 4
+static const tjscalingfactor sf[NUMSF]={
+	{1, 1},
+	{1, 2},
+	{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;}  \
+	cinfo=&this->cinfo;  dinfo=&this->dinfo;
+
+static int getPixelFormat(int pixelSize, int flags)
+{
+	if(pixelSize==1) return TJPF_GRAY;
+	if(pixelSize==3)
+	{
+		if(flags&TJ_BGR) return TJPF_BGR;
+		else return TJPF_RGB;
+	}
+	if(pixelSize==4)
+	{
+		if(flags&TJ_ALPHAFIRST)
+		{
+			if(flags&TJ_BGR) return TJPF_XBGR;
+			else return TJPF_XRGB;
+		}
+		else
+		{
+			if(flags&TJ_BGR) return TJPF_BGRX;
+			else return TJPF_RGBX;
+		}
+	}
+	return -1;
+}
+
+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:
+		case TJPF_RGBA:
+			cinfo->in_color_space=JCS_EXT_RGBX;  break;
+		case TJPF_BGRX:
+		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:
+		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;
+
+	return retval;
+}
+
+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;
+		#if JCS_ALPHA_EXTENSIONS==1
+		case TJPF_RGBA:
+			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:
+		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;
+}
+
+
+static int getSubsamp(j_decompress_ptr dinfo)
+{
+	int retval=-1, i, k;
+	for(i=0; i<NUMSUBOPT; i++)
+	{
+		if(dinfo->num_components==pixelsize[i])
+		{
+			if(dinfo->comp_info[0].h_samp_factor==tjMCUWidth[i]/8
+				&& dinfo->comp_info[0].v_samp_factor==tjMCUHeight[i]/8)
+			{
+				int match=0;
+				for(k=1; k<dinfo->num_components; k++)
+				{
+					if(dinfo->comp_info[k].h_samp_factor==1
+						&& dinfo->comp_info[k].v_samp_factor==1)
+						match++;
+				}
+				if(match==dinfo->num_components-1)
+				{
+					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)
+{
+	getinstance(handle);
+	if(setjmp(this->jerr.setjmp_buffer)) return -1;
+	if(this->init&COMPRESS) jpeg_destroy_compress(cinfo);
+	if(this->init&DECOMPRESS) jpeg_destroy_decompress(dinfo);
+	free(this);
+	return 0;
+}
+
+
+/* Compressor  */
+
+static boolean empty_output_buffer(j_compress_ptr cinfo)
+{
+	ERREXIT(cinfo, JERR_BUFFER_SIZE);
+	return TRUE;
+}
+
+static void dst_noop(j_compress_ptr cinfo)
+{
+}
+
+static tjhandle _tjInitCompress(tjinstance *this)
+{
+	/* This is also straight out of example.c */
+	this->cinfo.err=jpeg_std_error(&this->jerr.pub);
+	this->jerr.pub.error_exit=my_error_exit;
+	this->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
+		if(this) free(this);  return NULL;
+	}
+
+	jpeg_create_compress(&this->cinfo);
+	this->cinfo.dest=&this->jdst;
+	this->jdst.init_destination=dst_noop;
+	this->jdst.empty_output_buffer=empty_output_buffer;
+	this->jdst.term_destination=dst_noop;
+
+	this->init|=COMPRESS;
+	return (tjhandle)this;
+}
+
+DLLEXPORT tjhandle DLLCALL tjInitCompress(void)
+{
+	tjinstance *this=NULL;
+	if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjInitCompress(): Memory allocation failure");
+		return NULL;
+	}
+	MEMZERO(this, sizeof(tjinstance));
+	return _tjInitCompress(this);
+}
+
+
+DLLEXPORT unsigned long DLLCALL tjBufSize(int width, int height,
+	int jpegSubsamp)
+{
+	unsigned long retval=0;  int mcuw, mcuh, chromasf;
+	if(width<1 || height<1 || jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT)
+		_throw("tjBufSize(): Invalid argument");
+
+	// This allows for rare corner cases in which a JPEG image can actually be
+	// larger than the uncompressed input (we wouldn't mention it if it hadn't
+	// happened before.)
+	mcuw=tjMCUWidth[jpegSubsamp];
+	mcuh=tjMCUHeight[jpegSubsamp];
+	chromasf=jpegSubsamp==TJSAMP_GRAY? 0: 4*64/(mcuw*mcuh);
+	retval=PAD(width, mcuw) * PAD(height, mcuh) * (2 + chromasf) + 2048;
+
+	bailout:
+	return retval;
+}
+
+
+DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height)
+{
+	unsigned long retval=0;
+	if(width<1 || height<1)
+		_throw("TJBUFSIZE(): Invalid argument");
+
+	// This allows for rare corner cases in which a JPEG image can actually be
+	// larger than the uncompressed input (we wouldn't mention it if it hadn't
+	// happened before.)
+	retval=PAD(width, 16) * PAD(height, 16) * 6 + 2048;
+
+	bailout:
+	return retval;
+}
+
+
+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;  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(setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual)==-1)
+		return -1;
+
+	this->jdst.next_output_byte=*jpegBuf;
+	this->jdst.free_in_buffer=tjBufSize(width, height, jpegSubsamp);
+
+	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)
+	{
+		jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
+			cinfo->image_height-cinfo->next_scanline);
+	}
+	jpeg_finish_compress(cinfo);
+ 	*jpegSize=tjBufSize(width, height, jpegSubsamp)
+		-(unsigned long)(this->jdst.free_in_buffer);
+
+	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;
+	retval=tjCompress2(handle, srcBuf, width, pitch, height,
+		getPixelFormat(pixelSize, flags), &jpegBuf, &size, jpegSubsamp, jpegQual,
+		flags);
+	*jpegSize=size;
+	return retval;
+}
+
+
+/* Decompressor */
+
+static boolean fill_input_buffer(j_decompress_ptr dinfo)
+{
+	ERREXIT(dinfo, JERR_BUFFER_SIZE);
+	return TRUE;
+}
+
+static void skip_input_data(j_decompress_ptr dinfo, long num_bytes)
+{
+	dinfo->src->next_input_byte += (size_t) num_bytes;
+	dinfo->src->bytes_in_buffer -= (size_t) num_bytes;
+}
+
+static void src_noop(j_decompress_ptr dinfo)
+{
+}
+
+static tjhandle _tjInitDecompress(tjinstance *this)
+{
+	/* This is also straight out of example.c */
+	this->dinfo.err=jpeg_std_error(&this->jerr.pub);
+	this->jerr.pub.error_exit=my_error_exit;
+	this->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
+		if(this) free(this);  return NULL;
+	}
+
+	jpeg_create_decompress(&this->dinfo);
+	this->dinfo.src=&this->jsrc;
+	this->jsrc.init_source=src_noop;
+	this->jsrc.fill_input_buffer=fill_input_buffer;
+	this->jsrc.skip_input_data=skip_input_data;
+	this->jsrc.resync_to_restart=jpeg_resync_to_restart;
+	this->jsrc.term_source=src_noop;
+
+	this->init|=DECOMPRESS;
+	return (tjhandle)this;
+}
+
+DLLEXPORT tjhandle DLLCALL tjInitDecompress(void)
+{
+	tjinstance *this;
+	if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjInitDecompress(): Memory allocation failure");
+		return NULL;
+	}
+	MEMZERO(this, sizeof(tjinstance));
+	return _tjInitDecompress(this);
+}
+
+
+DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle handle,
+	unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height,
+	int *jpegSubsamp)
+{
+	int retval=0;
+
+	getinstance(handle);
+	if((this->init&DECOMPRESS)==0)
+		_throw("tjDecompressHeader2(): Instance has not been initialized for decompression");
+
+	if(jpegBuf==NULL || jpegSize<=0 || width==NULL || height==NULL
+		|| jpegSubsamp==NULL)
+		_throw("tjDecompressHeader2(): Invalid argument");
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
+		return -1;
+	}
+
+	this->jsrc.bytes_in_buffer=jpegSize;
+	this->jsrc.next_input_byte=jpegBuf;
+	jpeg_read_header(dinfo, TRUE);
+
+	*width=dinfo->image_width;
+	*height=dinfo->image_height;
+	*jpegSubsamp=getSubsamp(dinfo);
+
+	jpeg_abort_decompress(dinfo);
+
+	if(*jpegSubsamp<0)
+		_throw("tjDecompressHeader2(): Could not determine subsampling type for JPEG image");
+	if(*width<1 || *height<1)
+		_throw("tjDecompressHeader2(): Invalid data returned in header");
+
+	bailout:
+	return retval;
+}
+
+DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle handle,
+	unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height)
+{
+	int jpegSubsamp;
+	return tjDecompressHeader2(handle, jpegBuf, jpegSize, width, height,
+		&jpegSubsamp);
+}
+
+
+DLLEXPORT tjscalingfactor* DLLCALL tjGetScalingFactors(int *numscalingfactors)
+{
+	if(numscalingfactors==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjGetScalingFactors(): Invalid argument");
+		return NULL;
+	}
+
+	*numscalingfactors=NUMSF;
+	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;
+	}
+
+	this->jsrc.bytes_in_buffer=jpegSize;
+	this->jsrc.next_input_byte=jpegBuf;
+	jpeg_read_header(dinfo, TRUE);
+	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)
+{
+	return tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, width, pitch,
+		height, getPixelFormat(pixelSize, flags), flags);
+}
diff --git a/common/turbojpeg.h b/common/turbojpeg.h
new file mode 100644
index 0000000..ab8adda
--- /dev/null
+++ b/common/turbojpeg.h
@@ -0,0 +1,529 @@
+/*
+ * 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
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TURBOJPEG_H__
+#define __TURBOJPEG_H__
+
+#if defined(_WIN32) && defined(DLLDEFINE)
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+#define DLLCALL
+
+
+/**
+ * @addtogroup TurboJPEG Lite
+ * TurboJPEG API.  This API provides an interface for generating and decoding
+ * JPEG images in memory.
+ *
+ * @{
+ */
+
+
+/**
+ * The number of chrominance subsampling options
+ */
+#define TJ_NUMSAMP 5
+
+/**
+ * Chrominance subsampling options.
+ * When an image is converted from the RGB to the YCbCr colorspace as part of
+ * the JPEG compression process, some of the Cb and Cr (chrominance) components
+ * can be discarded or averaged together to produce a smaller image with little
+ * perceptible loss of image clarity (the human eye is more sensitive to small
+ * changes in brightness than small changes in color.)  This is called
+ * "chrominance subsampling".
+ */
+enum TJSAMP
+{
+  /**
+   * 4:4:4 chrominance subsampling (no chrominance subsampling).  The JPEG or
+   * YUV image will contain one chrominance component for every pixel in the
+   * source image.
+   */
+  TJSAMP_444=0,
+  /**
+   * 4:2:2 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x1 block of pixels in the source image.
+   */
+  TJSAMP_422,
+  /**
+   * 4:2:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 2x2 block of pixels in the source image.
+   */
+  TJSAMP_420,
+  /**
+   * Grayscale.  The JPEG or YUV image will contain no chrominance components.
+   */
+  TJSAMP_GRAY,
+  /**
+   * 4:4:0 chrominance subsampling.  The JPEG or YUV image will contain one
+   * chrominance component for every 1x2 block of pixels in the source image.
+   */
+  TJSAMP_440
+};
+
+/**
+ * MCU block width (in pixels) for a given level of chrominance subsampling.
+ * MCU block sizes:
+ * - 8x8 for no subsampling or grayscale
+ * - 16x8 for 4:2:2
+ * - 8x16 for 4:4:0
+ * - 16x16 for 4:2:0 
+ */
+static const int tjMCUWidth[TJ_NUMSAMP]  = {8, 16, 16, 8, 8};
+
+/**
+ * MCU block height (in pixels) for a given level of chrominance subsampling.
+ * MCU block sizes:
+ * - 8x8 for no subsampling or grayscale
+ * - 16x8 for 4:2:2
+ * - 8x16 for 4:4:0
+ * - 16x16 for 4:2:0 
+ */
+static const int tjMCUHeight[TJ_NUMSAMP] = {8, 8, 16, 8, 16};
+
+
+/**
+ * The number of pixel formats
+ */
+#define TJ_NUMPF 11
+
+/**
+ * Pixel formats
+ */
+enum TJPF
+{
+  /**
+   * RGB pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.
+   */
+  TJPF_RGB=0,
+  /**
+   * BGR pixel format.  The red, green, and blue components in the image are
+   * stored in 3-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.
+   */
+  TJPF_BGR,
+  /**
+   * RGBX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_RGBX,
+  /**
+   * BGRX pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from lowest to highest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_BGRX,
+  /**
+   * XBGR pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order R, G, B from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_XBGR,
+  /**
+   * XRGB pixel format.  The red, green, and blue components in the image are
+   * stored in 4-byte pixels in the order B, G, R from highest to lowest byte
+   * address within each pixel.  The X component is ignored when compressing
+   * and undefined when decompressing.
+   */
+  TJPF_XRGB,
+  /**
+   * Grayscale pixel format.  Each 1-byte pixel represents a luminance
+   * (brightness) level from 0 to 255.
+   */
+  TJPF_GRAY,
+  /**
+   * RGBA pixel format.  This is the same as @ref TJPF_RGBX, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_RGBA,
+  /**
+   * BGRA pixel format.  This is the same as @ref TJPF_BGRX, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_BGRA,
+  /**
+   * ABGR pixel format.  This is the same as @ref TJPF_XBGR, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_ABGR,
+  /**
+   * ARGB pixel format.  This is the same as @ref TJPF_XRGB, except that when
+   * decompressing, the X component is guaranteed to be 0xFF, which can be
+   * interpreted as an opaque alpha channel.
+   */
+  TJPF_ARGB
+};
+
+/**
+ * Red offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the red component is offset from the start of the pixel.  For
+ * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
+ * then the red component will be <tt>pixel[tjRedOffset[TJ_BGRX]]</tt>.
+ */
+static const int tjRedOffset[TJ_NUMPF] = {0, 2, 0, 2, 3, 1, 0, 0, 2, 3, 1};
+/**
+ * Green offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the green component is offset from the start of the pixel.
+ * For instance, if a pixel of format TJ_BGRX is stored in
+ * <tt>char pixel[]</tt>, then the green component will be
+ * <tt>pixel[tjGreenOffset[TJ_BGRX]]</tt>.
+ */
+static const int tjGreenOffset[TJ_NUMPF] = {1, 1, 1, 1, 2, 2, 0, 1, 1, 2, 2};
+/**
+ * Blue offset (in bytes) for a given pixel format.  This specifies the number
+ * of bytes that the Blue component is offset from the start of the pixel.  For
+ * instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
+ * then the blue component will be <tt>pixel[tjBlueOffset[TJ_BGRX]]</tt>.
+ */
+static const int tjBlueOffset[TJ_NUMPF] = {2, 0, 2, 0, 1, 3, 0, 2, 0, 1, 3};
+
+/**
+ * Pixel size (in bytes) for a given pixel format.
+ */
+static const int tjPixelSize[TJ_NUMPF] = {3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4};
+
+
+/**
+ * The uncompressed source/destination image is stored in bottom-up (Windows,
+ * OpenGL) order, not top-down (X11) order.
+ */
+#define TJFLAG_BOTTOMUP        2
+/**
+ * Turn off CPU auto-detection and force TurboJPEG to use MMX code (IPP and
+ * 32-bit libjpeg-turbo versions only.)
+ */
+#define TJFLAG_FORCEMMX        8
+/**
+ * Turn off CPU auto-detection and force TurboJPEG to use SSE code (32-bit IPP
+ * and 32-bit libjpeg-turbo versions only)
+ */
+#define TJFLAG_FORCESSE       16
+/**
+ * Turn off CPU auto-detection and force TurboJPEG to use SSE2 code (32-bit IPP
+ * and 32-bit libjpeg-turbo versions only)
+ */
+#define TJFLAG_FORCESSE2      32
+/**
+ * Turn off CPU auto-detection and force TurboJPEG to use SSE3 code (64-bit IPP
+ * version only)
+ */
+#define TJFLAG_FORCESSE3     128
+/**
+ * Use fast, inaccurate chrominance upsampling routines in the JPEG
+ * decompressor (libjpeg and libjpeg-turbo versions only)
+ */
+#define TJFLAG_FASTUPSAMPLE  256
+
+
+/**
+ * Scaling factor
+ */
+typedef struct
+{
+  /**
+   * Numerator
+   */
+  int num;
+  /**
+   * Denominator
+   */
+  int denom;
+} tjscalingfactor;
+
+
+/**
+ * TurboJPEG instance handle
+ */
+typedef void* tjhandle;
+
+
+/**
+ * Pad the given width to the nearest 32-bit boundary
+ */
+#define TJPAD(width) (((width)+3)&(~3))
+
+/**
+ * Compute the scaled value of <tt>dimension</tt> using the given scaling
+ * factor.  This macro performs the integer equivalent of <tt>ceil(dimension *
+ * scalingFactor)</tt>. 
+ */
+#define TJSCALED(dimension, scalingFactor) ((dimension * scalingFactor.num \
+  + scalingFactor.denom - 1) / scalingFactor.denom)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Create a TurboJPEG compressor instance.
+ *
+ * @return a handle to the newly-created instance, or NULL if an error
+ * occurred (see #tjGetErrorStr().)
+ */
+DLLEXPORT tjhandle DLLCALL tjInitCompress(void);
+
+
+/**
+ * Compress an RGB or grayscale image into a JPEG image.
+ *
+ * @param handle a handle to a TurboJPEG compressor or transformer instance
+ * @param srcBuf pointer to an image buffer containing RGB or grayscale pixels
+ *        to be compressed
+ * @param width width (in pixels) of the source image
+ * @param pitch bytes per line of the source image.  Normally, this should be
+ *        <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded,
+ *        or <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of
+ *        the image is padded to the nearest 32-bit boundary, as is the case
+ *        for Windows bitmaps.  You can also be clever and use this parameter
+ *        to skip lines, etc.  Setting this parameter to 0 is the equivalent of
+ *        setting it to <tt>width * #tjPixelSize[pixelFormat]</tt>.
+ * @param height height (in pixels) of the source image
+ * @param pixelFormat pixel format of the source image (see @ref TJPF
+ *        "Pixel formats".)
+ * @param jpegBuf address of a pointer to an image buffer that will receive the
+ *        JPEG image.  TurboJPEG has the ability to reallocate the JPEG buffer
+ *        to accommodate the size of the JPEG image.  Thus, you can choose to:
+ *        -# pre-allocate the JPEG buffer with an arbitrary size using
+ *        #tjAlloc() and let TurboJPEG grow the buffer as needed,
+ *        -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the
+ *        buffer for you, or
+ *        -# pre-allocate the buffer to a "worst case" size determined by
+ *        calling #tjBufSize().  This should ensure that the buffer never has
+ *        to be re-allocated (setting #TJFLAG_NOREALLOC guarantees this.)
+ *        .
+ *        If you choose option 1, <tt>*jpegSize</tt> should be set to the
+ *        size of your pre-allocated buffer.  In any case, unless you have
+ *        set #TJFLAG_NOREALLOC, you should always check <tt>*jpegBuf</tt> upon
+ *        return from this function, as it may have changed.
+ * @param jpegSize pointer to an unsigned long variable that holds the size of
+ *        the JPEG image buffer.  If <tt>*jpegBuf</tt> points to a
+ *        pre-allocated buffer, then <tt>*jpegSize</tt> should be set to the
+ *        size of the buffer.  Upon return, <tt>*jpegSize</tt> will contain the
+ *        size of the JPEG image (in bytes.)
+ * @param jpegSubsamp the level of chrominance subsampling to be used when
+ *        generating the JPEG image (see @ref TJSAMP
+ *        "Chrominance subsampling options".)
+ * @param jpegQual the image quality of the generated JPEG image (1 = worst,
+          100 = best)
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
+ *        "flags".
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
+*/
+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);
+
+
+/**
+ * The maximum size of the buffer (in bytes) required to hold a JPEG image with
+ * the given parameters.  The number of bytes returned by this function is
+ * larger than the size of the uncompressed source image.  The reason for this
+ * is that the JPEG format uses 16-bit coefficients, and it is thus possible
+ * for a very high-quality JPEG image with very high frequency content to
+ * expand rather than compress when converted to the JPEG format.  Such images
+ * represent a very rare corner case, but since there is no way to predict the
+ * size of a JPEG image prior to compression, the corner case has to be
+ * handled.
+ *
+ * @param width width of the image (in pixels)
+ * @param height height of the image (in pixels)
+ * @param jpegSubsamp the level of chrominance subsampling to be used when
+ *        generating the JPEG image (see @ref TJSAMP
+ *        "Chrominance subsampling options".)
+ *
+ * @return the maximum size of the buffer (in bytes) required to hold the
+ * image, or -1 if the arguments are out of bounds.
+ */
+DLLEXPORT unsigned long DLLCALL tjBufSize(int width, int height,
+  int jpegSubsamp);
+
+
+/**
+ * Create a TurboJPEG decompressor instance.
+ *
+ * @return a handle to the newly-created instance, or NULL if an error
+ * occurred (see #tjGetErrorStr().)
+*/
+DLLEXPORT tjhandle DLLCALL tjInitDecompress(void);
+
+
+/**
+ * Retrieve information about a JPEG image without decompressing it.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ * @param jpegBuf pointer to a buffer containing a JPEG image
+ * @param jpegSize size of the JPEG image (in bytes)
+ * @param width pointer to an integer variable that will receive the width (in
+ *        pixels) of the JPEG image
+ * @param height pointer to an integer variable that will receive the height
+ *        (in pixels) of the JPEG image
+ * @param jpegSubsamp pointer to an integer variable that will receive the
+ *        level of chrominance subsampling used when compressing the JPEG image
+ *        (see @ref TJSAMP "Chrominance subsampling options".)
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
+*/
+DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle handle,
+  unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height,
+  int *jpegSubsamp);
+
+
+/**
+ * Returns a list of fractional scaling factors that the JPEG decompressor in
+ * this implementation of TurboJPEG supports.
+ *
+ * @param numscalingfactors pointer to an integer variable that will receive
+ *        the number of elements in the list
+ *
+ * @return a pointer to a list of fractional scaling factors, or NULL if an
+ * error is encountered (see #tjGetErrorStr().)
+*/
+DLLEXPORT tjscalingfactor* DLLCALL tjGetScalingFactors(int *numscalingfactors);
+
+
+/**
+ * Decompress a JPEG image to an RGB or grayscale image.
+ *
+ * @param handle a handle to a TurboJPEG decompressor or transformer instance
+ * @param jpegBuf pointer to a buffer containing the JPEG image to decompress
+ * @param jpegSize size of the JPEG image (in bytes)
+ * @param dstBuf pointer to an image buffer that will receive the decompressed
+ *        image.  This buffer should normally be <tt>pitch * scaledHeight</tt>
+ *        bytes in size, where <tt>scaledHeight</tt> can be determined by
+ *        calling #TJSCALED() with the JPEG image height and one of the scaling
+ *        factors returned by #tjGetScalingFactors().  The dstBuf pointer may
+ *        also be used to decompress into a specific region of a larger buffer.
+ * @param width desired width (in pixels) of the destination image.  If this is
+ *        smaller than the width of the JPEG image being decompressed, then
+ *        TurboJPEG will use scaling in the JPEG decompressor to generate the
+ *        largest possible image that will fit within the desired width.  If
+ *        width is set to 0, then only the height will be considered when
+ *        determining the scaled image size.
+ * @param pitch bytes per line of the destination image.  Normally, this is
+ *        <tt>scaledWidth * #tjPixelSize[pixelFormat]</tt> if the decompressed
+ *        image is unpadded, else <tt>#TJPAD(scaledWidth *
+ *        #tjPixelSize[pixelFormat])</tt> if each line of the decompressed
+ *        image is padded to the nearest 32-bit boundary, as is the case for
+ *        Windows bitmaps.  (NOTE: <tt>scaledWidth</tt> can be determined by
+ *        calling #TJSCALED() with the JPEG image width and one of the scaling
+ *        factors returned by #tjGetScalingFactors().)  You can also be clever
+ *        and use the pitch parameter to skip lines, etc.  Setting this
+ *        parameter to 0 is the equivalent of setting it to <tt>scaledWidth
+ *        * #tjPixelSize[pixelFormat]</tt>.
+ * @param height desired height (in pixels) of the destination image.  If this
+ *        is smaller than the height of the JPEG image being decompressed, then
+ *        TurboJPEG will use scaling in the JPEG decompressor to generate the
+ *        largest possible image that will fit within the desired height.  If
+ *        height is set to 0, then only the width will be considered when
+ *        determining the scaled image size.
+ * @param pixelFormat pixel format of the destination image (see @ref
+ *        TJPF "Pixel formats".)
+ * @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
+ *        "flags".
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
+ */
+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);
+
+
+/**
+ * Destroy a TurboJPEG compressor, decompressor, or transformer instance.
+ *
+ * @param handle a handle to a TurboJPEG compressor, decompressor or
+ *        transformer instance
+ *
+ * @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
+ */
+DLLEXPORT int DLLCALL tjDestroy(tjhandle handle);
+
+
+/**
+ * Returns a descriptive error message explaining why the last command failed.
+ *
+ * @return a descriptive error message explaining why the last command failed.
+ */
+DLLEXPORT char* DLLCALL tjGetErrorStr(void);
+
+
+/* Backward compatibility functions and macros (nothing to see here) */
+#define NUMSUBOPT TJ_NUMSAMP
+#define TJ_444 TJSAMP_444
+#define TJ_422 TJSAMP_422
+#define TJ_420 TJSAMP_420
+#define TJ_411 TJSAMP_420
+#define TJ_GRAYSCALE TJSAMP_GRAY
+
+#define TJ_BGR 1
+#define TJ_BOTTOMUP TJFLAG_BOTTOMUP
+#define TJ_FORCEMMX TJFLAG_FORCEMMX
+#define TJ_FORCESSE TJFLAG_FORCESSE
+#define TJ_FORCESSE2 TJFLAG_FORCESSE2
+#define TJ_ALPHAFIRST 64
+#define TJ_FORCESSE3 TJFLAG_FORCESSE3
+#define TJ_FASTUPSAMPLE TJFLAG_FASTUPSAMPLE
+
+DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height);
+
+DLLEXPORT int DLLCALL tjCompress(tjhandle handle, unsigned char *srcBuf,
+  int width, int pitch, int height, int pixelSize, unsigned char *dstBuf,
+  unsigned long *compressedSize, int jpegSubsamp, int jpegQual, int flags);
+
+DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle handle,
+  unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height);
+
+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);
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/configure.ac b/configure.ac
index f157c12..4e9c889 100644
--- a/configure.ac
+++ b/configure.ac
@@ -528,7 +528,11 @@ AC_ARG_WITH(jpeg,
 #	-without-jpeg             with_jpeg="no"
 #	-with-jpeg=/foo/dir       with_jpeg="/foo/dir"
 
+HAVE_LIBJPEG_TURBO="false"
+
 if test "x$with_jpeg" != "xno"; then
+	AC_ARG_VAR(JPEG_LDFLAGS,
+		[Linker flags to use when linking with libjpeg, e.g. -L/foo/dir/lib -Wl,-static -ljpeg -Wl,-shared.  This overrides the linker flags set by --with-jpeg.])
 	if test ! -z "$with_jpeg" -a "x$with_jpeg" != "xyes"; then
 		# add user supplied directory to flags:
 		saved_CPPFLAGS="$CPPFLAGS"
@@ -544,9 +548,19 @@ if test "x$with_jpeg" != "xno"; then
 			LDFLAGS="$LDFLAGS -R$with_jpeg/lib"
 		fi
 	fi
+	if test "x$JPEG_LDFLAGS" != "x"; then
+		LDFLAGS="$saved_LDFLAGS"
+		LIBS="$LIBS $JPEG_LDFLAGS"
+	else
+		LIBS="-ljpeg"
+	fi
 	AC_CHECK_HEADER(jpeglib.h, HAVE_JPEGLIB_H="true")
+	AC_MSG_CHECKING(for jpeg_CreateCompress in libjpeg)
 	if test "x$HAVE_JPEGLIB_H" = "xtrue"; then
-		AC_CHECK_LIB(jpeg, jpeg_CreateCompress, , HAVE_JPEGLIB_H="")
+		AC_LINK_IFELSE([AC_LANG_CALL([], [jpeg_CreateCompress])],
+			[AC_MSG_RESULT(yes);
+				AC_DEFINE(HAVE_LIBJPEG, 1, libjpeg support enabled)],
+			[AC_MSG_RESULT(no); HAVE_JPEGLIB_H=""])
 	fi
 	if test ! -z "$with_jpeg" -a "x$with_jpeg" != "xyes"; then
 		if test "x$HAVE_JPEGLIB_H" != "xtrue"; then
@@ -563,13 +577,52 @@ if test "x$with_jpeg" != "xno"; then
 This may lead to reduced performance, especially over slow links.
 If libjpeg is in a non-standard location use --with-jpeg=DIR to
 indicate the header file is in DIR/include/jpeglib.h and the library
-in DIR/lib/libjpeg.a.  A copy of libjpeg may be obtained from:
-ftp://ftp.uu.net/graphics/jpeg/
+in DIR/lib/libjpeg.a.  You can also set the JPEG_LDFLAGS variable to
+specify more detailed linker flags.  A copy of libjpeg-turbo may be
+obtained from:  https://sourceforge.net/projects/libjpeg-turbo/files/
+A copy of libjpeg may be obtained from:  http://ijg.org/files/
 ==========================================================================
 ])
 			sleep 5
 		fi
 	fi
+
+	if test "x$HAVE_JPEGLIB_H" = "xtrue"; then
+		AC_MSG_CHECKING(whether JPEG library is libjpeg-turbo)
+		m4_define([LJT_TEST],
+			[AC_LANG_PROGRAM([#include <stdio.h>
+				#include <jpeglib.h>],
+			[struct jpeg_compress_struct cinfo;
+				struct jpeg_error_mgr jerr;
+				cinfo.err=jpeg_std_error(&jerr);
+				jpeg_create_compress(&cinfo);
+				cinfo.input_components = 3;
+				jpeg_set_defaults(&cinfo);
+				cinfo.in_color_space = JCS_EXT_RGB;
+				jpeg_default_colorspace(&cinfo);
+				return 0;])]
+		)
+		if test "x$cross_compiling" != "xyes"; then
+			AC_RUN_IFELSE([LJT_TEST],
+				[HAVE_LIBJPEG_TURBO="true"; AC_MSG_RESULT(yes)],
+				[AC_MSG_RESULT(no)])
+		else
+			AC_LINK_IFELSE([LJT_TEST],
+				[HAVE_LIBJPEG_TURBO="true"; AC_MSG_RESULT(yes)],
+				[AC_MSG_RESULT(no)])
+		fi
+	fi
+
+	if test "x$HAVE_LIBJPEG_TURBO" != "xtrue"; then
+		AC_MSG_WARN([
+==========================================================================
+*** The libjpeg library you are building against is not libjpeg-turbo.
+Performance will be reduced.  You can obtain libjpeg-turbo from:
+https://sourceforge.net/projects/libjpeg-turbo/files/ ***
+==========================================================================
+])
+  fi
+
 fi
 
 AC_ARG_WITH(png,
diff --git a/libvncserver/Makefile.am b/libvncserver/Makefile.am
index fce398d..c0cd4c3 100644
--- a/libvncserver/Makefile.am
+++ b/libvncserver/Makefile.am
@@ -46,7 +46,7 @@ EXTRA_DIST=tableinit24.c tableinittctemplate.c tabletranstemplate.c \
 if HAVE_LIBZ
 ZLIBSRCS = zlib.c zrle.c zrleoutstream.c zrlepalettehelper.c ../common/zywrletemplate.c
 if HAVE_LIBJPEG
-TIGHTSRCS = tight.c
+TIGHTSRCS = tight.c ../common/turbojpeg.c
 endif
 endif
 
diff --git a/libvncserver/rfbserver.c b/libvncserver/rfbserver.c
index 23c4d77..e18f31d 100644
--- a/libvncserver/rfbserver.c
+++ b/libvncserver/rfbserver.c
@@ -3,6 +3,7 @@
  */
 
 /*
+ *  Copyright (C) 2011-2012 D. R. Commander
  *  Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
  *  Copyright (C) 2002 RealVNC Ltd.
  *  OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
@@ -86,6 +87,21 @@ static int compat_mkdir(const char *path, int mode)
 #define mkdir compat_mkdir
 #endif
 
+#ifdef LIBVNCSERVER_HAVE_LIBJPEG
+/*
+ * Map of quality levels to provide compatibility with TightVNC/TigerVNC
+ * clients.  This emulates the behavior of the TigerVNC Server.
+ */
+
+static const int tight2turbo_qual[10] = {
+   15, 29, 41, 42, 62, 77, 79, 86, 92, 100
+};
+
+static const int tight2turbo_subsamp[10] = {
+   1, 1, 1, 2, 2, 2, 0, 0, 0, 0
+};
+#endif
+
 static void rfbProcessClientProtocolVersion(rfbClientPtr cl);
 static void rfbProcessClientNormalMessage(rfbClientPtr cl);
 static void rfbProcessClientInitMessage(rfbClientPtr cl);
@@ -383,6 +399,7 @@ rfbNewTCPOrUDPClient(rfbScreenInfoPtr rfbScreen,
       cl->tightCompressLevel = TIGHT_DEFAULT_COMPRESSION;
 #endif
 #ifdef LIBVNCSERVER_HAVE_LIBJPEG
+      cl->turboSubsampLevel = TURBO_DEFAULT_SUBSAMP;
       {
 	int i;
 	for (i = 0; i < 4; i++)
@@ -1963,6 +1980,16 @@ rfbProcessClientNormalMessage(rfbClientPtr cl)
         cl->enableSupportedMessages  = FALSE;
         cl->enableSupportedEncodings = FALSE;
         cl->enableServerIdentity     = FALSE;
+#if defined(LIBVNCSERVER_HAVE_LIBZ) || defined(LIBVNCSERVER_HAVE_LIBPNG)
+        cl->tightQualityLevel        = -1;
+#if defined(LIBVNCSERVER_HAVE_LIBJPEG) || defined(LIBVNCSERVER_HAVE_LIBPNG)
+        cl->tightCompressLevel       = TIGHT_DEFAULT_COMPRESSION;
+#endif
+#ifdef LIBVNCSERVER_HAVE_LIBJPEG
+        cl->turboSubsampLevel        = TURBO_DEFAULT_SUBSAMP;
+        cl->turboQualityLevel        = -1;
+#endif
+#endif
 
 
         for (i = 0; i < msg.se.nEncodings; i++) {
@@ -2097,6 +2124,22 @@ rfbProcessClientNormalMessage(rfbClientPtr cl)
 		    cl->tightQualityLevel = enc & 0x0F;
 		    rfbLog("Using image quality level %d for client %s\n",
 			   cl->tightQualityLevel, cl->host);
+#ifdef LIBVNCSERVER_HAVE_LIBJPEG
+		    cl->turboQualityLevel = tight2turbo_qual[enc & 0x0F];
+		    cl->turboSubsampLevel = tight2turbo_subsamp[enc & 0x0F];
+		    rfbLog("Using JPEG subsampling %d, Q%d for client %s\n",
+			   cl->turboSubsampLevel, cl->turboQualityLevel, cl->host);
+		} else if ( enc >= (uint32_t)rfbEncodingFineQualityLevel0 + 1 &&
+			    enc <= (uint32_t)rfbEncodingFineQualityLevel100 ) {
+		    cl->turboQualityLevel = enc & 0xFF;
+		    rfbLog("Using fine quality level %d for client %s\n",
+			   cl->turboQualityLevel, cl->host);
+		} else if ( enc >= (uint32_t)rfbEncodingSubsamp1X &&
+			    enc <= (uint32_t)rfbEncodingSubsampGray ) {
+		    cl->turboSubsampLevel = enc & 0xFF;
+		    rfbLog("Using subsampling level %d for client %s\n",
+			   cl->turboSubsampLevel, cl->host);
+#endif
 		} else
 #endif
 		{
diff --git a/libvncserver/tight.c b/libvncserver/tight.c
index 474e9e3..6d5bcbb 100644
--- a/libvncserver/tight.c
+++ b/libvncserver/tight.c
@@ -2,9 +2,20 @@
  * tight.c
  *
  * Routines to implement Tight Encoding
+ *
+ * Our Tight encoder is based roughly on the TurboVNC v0.6 encoder with some
+ * additional enhancements from TurboVNC 1.1.  For lower compression levels,
+ * this encoder provides a tremendous reduction in CPU usage (and subsequently,
+ * an increase in throughput for CPU-limited environments) relative to the
+ * TightVNC encoder, whereas Compression Level 9 provides a low-bandwidth mode
+ * that behaves similarly to Compression Levels 5-9 in the old TightVNC
+ * encoder.
  */
 
 /*
+ *  Copyright (C) 2010-2012 D. R. Commander.  All Rights Reserved.
+ *  Copyright (C) 2005-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ *  Copyright (C) 2004 Landmark Graphics Corporation.  All Rights Reserved.
  *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
  *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
  *
@@ -20,27 +31,18 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this software; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  *  USA.
  */
 
-/*#include <stdio.h>*/
 #include <rfb/rfb.h>
 #include "private.h"
 
-#ifdef WIN32
-#define XMD_H
-#undef FAR
-#define NEEDFAR_POINTERS
-#endif
-
-#ifdef _RPCNDR_H /* This Windows header typedefs 'boolean', jpeglib has to know */
-#define HAVE_BOOLEAN
-#endif
 #ifdef LIBVNCSERVER_HAVE_LIBPNG
 #include <png.h>
 #endif
-#include <jpeglib.h>
+#include "turbojpeg.h"
+
 
 /* Note: The following constant should not be changed. */
 #define TIGHT_MIN_TO_COMPRESS 12
@@ -50,9 +52,6 @@
 #define MIN_SOLID_SUBRECT_SIZE  2048
 #define MAX_SPLIT_TILE_SIZE       16
 
-/* May be set to TRUE with "-lazytight" Xvnc option. */
-rfbBool rfbTightDisableGradient = FALSE;
-
 /*
  * There is so much access of the Tight encoding static data buffers
  * that we resort to using thread local storage instead of having
@@ -68,30 +67,24 @@ rfbBool rfbTightDisableGradient = FALSE;
 /* This variable is set on every rfbSendRectEncodingTight() call. */
 static TLS rfbBool usePixelFormat24 = FALSE;
 
+
 /* Compression level stuff. The following array contains various
    encoder parameters for each of 10 compression levels (0..9).
    Last three parameters correspond to JPEG quality levels (0..9). */
 
 typedef struct TIGHT_CONF_s {
     int maxRectSize, maxRectWidth;
-    int monoMinRectSize, gradientMinRectSize;
-    int idxZlibLevel, monoZlibLevel, rawZlibLevel, gradientZlibLevel;
-    int gradientThreshold, gradientThreshold24;
+    int monoMinRectSize;
+    int idxZlibLevel, monoZlibLevel, rawZlibLevel;
     int idxMaxColorsDivisor;
-    int jpegQuality, jpegThreshold, jpegThreshold24;
+    int palMaxColorsWithJPEG;
 } TIGHT_CONF;
 
-static TIGHT_CONF tightConf[10] = {
-    {   512,   32,   6, 65536, 0, 0, 0, 0,   0,   0,   4,  5, 10000, 23000 },
-    {  2048,  128,   6, 65536, 1, 1, 1, 0,   0,   0,   8, 10,  8000, 18000 },
-    {  6144,  256,   8, 65536, 3, 3, 2, 0,   0,   0,  24, 15,  6500, 15000 },
-    { 10240, 1024,  12, 65536, 5, 5, 3, 0,   0,   0,  32, 25,  5000, 12000 },
-    { 16384, 2048,  12, 65536, 6, 6, 4, 0,   0,   0,  32, 37,  4000, 10000 },
-    { 32768, 2048,  12,  4096, 7, 7, 5, 4, 150, 380,  32, 50,  3000,  8000 },
-    { 65536, 2048,  16,  4096, 7, 7, 6, 4, 170, 420,  48, 60,  2000,  5000 },
-    { 65536, 2048,  16,  4096, 8, 8, 7, 5, 180, 450,  64, 70,  1000,  2500 },
-    { 65536, 2048,  32,  8192, 9, 9, 8, 6, 190, 475,  64, 75,   500,  1200 },
-    { 65536, 2048,  32,  8192, 9, 9, 9, 6, 200, 500,  96, 80,   200,   500 }
+static TIGHT_CONF tightConf[4] = {
+    { 65536, 2048,   6, 0, 0, 0,   4, 24 }, // 0  (used only without JPEG)
+    { 65536, 2048,  32, 1, 1, 1,  96, 24 }, // 1
+    { 65536, 2048,  32, 3, 3, 2,  96, 96 }, // 2  (used only with JPEG)
+    { 65536, 2048,  32, 7, 7, 5,  96, 256 } // 9
 };
 
 #ifdef LIBVNCSERVER_HAVE_LIBPNG
@@ -113,8 +106,14 @@ static TIGHT_PNG_CONF tightPngConf[10] = {
 };
 #endif
 
-static TLS int compressLevel = 0;
-static TLS int qualityLevel = 0;
+static TLS int compressLevel = 1;
+static TLS int qualityLevel = 95;
+static TLS int subsampLevel = TJ_444;
+
+static const int subsampLevel2tjsubsamp[4] = {
+    TJ_444, TJ_420, TJ_422, TJ_GRAYSCALE
+};
+
 
 /* Stuff dealing with palettes. */
 
@@ -150,22 +149,24 @@ static TLS char *tightBeforeBuf = NULL;
 static TLS int tightAfterBufSize = 0;
 static TLS char *tightAfterBuf = NULL;
 
-static TLS int *prevRowBuf = NULL;
+static TLS tjhandle j = NULL;
 
-void rfbTightCleanup(rfbScreenInfoPtr screen)
+void rfbTightCleanup (rfbScreenInfoPtr screen)
 {
-  if(tightBeforeBufSize) {
-    free(tightBeforeBuf);
-    tightBeforeBufSize=0;
-    tightBeforeBuf = NULL;
-  }
-  if(tightAfterBufSize) {
-    free(tightAfterBuf);
-    tightAfterBufSize=0;
-    tightAfterBuf = NULL;
-  }
+    if (tightBeforeBufSize) {
+        free (tightBeforeBuf);
+        tightBeforeBufSize = 0;
+        tightBeforeBuf = NULL;
+    }
+    if (tightAfterBufSize) {
+        free (tightAfterBuf);
+        tightAfterBufSize = 0;
+        tightAfterBuf = NULL;
+    }
+    if (j) tjDestroy(j);
 }
 
+
 /* Prototypes for static functions. */
 
 static rfbBool SendRectEncodingTight(rfbClientPtr cl, int x, int y,
@@ -176,13 +177,13 @@ static void ExtendSolidArea   (rfbClientPtr cl, int x, int y, int w, int h,
                                uint32_t colorValue,
                                int *x_ptr, int *y_ptr, int *w_ptr, int *h_ptr);
 static rfbBool CheckSolidTile    (rfbClientPtr cl, int x, int y, int w, int h,
-                               uint32_t *colorPtr, rfbBool needSameColor);
+                                  uint32_t *colorPtr, rfbBool needSameColor);
 static rfbBool CheckSolidTile8   (rfbClientPtr cl, int x, int y, int w, int h,
-                               uint32_t *colorPtr, rfbBool needSameColor);
+                                  uint32_t *colorPtr, rfbBool needSameColor);
 static rfbBool CheckSolidTile16  (rfbClientPtr cl, int x, int y, int w, int h,
-                               uint32_t *colorPtr, rfbBool needSameColor);
+                                  uint32_t *colorPtr, rfbBool needSameColor);
 static rfbBool CheckSolidTile32  (rfbClientPtr cl, int x, int y, int w, int h,
-                               uint32_t *colorPtr, rfbBool needSameColor);
+                                  uint32_t *colorPtr, rfbBool needSameColor);
 
 static rfbBool SendRectSimple    (rfbClientPtr cl, int x, int y, int w, int h);
 static rfbBool SendSubrect       (rfbClientPtr cl, int x, int y, int w, int h);
@@ -192,49 +193,40 @@ static rfbBool SendSolidRect     (rfbClientPtr cl);
 static rfbBool SendMonoRect      (rfbClientPtr cl, int x, int y, int w, int h);
 static rfbBool SendIndexedRect   (rfbClientPtr cl, int x, int y, int w, int h);
 static rfbBool SendFullColorRect (rfbClientPtr cl, int x, int y, int w, int h);
-static rfbBool SendGradientRect  (rfbClientPtr cl, int x, int y, int w, int h);
-
-static rfbBool CompressData(rfbClientPtr cl, int streamId, int dataLen,
-                         int zlibLevel, int zlibStrategy);
-static rfbBool SendCompressedData(rfbClientPtr cl, int compressedLen);
-
-static void FillPalette8(int count);
-static void FillPalette16(int count);
-static void FillPalette32(int count);
 
-static void PaletteReset(void);
-static int PaletteInsert(uint32_t rgb, int numPixels, int bpp);
+static rfbBool CompressData (rfbClientPtr cl, int streamId, int dataLen,
+                             int zlibLevel, int zlibStrategy);
+static rfbBool SendCompressedData (rfbClientPtr cl, char *buf,
+                                   int compressedLen);
 
-static void Pack24(rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, int count);
+static void FillPalette8 (int count);
+static void FillPalette16 (int count);
+static void FillPalette32 (int count);
+static void FastFillPalette16 (rfbClientPtr cl, uint16_t *data, int w,
+                               int pitch, int h);
+static void FastFillPalette32 (rfbClientPtr cl, uint32_t *data, int w,
+                               int pitch, int h);
 
-static void EncodeIndexedRect16(uint8_t *buf, int count);
-static void EncodeIndexedRect32(uint8_t *buf, int count);
+static void PaletteReset (void);
+static int PaletteInsert (uint32_t rgb, int numPixels, int bpp);
 
-static void EncodeMonoRect8(uint8_t *buf, int w, int h);
-static void EncodeMonoRect16(uint8_t *buf, int w, int h);
-static void EncodeMonoRect32(uint8_t *buf, int w, int h);
+static void Pack24 (rfbClientPtr cl, char *buf, rfbPixelFormat *fmt,
+                    int count);
 
-static void FilterGradient24(rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, int w, int h);
-static void FilterGradient16(rfbClientPtr cl, uint16_t *buf, rfbPixelFormat *fmt, int w, int h);
-static void FilterGradient32(rfbClientPtr cl, uint32_t *buf, rfbPixelFormat *fmt, int w, int h);
+static void EncodeIndexedRect16 (uint8_t *buf, int count);
+static void EncodeIndexedRect32 (uint8_t *buf, int count);
 
-static int DetectSmoothImage(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h);
-static unsigned long DetectSmoothImage24(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h);
-static unsigned long DetectSmoothImage16(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h);
-static unsigned long DetectSmoothImage32(rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h);
+static void EncodeMonoRect8 (uint8_t *buf, int w, int h);
+static void EncodeMonoRect16 (uint8_t *buf, int w, int h);
+static void EncodeMonoRect32 (uint8_t *buf, int w, int h);
 
-static rfbBool SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h,
-                         int quality);
+static rfbBool SendJpegRect (rfbClientPtr cl, int x, int y, int w, int h,
+                             int quality);
 static void PrepareRowForImg(rfbClientPtr cl, uint8_t *dst, int x, int y, int count);
 static void PrepareRowForImg24(rfbClientPtr cl, uint8_t *dst, int x, int y, int count);
 static void PrepareRowForImg16(rfbClientPtr cl, uint8_t *dst, int x, int y, int count);
 static void PrepareRowForImg32(rfbClientPtr cl, uint8_t *dst, int x, int y, int count);
 
-static void JpegInitDestination(j_compress_ptr cinfo);
-static boolean JpegEmptyOutputBuffer(j_compress_ptr cinfo);
-static void JpegTermDestination(j_compress_ptr cinfo);
-static void JpegSetDstManager(j_compress_ptr cinfo);
-
 #ifdef LIBVNCSERVER_HAVE_LIBPNG
 static rfbBool SendPngRect(rfbClientPtr cl, int x, int y, int w, int h);
 static rfbBool CanSendPngRect(rfbClientPtr cl, int w, int h);
@@ -257,10 +249,10 @@ rfbNumCodedRectsTight(rfbClientPtr cl,
     /* No matter how many rectangles we will send if LastRect markers
        are used to terminate rectangle stream. */
     if (cl->enableLastRectEncoding && w * h >= MIN_SPLIT_RECT_SIZE)
-      return 0;
+        return 0;
 
-    maxRectSize = tightConf[cl->tightCompressLevel].maxRectSize;
-    maxRectWidth = tightConf[cl->tightCompressLevel].maxRectWidth;
+    maxRectSize = tightConf[compressLevel].maxRectSize;
+    maxRectWidth = tightConf[compressLevel].maxRectWidth;
 
     if (w > maxRectWidth || w * h > maxRectSize) {
         subrectMaxWidth = (w > maxRectWidth) ? maxRectWidth : w;
@@ -311,7 +303,34 @@ SendRectEncodingTight(rfbClientPtr cl,
     rfbSendUpdateBuf(cl);
 
     compressLevel = cl->tightCompressLevel;
-    qualityLevel = cl->tightQualityLevel;
+    qualityLevel = cl->turboQualityLevel;
+    subsampLevel = cl->turboSubsampLevel;
+
+    /* We only allow compression levels that have a demonstrable performance
+       benefit.  CL 0 with JPEG reduces CPU usage for workloads that have low
+       numbers of unique colors, but the same thing can be accomplished by
+       using CL 0 without JPEG (AKA "Lossless Tight.")  For those same
+       low-color workloads, CL 2 can provide typically 20-40% better
+       compression than CL 1 (with a commensurate increase in CPU usage.)  For
+       high-color workloads, CL 1 should always be used, as higher compression
+       levels increase CPU usage for these workloads without providing any
+       significant reduction in bandwidth. */
+    if (qualityLevel != -1) {
+        if (compressLevel < 1) compressLevel = 1;
+        if (compressLevel > 2) compressLevel = 2;
+    }
+
+    /* With JPEG disabled, CL 2 offers no significant bandwidth savings over
+       CL 1, so we don't include it. */
+    else if (compressLevel > 1) compressLevel = 1;
+
+    /* CL 9 (which maps internally to CL 3) is included mainly for backward
+       compatibility with TightVNC Compression Levels 5-9.  It should be used
+       only in extremely low-bandwidth cases in which it can be shown to have a
+       benefit.  For low-color workloads, it provides typically only 10-20%
+       better compression than CL 2 with JPEG and CL 1 without JPEG, and it
+       uses, on average, twice as much CPU time. */
+    if (cl->tightCompressLevel == 9) compressLevel = 3;
 
     if ( cl->format.depth == 24 && cl->format.redMax == 0xFF &&
          cl->format.greenMax == 0xFF && cl->format.blueMax == 0xFF ) {
@@ -331,7 +350,7 @@ SendRectEncodingTight(rfbClientPtr cl,
             tightBeforeBuf = (char *)malloc(tightBeforeBufSize);
         else
             tightBeforeBuf = (char *)realloc(tightBeforeBuf,
-                                              tightBeforeBufSize);
+                                             tightBeforeBufSize);
     }
 
     /* Calculate maximum number of rows in one non-solid rectangle. */
@@ -359,15 +378,24 @@ SendRectEncodingTight(rfbClientPtr cl,
         }
 
         dh = (dy + MAX_SPLIT_TILE_SIZE <= y + h) ?
-            MAX_SPLIT_TILE_SIZE : (y + h - dy);
+             MAX_SPLIT_TILE_SIZE : (y + h - dy);
 
         for (dx = x; dx < x + w; dx += MAX_SPLIT_TILE_SIZE) {
 
             dw = (dx + MAX_SPLIT_TILE_SIZE <= x + w) ?
-                MAX_SPLIT_TILE_SIZE : (x + w - dx);
+                 MAX_SPLIT_TILE_SIZE : (x + w - dx);
 
             if (CheckSolidTile(cl, dx, dy, dw, dh, &colorValue, FALSE)) {
 
+                if (subsampLevel == TJ_GRAYSCALE && qualityLevel != -1) {
+                    uint32_t r = (colorValue >> 16) & 0xFF;
+                    uint32_t g = (colorValue >> 8) & 0xFF;
+                    uint32_t b = (colorValue) & 0xFF;
+                    double y = (0.257 * (double)r) + (0.504 * (double)g)
+                             + (0.098 * (double)b) + 16.;
+                    colorValue = (int)y + (((int)y) << 8) + (((int)y) << 16);
+                }
+
                 /* Get dimensions of solid-color area. */
 
                 FindBestSolidArea(cl, dx, dy, w - (dx - x), h - (dy - y),
@@ -415,12 +443,12 @@ SendRectEncodingTight(rfbClientPtr cl,
                 /* Send remaining rectangles (at right and bottom). */
 
                 if ( x_best + w_best != x + w &&
-                     !SendRectEncodingTight(cl, x_best+w_best, y_best,
-                                               w-(x_best-x)-w_best, h_best) )
+                     !SendRectEncodingTight(cl, x_best + w_best, y_best,
+                                               w - (x_best-x) - w_best, h_best) )
                     return FALSE;
                 if ( y_best + h_best != y + h &&
-                     !SendRectEncodingTight(cl, x, y_best+h_best,
-                                               w, h-(y_best-y)-h_best) )
+                     !SendRectEncodingTight(cl, x, y_best + h_best,
+                                               w, h - (y_best-y) - h_best) )
                     return FALSE;
 
                 /* Return after all recursive calls are done. */
@@ -437,6 +465,7 @@ SendRectEncodingTight(rfbClientPtr cl,
     return SendRectSimple(cl, x, y, w, h);
 }
 
+
 static void
 FindBestSolidArea(rfbClientPtr cl,
                   int x,
@@ -456,16 +485,16 @@ FindBestSolidArea(rfbClientPtr cl,
     for (dy = y; dy < y + h; dy += MAX_SPLIT_TILE_SIZE) {
 
         dh = (dy + MAX_SPLIT_TILE_SIZE <= y + h) ?
-            MAX_SPLIT_TILE_SIZE : (y + h - dy);
+             MAX_SPLIT_TILE_SIZE : (y + h - dy);
         dw = (w_prev > MAX_SPLIT_TILE_SIZE) ?
-            MAX_SPLIT_TILE_SIZE : w_prev;
+             MAX_SPLIT_TILE_SIZE : w_prev;
 
         if (!CheckSolidTile(cl, x, dy, dw, dh, &colorValue, TRUE))
             break;
 
         for (dx = x + dw; dx < x + w_prev;) {
             dw = (dx + MAX_SPLIT_TILE_SIZE <= x + w_prev) ?
-                MAX_SPLIT_TILE_SIZE : (x + w_prev - dx);
+                 MAX_SPLIT_TILE_SIZE : (x + w_prev - dx);
             if (!CheckSolidTile(cl, dx, dy, dw, dh, &colorValue, TRUE))
                 break;
 	    dx += dw;
@@ -482,6 +511,7 @@ FindBestSolidArea(rfbClientPtr cl,
     *h_ptr = h_best;
 }
 
+
 static void
 ExtendSolidArea(rfbClientPtr cl,
                 int x,
@@ -525,6 +555,7 @@ ExtendSolidArea(rfbClientPtr cl,
     *w_ptr += cx - (*x_ptr + *w_ptr);
 }
 
+
 /*
  * Check if a rectangle is all of the same color. If needSameColor is
  * set to non-zero, then also check that its color equals to the
@@ -544,6 +575,7 @@ static rfbBool CheckSolidTile(rfbClientPtr cl, int x, int y, int w, int h, uint3
     }
 }
 
+
 #define DEFINE_CHECK_SOLID_FUNCTION(bpp)                                      \
                                                                               \
 static rfbBool                                                                \
@@ -554,8 +586,8 @@ CheckSolidTile##bpp(rfbClientPtr cl, int x, int y, int w, int h,              \
     uint##bpp##_t colorValue;                                                 \
     int dx, dy;                                                               \
                                                                               \
-    fbptr = (uint##bpp##_t *)                                                 \
-        &cl->scaledScreen->frameBuffer[y * cl->scaledScreen->paddedWidthInBytes + x * (bpp/8)]; \
+    fbptr = (uint##bpp##_t *)&cl->scaledScreen->frameBuffer                   \
+        [y * cl->scaledScreen->paddedWidthInBytes + x * (bpp/8)];             \
                                                                               \
     colorValue = *fbptr;                                                      \
     if (needSameColor && (uint32_t)colorValue != *colorPtr)                   \
@@ -566,7 +598,8 @@ CheckSolidTile##bpp(rfbClientPtr cl, int x, int y, int w, int h,              \
             if (colorValue != fbptr[dx])                                      \
                 return FALSE;                                                 \
         }                                                                     \
-        fbptr = (uint##bpp##_t *)((uint8_t *)fbptr + cl->scaledScreen->paddedWidthInBytes); \
+        fbptr = (uint##bpp##_t *)((uint8_t *)fbptr                            \
+                 + cl->scaledScreen->paddedWidthInBytes);                     \
     }                                                                         \
                                                                               \
     *colorPtr = (uint32_t)colorValue;                                         \
@@ -598,7 +631,7 @@ SendRectSimple(rfbClientPtr cl, int x, int y, int w, int h)
             tightBeforeBuf = (char *)malloc(tightBeforeBufSize);
         else
             tightBeforeBuf = (char *)realloc(tightBeforeBuf,
-                                              tightBeforeBufSize);
+                                             tightBeforeBufSize);
     }
 
     if (tightAfterBufSize < maxAfterSize) {
@@ -607,7 +640,7 @@ SendRectSimple(rfbClientPtr cl, int x, int y, int w, int h)
             tightAfterBuf = (char *)malloc(tightAfterBufSize);
         else
             tightAfterBuf = (char *)realloc(tightAfterBuf,
-                                             tightAfterBufSize);
+                                            tightAfterBufSize);
     }
 
     if (w > maxRectWidth || w * h > maxRectSize) {
@@ -618,7 +651,7 @@ SendRectSimple(rfbClientPtr cl, int x, int y, int w, int h)
             for (dx = 0; dx < w; dx += maxRectWidth) {
                 rw = (dx + maxRectWidth < w) ? maxRectWidth : w - dx;
                 rh = (dy + subrectMaxHeight < h) ? subrectMaxHeight : h - dy;
-                if (!SendSubrect(cl, x+dx, y+dy, rw, rh))
+                if (!SendSubrect(cl, x + dx, y + dy, rw, rh))
                     return FALSE;
             }
         }
@@ -649,39 +682,68 @@ SendSubrect(rfbClientPtr cl,
     if (!SendTightHeader(cl, x, y, w, h))
         return FALSE;
 
-    fbptr = (cl->scaledScreen->frameBuffer + (cl->scaledScreen->paddedWidthInBytes * y)
+    fbptr = (cl->scaledScreen->frameBuffer
+             + (cl->scaledScreen->paddedWidthInBytes * y)
              + (x * (cl->scaledScreen->bitsPerPixel / 8)));
 
-    (*cl->translateFn)(cl->translateLookupTable, &cl->screen->serverFormat,
-                       &cl->format, fbptr, tightBeforeBuf,
-                       cl->scaledScreen->paddedWidthInBytes, w, h);
+    if (subsampLevel == TJ_GRAYSCALE && qualityLevel != -1)
+        return SendJpegRect(cl, x, y, w, h, qualityLevel);
 
     paletteMaxColors = w * h / tightConf[compressLevel].idxMaxColorsDivisor;
+    if(qualityLevel != -1)
+        paletteMaxColors = tightConf[compressLevel].palMaxColorsWithJPEG;
     if ( paletteMaxColors < 2 &&
          w * h >= tightConf[compressLevel].monoMinRectSize ) {
         paletteMaxColors = 2;
     }
-    switch (cl->format.bitsPerPixel) {
-    case 8:
-        FillPalette8(w * h);
-        break;
-    case 16:
-        FillPalette16(w * h);
-        break;
-    default:
-        FillPalette32(w * h);
+
+    if (cl->format.bitsPerPixel == cl->screen->serverFormat.bitsPerPixel &&
+        cl->format.redMax == cl->screen->serverFormat.redMax &&
+        cl->format.greenMax == cl->screen->serverFormat.greenMax && 
+        cl->format.blueMax == cl->screen->serverFormat.blueMax &&
+        cl->format.bitsPerPixel >= 16) {
+
+        /* This is so we can avoid translating the pixels when compressing
+           with JPEG, since it is unnecessary */
+        switch (cl->format.bitsPerPixel) {
+        case 16:
+            FastFillPalette16(cl, (uint16_t *)fbptr, w,
+                              cl->scaledScreen->paddedWidthInBytes / 2, h);
+            break;
+        default:
+            FastFillPalette32(cl, (uint32_t *)fbptr, w,
+                              cl->scaledScreen->paddedWidthInBytes / 4, h);
+        }
+
+        if(paletteNumColors != 0 || qualityLevel == -1) {
+            (*cl->translateFn)(cl->translateLookupTable,
+                               &cl->screen->serverFormat, &cl->format, fbptr,
+                               tightBeforeBuf,
+                               cl->scaledScreen->paddedWidthInBytes, w, h);
+        }
+    }
+    else {
+        (*cl->translateFn)(cl->translateLookupTable, &cl->screen->serverFormat,
+                           &cl->format, fbptr, tightBeforeBuf,
+                           cl->scaledScreen->paddedWidthInBytes, w, h);
+
+        switch (cl->format.bitsPerPixel) {
+        case 8:
+            FillPalette8(w * h);
+            break;
+        case 16:
+            FillPalette16(w * h);
+            break;
+        default:
+            FillPalette32(w * h);
+        }
     }
 
     switch (paletteNumColors) {
     case 0:
         /* Truecolor image */
-        if (DetectSmoothImage(cl, &cl->format, w, h)) {
-            if (qualityLevel != -1) {
-                success = SendJpegRect(cl, x, y, w, h,
-                                       tightConf[qualityLevel].jpegQuality);
-            } else {
-                success = SendGradientRect(cl, x, y, w, h);
-            }
+        if (qualityLevel != -1) {
+            success = SendJpegRect(cl, x, y, w, h, qualityLevel);
         } else {
             success = SendFullColorRect(cl, x, y, w, h);
         }
@@ -696,14 +758,7 @@ SendSubrect(rfbClientPtr cl,
         break;
     default:
         /* Up to 256 different colors */
-        if ( paletteNumColors > 96 &&
-             qualityLevel != -1 && qualityLevel <= 3 &&
-             DetectSmoothImage(cl, &cl->format, w, h) ) {
-            success = SendJpegRect(cl, x, y, w, h,
-                                   tightConf[qualityLevel].jpegQuality);
-        } else {
-            success = SendIndexedRect(cl, x, y, w, h);
-        }
+        success = SendIndexedRect(cl, x, y, w, h);
     }
     return success;
 }
@@ -732,8 +787,10 @@ SendTightHeader(rfbClientPtr cl,
            sz_rfbFramebufferUpdateRectHeader);
     cl->ublen += sz_rfbFramebufferUpdateRectHeader;
 
-    rfbStatRecordEncodingSent(cl, cl->tightEncoding, sz_rfbFramebufferUpdateRectHeader,
-                              sz_rfbFramebufferUpdateRectHeader + w * (cl->format.bitsPerPixel / 8) * h);
+    rfbStatRecordEncodingSent(cl, cl->tightEncoding,
+                              sz_rfbFramebufferUpdateRectHeader,
+                              sz_rfbFramebufferUpdateRectHeader
+                                  + w * (cl->format.bitsPerPixel / 8) * h);
 
     return TRUE;
 }
@@ -762,7 +819,7 @@ SendSolidRect(rfbClientPtr cl)
     memcpy (&cl->updateBuf[cl->ublen], tightBeforeBuf, len);
     cl->ublen += len;
 
-    rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, len+1);
+    rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, len + 1);
 
     return TRUE;
 }
@@ -795,7 +852,12 @@ SendMonoRect(rfbClientPtr cl,
     dataLen = (w + 7) / 8;
     dataLen *= h;
 
-    cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
+    if (tightConf[compressLevel].monoZlibLevel == 0 &&
+        cl->tightEncoding != rfbEncodingTightPng)
+        cl->updateBuf[cl->ublen++] =
+            (char)((rfbTightNoZlib | rfbTightExplicitFilter) << 4);
+    else
+        cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
     cl->updateBuf[cl->ublen++] = rfbTightFilterPalette;
     cl->updateBuf[cl->ublen++] = 1;
 
@@ -866,7 +928,12 @@ SendIndexedRect(rfbClientPtr cl,
     }
 
     /* Prepare tight encoding header. */
-    cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
+    if (tightConf[compressLevel].idxZlibLevel == 0 &&
+        cl->tightEncoding != rfbEncodingTightPng)
+        cl->updateBuf[cl->ublen++] =
+            (char)((rfbTightNoZlib | rfbTightExplicitFilter) << 4);
+    else
+        cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
     cl->updateBuf[cl->ublen++] = rfbTightFilterPalette;
     cl->updateBuf[cl->ublen++] = (char)(paletteNumColors - 1);
 
@@ -886,9 +953,11 @@ SendIndexedRect(rfbClientPtr cl,
         } else
             entryLen = 4;
 
-        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * entryLen);
+        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf,
+               paletteNumColors * entryLen);
         cl->ublen += paletteNumColors * entryLen;
-        rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 3 + paletteNumColors * entryLen);
+        rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding,
+                                     3 + paletteNumColors * entryLen);
         break;
 
     case 16:
@@ -901,7 +970,8 @@ SendIndexedRect(rfbClientPtr cl,
 
         memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * 2);
         cl->ublen += paletteNumColors * 2;
-        rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 3 + paletteNumColors * 2);
+        rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding,
+                                     3 + paletteNumColors * 2);
         break;
 
     default:
@@ -934,7 +1004,11 @@ SendFullColorRect(rfbClientPtr cl,
             return FALSE;
     }
 
-    cl->updateBuf[cl->ublen++] = 0x00;  /* stream id = 0, no flushing, no filter */
+    if (tightConf[compressLevel].rawZlibLevel == 0 &&
+        cl->tightEncoding != rfbEncodingTightPng)
+        cl->updateBuf[cl->ublen++] = (char)(rfbTightNoZlib << 4);
+    else
+        cl->updateBuf[cl->ublen++] = 0x00;  /* stream id = 0, no flushing, no filter */
     rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 1);
 
     if (usePixelFormat24) {
@@ -949,53 +1023,6 @@ SendFullColorRect(rfbClientPtr cl,
 }
 
 static rfbBool
-SendGradientRect(rfbClientPtr cl,
-                 int x,
-                 int y,
-                 int w,
-                 int h)
-{
-    int streamId = 3;
-    int len;
-
-#ifdef LIBVNCSERVER_HAVE_LIBPNG
-    if (CanSendPngRect(cl, w, h)) {
-        return SendPngRect(cl, x, y, w, h);
-    }
-#endif
-
-    if (cl->format.bitsPerPixel == 8)
-        return SendFullColorRect(cl, x, y, w, h);
-
-    if (cl->ublen + TIGHT_MIN_TO_COMPRESS + 2 > UPDATE_BUF_SIZE) {
-        if (!rfbSendUpdateBuf(cl))
-            return FALSE;
-    }
-
-    if (prevRowBuf == NULL)
-        prevRowBuf = (int *)malloc(2048 * 3 * sizeof(int));
-
-    cl->updateBuf[cl->ublen++] = (streamId | rfbTightExplicitFilter) << 4;
-    cl->updateBuf[cl->ublen++] = rfbTightFilterGradient;
-    rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 2);
-
-    if (usePixelFormat24) {
-        FilterGradient24(cl, tightBeforeBuf, &cl->format, w, h);
-        len = 3;
-    } else if (cl->format.bitsPerPixel == 32) {
-        FilterGradient32(cl, (uint32_t *)tightBeforeBuf, &cl->format, w, h);
-        len = 4;
-    } else {
-        FilterGradient16(cl, (uint16_t *)tightBeforeBuf, &cl->format, w, h);
-        len = 2;
-    }
-
-    return CompressData(cl, streamId, w * h * len,
-                        tightConf[compressLevel].gradientZlibLevel,
-                        Z_FILTERED);
-}
-
-static rfbBool
 CompressData(rfbClientPtr cl,
              int streamId,
              int dataLen,
@@ -1012,6 +1039,9 @@ CompressData(rfbClientPtr cl,
         return TRUE;
     }
 
+    if (zlibLevel == 0)
+        return SendCompressedData (cl, tightBeforeBuf, dataLen);
+
     pz = &cl->zsStruct[streamId];
 
     /* Initialize compression stream if needed. */
@@ -1044,15 +1074,16 @@ CompressData(rfbClientPtr cl,
     }
 
     /* Actual compression. */
-    if ( deflate (pz, Z_SYNC_FLUSH) != Z_OK ||
-         pz->avail_in != 0 || pz->avail_out == 0 ) {
+    if (deflate(pz, Z_SYNC_FLUSH) != Z_OK ||
+        pz->avail_in != 0 || pz->avail_out == 0) {
         return FALSE;
     }
 
-    return SendCompressedData(cl, tightAfterBufSize - pz->avail_out);
+    return SendCompressedData(cl, tightAfterBuf,
+                              tightAfterBufSize - pz->avail_out);
 }
 
-static rfbBool SendCompressedData(rfbClientPtr cl,
+static rfbBool SendCompressedData(rfbClientPtr cl, char *buf,
                                   int compressedLen)
 {
     int i, portionLen;
@@ -1079,7 +1110,7 @@ static rfbBool SendCompressedData(rfbClientPtr cl,
             if (!rfbSendUpdateBuf(cl))
                 return FALSE;
         }
-        memcpy(&cl->updateBuf[cl->ublen], &tightAfterBuf[i], portionLen);
+        memcpy(&cl->updateBuf[cl->ublen], &buf[i], portionLen);
         cl->ublen += portionLen;
     }
     rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, compressedLen);
@@ -1087,6 +1118,7 @@ static rfbBool SendCompressedData(rfbClientPtr cl,
     return TRUE;
 }
 
+
 /*
  * Code to determine how many different colors used in rectangle.
  */
@@ -1133,6 +1165,7 @@ FillPalette8(int count)
     }
 }
 
+
 #define DEFINE_FILL_PALETTE_FUNCTION(bpp)                               \
                                                                         \
 static void                                                             \
@@ -1198,13 +1231,117 @@ FillPalette##bpp(int count) {                                           \
 DEFINE_FILL_PALETTE_FUNCTION(16)
 DEFINE_FILL_PALETTE_FUNCTION(32)
 
+#define DEFINE_FAST_FILL_PALETTE_FUNCTION(bpp)                          \
+                                                                        \
+static void                                                             \
+FastFillPalette##bpp(rfbClientPtr cl, uint##bpp##_t *data, int w,       \
+                     int pitch, int h)                                  \
+{                                                                       \
+    uint##bpp##_t c0, c1, ci, mask, c0t, c1t, cit;                      \
+    int i, j, i2 = 0, j2, n0, n1, ni;                                   \
+                                                                        \
+    if (cl->translateFn != rfbTranslateNone) {                          \
+        mask = cl->screen->serverFormat.redMax                          \
+            << cl->screen->serverFormat.redShift;                       \
+        mask |= cl->screen->serverFormat.greenMax                       \
+             << cl->screen->serverFormat.greenShift;                    \
+        mask |= cl->screen->serverFormat.blueMax                        \
+             << cl->screen->serverFormat.blueShift;                     \
+    } else mask = ~0;                                                   \
+                                                                        \
+    c0 = data[0] & mask;                                                \
+    for (j = 0; j < h; j++) {                                           \
+        for (i = 0; i < w; i++) {                                       \
+            if ((data[j * pitch + i] & mask) != c0)                     \
+                goto done;                                              \
+        }                                                               \
+    }                                                                   \
+    done:                                                               \
+    if (j >= h) {                                                       \
+        paletteNumColors = 1;   /* Solid rectangle */                   \
+        return;                                                         \
+    }                                                                   \
+    if (paletteMaxColors < 2) {                                         \
+        paletteNumColors = 0;   /* Full-color encoding preferred */     \
+        return;                                                         \
+    }                                                                   \
+                                                                        \
+    n0 = j * w + i;                                                     \
+    c1 = data[j * pitch + i] & mask;                                    \
+    n1 = 0;                                                             \
+    i++;  if (i >= w) {i = 0;  j++;}                                    \
+    for (j2 = j; j2 < h; j2++) {                                        \
+        for (i2 = i; i2 < w; i2++) {                                    \
+            ci = data[j2 * pitch + i2] & mask;                          \
+            if (ci == c0) {                                             \
+                n0++;                                                   \
+            } else if (ci == c1) {                                      \
+                n1++;                                                   \
+            } else                                                      \
+                goto done2;                                             \
+        }                                                               \
+        i = 0;                                                          \
+    }                                                                   \
+    done2:                                                              \
+    (*cl->translateFn)(cl->translateLookupTable,                        \
+                       &cl->screen->serverFormat, &cl->format,          \
+                       (char *)&c0, (char *)&c0t, bpp/8, 1, 1);         \
+    (*cl->translateFn)(cl->translateLookupTable,                        \
+                       &cl->screen->serverFormat, &cl->format,          \
+                       (char *)&c1, (char *)&c1t, bpp/8, 1, 1);         \
+    if (j2 >= h) {                                                      \
+        if (n0 > n1) {                                                  \
+            monoBackground = (uint32_t)c0t;                             \
+            monoForeground = (uint32_t)c1t;                             \
+        } else {                                                        \
+            monoBackground = (uint32_t)c1t;                             \
+            monoForeground = (uint32_t)c0t;                             \
+        }                                                               \
+        paletteNumColors = 2;   /* Two colors */                        \
+        return;                                                         \
+    }                                                                   \
+                                                                        \
+    PaletteReset();                                                     \
+    PaletteInsert (c0t, (uint32_t)n0, bpp);                             \
+    PaletteInsert (c1t, (uint32_t)n1, bpp);                             \
+                                                                        \
+    ni = 1;                                                             \
+    i2++;  if (i2 >= w) {i2 = 0;  j2++;}                                \
+    for (j = j2; j < h; j++) {                                          \
+        for (i = i2; i < w; i++) {                                      \
+            if ((data[j * pitch + i] & mask) == ci) {                   \
+                ni++;                                                   \
+            } else {                                                    \
+                (*cl->translateFn)(cl->translateLookupTable,            \
+                                   &cl->screen->serverFormat,           \
+                                   &cl->format, (char *)&ci,            \
+                                   (char *)&cit, bpp/8, 1, 1);          \
+                if (!PaletteInsert (cit, (uint32_t)ni, bpp))            \
+                    return;                                             \
+                ci = data[j * pitch + i] & mask;                        \
+                ni = 1;                                                 \
+            }                                                           \
+        }                                                               \
+        i2 = 0;                                                         \
+    }                                                                   \
+                                                                        \
+    (*cl->translateFn)(cl->translateLookupTable,                        \
+                       &cl->screen->serverFormat, &cl->format,          \
+                       (char *)&ci, (char *)&cit, bpp/8, 1, 1);         \
+    PaletteInsert (cit, (uint32_t)ni, bpp);                             \
+}
+
+DEFINE_FAST_FILL_PALETTE_FUNCTION(16)
+DEFINE_FAST_FILL_PALETTE_FUNCTION(32)
+
 
 /*
  * Functions to operate with palette structures.
  */
 
-#define HASH_FUNC16(rgb) ((int)(((rgb >> 8) + rgb) & 0xFF))
-#define HASH_FUNC32(rgb) ((int)(((rgb >> 16) + (rgb >> 8)) & 0xFF))
+#define HASH_FUNC16(rgb) ((int)((((rgb) >> 8) + (rgb)) & 0xFF))
+#define HASH_FUNC32(rgb) ((int)((((rgb) >> 16) + ((rgb) >> 8)) & 0xFF))
+
 
 static void
 PaletteReset(void)
@@ -1213,6 +1350,7 @@ PaletteReset(void)
     memset(palette.hash, 0, 256 * sizeof(COLOR_LIST *));
 }
 
+
 static int
 PaletteInsert(uint32_t rgb,
               int numPixels,
@@ -1353,6 +1491,7 @@ EncodeIndexedRect##bpp(uint8_t *buf, int count) {                       \
 DEFINE_IDX_ENCODE_FUNCTION(16)
 DEFINE_IDX_ENCODE_FUNCTION(32)
 
+
 #define DEFINE_MONO_ENCODE_FUNCTION(bpp)                                \
                                                                         \
 static void                                                             \
@@ -1409,379 +1548,110 @@ DEFINE_MONO_ENCODE_FUNCTION(32)
 
 
 /*
- * ``Gradient'' filter for 24-bit color samples.
- * Should be called only when redMax, greenMax and blueMax are 255.
- * Color components assumed to be byte-aligned.
+ * JPEG compression stuff.
  */
 
-static void
-FilterGradient24(rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, int w, int h)
+static rfbBool
+SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h, int quality)
 {
-    uint32_t *buf32;
-    uint32_t pix32;
-    int *prevRowPtr;
-    int shiftBits[3];
-    int pixHere[3], pixUpper[3], pixLeft[3], pixUpperLeft[3];
-    int prediction;
-    int x, y, c;
-
-    buf32 = (uint32_t *)buf;
-    memset (prevRowBuf, 0, w * 3 * sizeof(int));
-
-    if (!cl->screen->serverFormat.bigEndian == !fmt->bigEndian) {
-        shiftBits[0] = fmt->redShift;
-        shiftBits[1] = fmt->greenShift;
-        shiftBits[2] = fmt->blueShift;
-    } else {
-        shiftBits[0] = 24 - fmt->redShift;
-        shiftBits[1] = 24 - fmt->greenShift;
-        shiftBits[2] = 24 - fmt->blueShift;
-    }
-
-    for (y = 0; y < h; y++) {
-        for (c = 0; c < 3; c++) {
-            pixUpper[c] = 0;
-            pixHere[c] = 0;
-        }
-        prevRowPtr = prevRowBuf;
-        for (x = 0; x < w; x++) {
-            pix32 = *buf32++;
-            for (c = 0; c < 3; c++) {
-                pixUpperLeft[c] = pixUpper[c];
-                pixLeft[c] = pixHere[c];
-                pixUpper[c] = *prevRowPtr;
-                pixHere[c] = (int)(pix32 >> shiftBits[c] & 0xFF);
-                *prevRowPtr++ = pixHere[c];
-
-                prediction = pixLeft[c] + pixUpper[c] - pixUpperLeft[c];
-                if (prediction < 0) {
-                    prediction = 0;
-                } else if (prediction > 0xFF) {
-                    prediction = 0xFF;
-                }
-                *buf++ = (char)(pixHere[c] - prediction);
-            }
-        }
-    }
-}
-
-
-/*
- * ``Gradient'' filter for other color depths.
- */
-
-#define DEFINE_GRADIENT_FILTER_FUNCTION(bpp)                             \
-                                                                         \
-static void                                                              \
-FilterGradient##bpp(rfbClientPtr cl, uint##bpp##_t *buf,                 \
-		rfbPixelFormat *fmt, int w, int h) {                     \
-    uint##bpp##_t pix, diff;                                             \
-    rfbBool endianMismatch;                                              \
-    int *prevRowPtr;                                                     \
-    int maxColor[3], shiftBits[3];                                       \
-    int pixHere[3], pixUpper[3], pixLeft[3], pixUpperLeft[3];            \
-    int prediction;                                                      \
-    int x, y, c;                                                         \
-                                                                         \
-    memset (prevRowBuf, 0, w * 3 * sizeof(int));                         \
-                                                                         \
-    endianMismatch = (!cl->screen->serverFormat.bigEndian != !fmt->bigEndian);    \
-                                                                         \
-    maxColor[0] = fmt->redMax;                                           \
-    maxColor[1] = fmt->greenMax;                                         \
-    maxColor[2] = fmt->blueMax;                                          \
-    shiftBits[0] = fmt->redShift;                                        \
-    shiftBits[1] = fmt->greenShift;                                      \
-    shiftBits[2] = fmt->blueShift;                                       \
-                                                                         \
-    for (y = 0; y < h; y++) {                                            \
-        for (c = 0; c < 3; c++) {                                        \
-            pixUpper[c] = 0;                                             \
-            pixHere[c] = 0;                                              \
-        }                                                                \
-        prevRowPtr = prevRowBuf;                                         \
-        for (x = 0; x < w; x++) {                                        \
-            pix = *buf;                                                  \
-            if (endianMismatch) {                                        \
-                pix = Swap##bpp(pix);                                    \
-            }                                                            \
-            diff = 0;                                                    \
-            for (c = 0; c < 3; c++) {                                    \
-                pixUpperLeft[c] = pixUpper[c];                           \
-                pixLeft[c] = pixHere[c];                                 \
-                pixUpper[c] = *prevRowPtr;                               \
-                pixHere[c] = (int)(pix >> shiftBits[c] & maxColor[c]);   \
-                *prevRowPtr++ = pixHere[c];                              \
-                                                                         \
-                prediction = pixLeft[c] + pixUpper[c] - pixUpperLeft[c]; \
-                if (prediction < 0) {                                    \
-                    prediction = 0;                                      \
-                } else if (prediction > maxColor[c]) {                   \
-                    prediction = maxColor[c];                            \
-                }                                                        \
-                diff |= ((pixHere[c] - prediction) & maxColor[c])        \
-                    << shiftBits[c];                                     \
-            }                                                            \
-            if (endianMismatch) {                                        \
-                diff = Swap##bpp(diff);                                  \
-            }                                                            \
-            *buf++ = diff;                                               \
-        }                                                                \
-    }                                                                    \
-}
-
-DEFINE_GRADIENT_FILTER_FUNCTION(16)
-DEFINE_GRADIENT_FILTER_FUNCTION(32)
-
-
-/*
- * Code to guess if given rectangle is suitable for smooth image
- * compression (by applying "gradient" filter or JPEG coder).
- */
+    unsigned char *srcbuf;
+    int ps = cl->screen->serverFormat.bitsPerPixel / 8;
+    int subsamp = subsampLevel2tjsubsamp[subsampLevel];
+    unsigned long size = 0;
+    int flags = 0, pitch;
+    unsigned char *tmpbuf = NULL;
 
-#define JPEG_MIN_RECT_SIZE  4096
-
-#define DETECT_SUBROW_WIDTH    7
-#define DETECT_MIN_WIDTH       8
-#define DETECT_MIN_HEIGHT      8
-
-static int
-DetectSmoothImage (rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h)
-{
-    long avgError;
+    if (cl->screen->serverFormat.bitsPerPixel == 8)
+        return SendFullColorRect(cl, x, y, w, h);
 
-    if ( cl->screen->serverFormat.bitsPerPixel == 8 || fmt->bitsPerPixel == 8 ||
-         w < DETECT_MIN_WIDTH || h < DETECT_MIN_HEIGHT ) {
+    if (ps < 2) {
+        rfbLog("Error: JPEG requires 16-bit, 24-bit, or 32-bit pixel format.\n");
         return 0;
     }
-
-    if (qualityLevel != -1) {
-        if (w * h < JPEG_MIN_RECT_SIZE) {
-            return 0;
-        }
-    } else {
-        if ( rfbTightDisableGradient ||
-             w * h < tightConf[compressLevel].gradientMinRectSize ) {
+    if (!j) {
+        if ((j = tjInitCompress()) == NULL) {
+            rfbLog("JPEG Error: %s\n", tjGetErrorStr());
             return 0;
         }
     }
 
-    if (fmt->bitsPerPixel == 32) {
-        if (usePixelFormat24) {
-            avgError = DetectSmoothImage24(cl, fmt, w, h);
-            if (qualityLevel != -1) {
-                return (avgError < tightConf[qualityLevel].jpegThreshold24);
-            }
-            return (avgError < tightConf[compressLevel].gradientThreshold24);
-        } else {
-            avgError = DetectSmoothImage32(cl, fmt, w, h);
+    if (tightAfterBufSize < TJBUFSIZE(w, h)) {
+        if (tightAfterBuf == NULL)
+            tightAfterBuf = (char *)malloc(TJBUFSIZE(w, h));
+        else
+            tightAfterBuf = (char *)realloc(tightAfterBuf,
+                                            TJBUFSIZE(w, h));
+        if (!tightAfterBuf) {
+            rfbLog("Memory allocation failure!\n");
+            return 0;
         }
-    } else {
-        avgError = DetectSmoothImage16(cl, fmt, w, h);
-    }
-    if (qualityLevel != -1) {
-        return (avgError < tightConf[qualityLevel].jpegThreshold);
-    }
-    return (avgError < tightConf[compressLevel].gradientThreshold);
-}
-
-static unsigned long
-DetectSmoothImage24 (rfbClientPtr cl,
-                     rfbPixelFormat *fmt,
-                     int w,
-                     int h)
-{
-    int off;
-    int x, y, d, dx, c;
-    int diffStat[256];
-    int pixelCount = 0;
-    int pix, left[3];
-    unsigned long avgError;
-
-    /* If client is big-endian, color samples begin from the second
-       byte (offset 1) of a 32-bit pixel value. */
-    off = (fmt->bigEndian != 0);
-
-    memset(diffStat, 0, 256*sizeof(int));
-
-    y = 0, x = 0;
-    while (y < h && x < w) {
-        for (d = 0; d < h - y && d < w - x - DETECT_SUBROW_WIDTH; d++) {
-            for (c = 0; c < 3; c++) {
-                left[c] = (int)tightBeforeBuf[((y+d)*w+x+d)*4+off+c] & 0xFF;
-            }
-            for (dx = 1; dx <= DETECT_SUBROW_WIDTH; dx++) {
-                for (c = 0; c < 3; c++) {
-                    pix = (int)tightBeforeBuf[((y+d)*w+x+d+dx)*4+off+c] & 0xFF;
-                    diffStat[abs(pix - left[c])]++;
-                    left[c] = pix;
-                }
-                pixelCount++;
+        tightAfterBufSize = TJBUFSIZE(w, h);
+    }
+
+    if (ps == 2) {
+        uint16_t *srcptr, pix;
+        unsigned char *dst;
+        int inRed, inGreen, inBlue, i, j;
+
+        if((tmpbuf = (unsigned char *)malloc(w * h * 3)) == NULL)
+            rfbLog("Memory allocation failure!\n");
+        srcptr = (uint16_t *)&cl->scaledScreen->frameBuffer
+            [y * cl->scaledScreen->paddedWidthInBytes + x * ps];
+        dst = tmpbuf;
+        for(j = 0; j < h; j++) {
+            uint16_t *srcptr2 = srcptr;
+            unsigned char *dst2 = dst;
+            for (i = 0; i < w; i++) {
+                pix = *srcptr2++;
+                inRed = (int) (pix >> cl->screen->serverFormat.redShift
+                               & cl->screen->serverFormat.redMax);
+                inGreen = (int) (pix >> cl->screen->serverFormat.greenShift
+                                 & cl->screen->serverFormat.greenMax);
+                inBlue  = (int) (pix >> cl->screen->serverFormat.blueShift
+                                 & cl->screen->serverFormat.blueMax);
+                *dst2++ = (uint8_t)((inRed * 255
+                                     + cl->screen->serverFormat.redMax / 2)
+                                    / cl->screen->serverFormat.redMax);
+               	*dst2++ = (uint8_t)((inGreen * 255
+                                     + cl->screen->serverFormat.greenMax / 2)
+                                    / cl->screen->serverFormat.greenMax);
+                *dst2++ = (uint8_t)((inBlue * 255
+                                     + cl->screen->serverFormat.blueMax / 2)
+                                    / cl->screen->serverFormat.blueMax);
             }
+            srcptr += cl->scaledScreen->paddedWidthInBytes / ps;
+            dst += w * 3;
         }
-        if (w > h) {
-            x += h;
-            y = 0;
-        } else {
-            x = 0;
-            y += w;
+        srcbuf = tmpbuf;
+        pitch = w * 3;
+        ps = 3;
+    } else {
+        if (cl->screen->serverFormat.bigEndian && ps == 4)
+            flags |= TJ_ALPHAFIRST;
+        if (cl->screen->serverFormat.redShift == 16
+            && cl->screen->serverFormat.blueShift == 0)
+            flags |= TJ_BGR;
+        if (cl->screen->serverFormat.bigEndian)
+            flags ^= TJ_BGR;
+        pitch = cl->scaledScreen->paddedWidthInBytes;
+        srcbuf = (unsigned char *)&cl->scaledScreen->frameBuffer
+            [y * pitch + x * ps];
+    }
+
+    if (tjCompress(j, srcbuf, w, pitch, h, ps, (unsigned char *)tightAfterBuf,
+                   &size, subsamp, quality, flags) == -1) {
+        rfbLog("JPEG Error: %s\n", tjGetErrorStr());
+        if (tmpbuf) {
+            free(tmpbuf);
+            tmpbuf = NULL;
         }
-    }
-
-    if (diffStat[0] * 33 / pixelCount >= 95)
         return 0;
-
-    avgError = 0;
-    for (c = 1; c < 8; c++) {
-        avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c);
-        if (diffStat[c] == 0 || diffStat[c] > diffStat[c-1] * 2)
-            return 0;
     }
-    for (; c < 256; c++) {
-        avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c);
-    }
-    avgError /= (pixelCount * 3 - diffStat[0]);
-
-    return avgError;
-}
-
-#define DEFINE_DETECT_FUNCTION(bpp)                                          \
-                                                                             \
-static unsigned long                                                         \
-DetectSmoothImage##bpp (rfbClientPtr cl, rfbPixelFormat *fmt, int w, int h) {\
-    rfbBool endianMismatch;                                                  \
-    uint##bpp##_t pix;                                                       \
-    int maxColor[3], shiftBits[3];                                           \
-    int x, y, d, dx, c;                                                      \
-    int diffStat[256];                                                       \
-    int pixelCount = 0;                                                      \
-    int sample, sum, left[3];                                                \
-    unsigned long avgError;                                                  \
-                                                                             \
-    endianMismatch = (!cl->screen->serverFormat.bigEndian != !fmt->bigEndian); \
-                                                                             \
-    maxColor[0] = fmt->redMax;                                               \
-    maxColor[1] = fmt->greenMax;                                             \
-    maxColor[2] = fmt->blueMax;                                              \
-    shiftBits[0] = fmt->redShift;                                            \
-    shiftBits[1] = fmt->greenShift;                                          \
-    shiftBits[2] = fmt->blueShift;                                           \
-                                                                             \
-    memset(diffStat, 0, 256*sizeof(int));                                    \
-                                                                             \
-    y = 0, x = 0;                                                            \
-    while (y < h && x < w) {                                                 \
-        for (d = 0; d < h - y && d < w - x - DETECT_SUBROW_WIDTH; d++) {     \
-            pix = ((uint##bpp##_t *)tightBeforeBuf)[(y+d)*w+x+d];            \
-            if (endianMismatch) {                                            \
-                pix = Swap##bpp(pix);                                        \
-            }                                                                \
-            for (c = 0; c < 3; c++) {                                        \
-                left[c] = (int)(pix >> shiftBits[c] & maxColor[c]);          \
-            }                                                                \
-            for (dx = 1; dx <= DETECT_SUBROW_WIDTH; dx++) {                  \
-                pix = ((uint##bpp##_t *)tightBeforeBuf)[(y+d)*w+x+d+dx];     \
-                if (endianMismatch) {                                        \
-                    pix = Swap##bpp(pix);                                    \
-                }                                                            \
-                sum = 0;                                                     \
-                for (c = 0; c < 3; c++) {                                    \
-                    sample = (int)(pix >> shiftBits[c] & maxColor[c]);       \
-                    sum += abs(sample - left[c]);                            \
-                    left[c] = sample;                                        \
-                }                                                            \
-                if (sum > 255)                                               \
-                    sum = 255;                                               \
-                diffStat[sum]++;                                             \
-                pixelCount++;                                                \
-            }                                                                \
-        }                                                                    \
-        if (w > h) {                                                         \
-            x += h;                                                          \
-            y = 0;                                                           \
-        } else {                                                             \
-            x = 0;                                                           \
-            y += w;                                                          \
-        }                                                                    \
-    }                                                                        \
-                                                                             \
-    if ((diffStat[0] + diffStat[1]) * 100 / pixelCount >= 90)                \
-        return 0;                                                            \
-                                                                             \
-    avgError = 0;                                                            \
-    for (c = 1; c < 8; c++) {                                                \
-        avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c);     \
-        if (diffStat[c] == 0 || diffStat[c] > diffStat[c-1] * 2)             \
-            return 0;                                                        \
-    }                                                                        \
-    for (; c < 256; c++) {                                                   \
-        avgError += (unsigned long)diffStat[c] * (unsigned long)(c * c);     \
-    }                                                                        \
-    avgError /= (pixelCount - diffStat[0]);                                  \
-                                                                             \
-    return avgError;                                                         \
-}
-
-DEFINE_DETECT_FUNCTION(16)
-DEFINE_DETECT_FUNCTION(32)
-
-
-/*
- * JPEG compression stuff.
- */
 
-static TLS struct jpeg_destination_mgr jpegDstManager;
-static TLS rfbBool jpegError = FALSE;
-static TLS int jpegDstDataLen = 0;
-
-static rfbBool
-SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h, int quality)
-{
-    struct jpeg_compress_struct cinfo;
-    struct jpeg_error_mgr jerr;
-    uint8_t *srcBuf;
-    JSAMPROW rowPointer[1];
-    int dy;
-
-    if (cl->screen->serverFormat.bitsPerPixel == 8)
-        return SendFullColorRect(cl, x, y, w, h);
-
-    srcBuf = (uint8_t *)malloc(w * 3);
-    if (srcBuf == NULL) {
-        return SendFullColorRect(cl, x, y, w, h);
+    if (tmpbuf) {
+        free(tmpbuf);
+        tmpbuf = NULL;
     }
-    rowPointer[0] = srcBuf;
-
-    cinfo.err = jpeg_std_error(&jerr);
-    jpeg_create_compress(&cinfo);
-
-    cinfo.image_width = w;
-    cinfo.image_height = h;
-    cinfo.input_components = 3;
-    cinfo.in_color_space = JCS_RGB;
-
-    jpeg_set_defaults(&cinfo);
-    jpeg_set_quality(&cinfo, quality, TRUE);
-
-    JpegSetDstManager (&cinfo);
-
-    jpeg_start_compress(&cinfo, TRUE);
-
-    for (dy = 0; dy < h; dy++) {
-        PrepareRowForImg(cl, srcBuf, x, y + dy, w);
-        jpeg_write_scanlines(&cinfo, rowPointer, 1);
-        if (jpegError)
-            break;
-    }
-
-    if (!jpegError)
-        jpeg_finish_compress(&cinfo);
-
-    jpeg_destroy_compress(&cinfo);
-    free(srcBuf);
-
-    if (jpegError)
-        return SendFullColorRect(cl, x, y, w, h);
 
     if (cl->ublen + TIGHT_MIN_TO_COMPRESS + 1 > UPDATE_BUF_SIZE) {
         if (!rfbSendUpdateBuf(cl))
@@ -1791,7 +1661,7 @@ SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h, int quality)
     cl->updateBuf[cl->ublen++] = (char)(rfbTightJpeg << 4);
     rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 1);
 
-    return SendCompressedData(cl, jpegDstDataLen);
+    return SendCompressedData(cl, tightAfterBuf, (int)size);
 }
 
 static void
@@ -1871,43 +1741,6 @@ DEFINE_JPEG_GET_ROW_FUNCTION(16)
 DEFINE_JPEG_GET_ROW_FUNCTION(32)
 
 /*
- * Destination manager implementation for JPEG library.
- */
-
-static void
-JpegInitDestination(j_compress_ptr cinfo)
-{
-    jpegError = FALSE;
-    jpegDstManager.next_output_byte = (JOCTET *)tightAfterBuf;
-    jpegDstManager.free_in_buffer = (size_t)tightAfterBufSize;
-}
-
-static boolean
-JpegEmptyOutputBuffer(j_compress_ptr cinfo)
-{
-    jpegError = TRUE;
-    jpegDstManager.next_output_byte = (JOCTET *)tightAfterBuf;
-    jpegDstManager.free_in_buffer = (size_t)tightAfterBufSize;
-
-    return TRUE;
-}
-
-static void
-JpegTermDestination(j_compress_ptr cinfo)
-{
-    jpegDstDataLen = tightAfterBufSize - jpegDstManager.free_in_buffer;
-}
-
-static void
-JpegSetDstManager(j_compress_ptr cinfo)
-{
-    jpegDstManager.init_destination = JpegInitDestination;
-    jpegDstManager.empty_output_buffer = JpegEmptyOutputBuffer;
-    jpegDstManager.term_destination = JpegTermDestination;
-    cinfo->dest = &jpegDstManager;
-}
-
-/*
  * PNG compression stuff.
  */
 
@@ -2062,6 +1895,6 @@ static rfbBool SendPngRect(rfbClientPtr cl, int x, int y, int w, int h) {
     rfbStatRecordEncodingSentAdd(cl, cl->tightEncoding, 1);
 
     /* rfbLog("<< SendPngRect\n"); */
-    return SendCompressedData(cl, pngDstDataLen);
+    return SendCompressedData(cl, tightAfterBuf, pngDstDataLen);
 }
 #endif
diff --git a/rfb/rfb.h b/rfb/rfb.h
index bf4e011..a265746 100644
--- a/rfb/rfb.h
+++ b/rfb/rfb.h
@@ -681,6 +681,11 @@ typedef struct _rfbClientRec {
   int afterEncBufLen;
 #if defined(LIBVNCSERVER_HAVE_LIBZ) || defined(LIBVNCSERVER_HAVE_LIBPNG)
     uint32_t tightEncoding;  /* rfbEncodingTight or rfbEncodingTightPng */
+#ifdef LIBVNCSERVER_HAVE_LIBJPEG
+    /* TurboVNC Encoding support (extends TightVNC) */
+    int turboSubsampLevel;
+    int turboQualityLevel;  // 1-100 scale
+#endif
 #endif
 
 #ifdef LIBVNCSERVER_WITH_WEBSOCKETS
@@ -880,6 +885,10 @@ extern rfbBool rfbSendRectEncodingZlib(rfbClientPtr cl, int x, int y, int w,
 
 #define TIGHT_DEFAULT_COMPRESSION  6
 
+#ifdef LIBVNCSERVER_HAVE_LIBJPEG
+#define TURBO_DEFAULT_SUBSAMP 0
+#endif
+
 extern rfbBool rfbTightDisableGradient;
 
 extern int rfbNumCodedRectsTight(rfbClientPtr cl, int x,int y,int w,int h);
diff --git a/rfb/rfbproto.h b/rfb/rfbproto.h
index c6dfd2c..acb2e7b 100644
--- a/rfb/rfbproto.h
+++ b/rfb/rfbproto.h
@@ -13,7 +13,9 @@
 */
 
 /*
+ *  Copyright (C) 2009-2010 D. R. Commander. All Rights Reserved.
  *  Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
+ *  Copyright (C) 2004-2008 Sun Microsystems, Inc. All Rights Reserved.
  *  Copyright (C) 2000-2002 Constantin Kaplinsky.  All Rights Reserved.
  *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
  *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
@@ -457,6 +459,8 @@ typedef struct {
 
 /*
  * Special encoding numbers:
+ *   0xFFFFFD00 .. 0xFFFFFD05 -- subsampling level
+ *   0xFFFFFE00 .. 0xFFFFFE64 -- fine-grained quality level (0-100 scale)
  *   0xFFFFFF00 .. 0xFFFFFF0F -- encoding-specific compression levels;
  *   0xFFFFFF10 .. 0xFFFFFF1F -- mouse cursor shape data;
  *   0xFFFFFF20 .. 0xFFFFFF2F -- various protocol extensions;
@@ -465,6 +469,15 @@ typedef struct {
  *   0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels.
  */
 
+#define rfbEncodingFineQualityLevel0   0xFFFFFE00
+#define rfbEncodingFineQualityLevel100 0xFFFFFE64
+#define rfbEncodingSubsamp1X           0xFFFFFD00
+#define rfbEncodingSubsamp4X           0xFFFFFD01
+#define rfbEncodingSubsamp2X           0xFFFFFD02
+#define rfbEncodingSubsampGray         0xFFFFFD03
+#define rfbEncodingSubsamp8X           0xFFFFFD04
+#define rfbEncodingSubsamp16X          0xFFFFFD05
+
 #define rfbEncodingCompressLevel0  0xFFFFFF00
 #define rfbEncodingCompressLevel1  0xFFFFFF01
 #define rfbEncodingCompressLevel2  0xFFFFFF02
@@ -719,12 +732,20 @@ typedef struct {
  *   bit 3:    if 1, then compression stream 3 should be reset;
  *   bits 7-4: if 1000 (0x08), then the compression type is "fill",
  *             if 1001 (0x09), then the compression type is "jpeg",
- *             if 1001 (0x0A), then the compression type is "png",
- *             if 0xxx, then the compression type is "basic",
+ *             (Tight only) if 1010 (0x0A), then the compression type is
+ *               "basic" and no Zlib compression was used,
+ *             (Tight only) if 1110 (0x0E), then the compression type is
+ *               "basic", no Zlib compression was used, and a "filter id" byte
+ *               follows this byte,
+ *             (TightPng only) if 1010 (0x0A), then the compression type is
+ *               "png",
+ *             if 0xxx, then the compression type is "basic" and Zlib
+ *               compression was used,
  *             values greater than 1010 are not valid.
  *
- * If the compression type is "basic", then bits 6..4 of the
- * compression control byte (those xxx in 0xxx) specify the following:
+ * If the compression type is "basic" and Zlib compression was used, then bits
+ * 6..4 of the compression control byte (those xxx in 0xxx) specify the
+ * following:
  *
  *   bits 5-4:  decimal representation is the index of a particular zlib
  *              stream which should be used for decompressing the data;
@@ -836,6 +857,7 @@ typedef struct {
 #define rfbTightExplicitFilter         0x04
 #define rfbTightFill                   0x08
 #define rfbTightJpeg                   0x09
+#define rfbTightNoZlib                 0x0A
 #define rfbTightPng                    0x0A
 #define rfbTightMaxSubencoding         0x0A
 
diff --git a/test/Makefile.am b/test/Makefile.am
index 30498c2..ff6e8f2 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,4 +1,15 @@
-INCLUDES = -I$(top_srcdir)
+# TurboJPEG wrapper tests
+
+noinst_PROGRAMS=tjunittest tjbench
+
+tjunittest_SOURCES=tjunittest.c ../common/turbojpeg.c ../common/turbojpeg.h \
+	tjutil.c tjutil.h
+
+tjbench_SOURCES=tjbench.c ../common/turbojpeg.c ../common/turbojpeg.h \
+	tjutil.c tjutil.h bmp.c bmp.h
+tjbench_LDADD=$(LDADD) -lm
+
+INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/common
 LDADD = ../libvncserver/libvncserver.la ../libvncclient/libvncclient.la @WSOCKLIB@
 
 if HAVE_LIBPTHREAD
diff --git a/test/bmp.c b/test/bmp.c
new file mode 100644
index 0000000..7dcbf13
--- /dev/null
+++ b/test/bmp.c
@@ -0,0 +1,389 @@
+/* Copyright (C)2004 Landmark Graphics Corporation
+ * Copyright (C)2005 Sun Microsystems, Inc.
+ * Copyright (C)2010, 2012 D. R. Commander
+ *
+ * This library is free software and may be redistributed and/or modified under
+ * the terms of the wxWindows Library License, Version 3.1 or (at your option)
+ * any later version.  The full license is in the LICENSE.txt file included
+ * with this distribution.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * wxWindows Library License for more details.
+*/
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef _WIN32
+ #include <io.h>
+#else
+ #include <unistd.h>
+#endif
+#include "./tjutil.h"
+#include "./bmp.h"
+
+#define byteswap(i) ( \
+	(((i) & 0xff000000) >> 24) | \
+	(((i) & 0x00ff0000) >>  8) | \
+	(((i) & 0x0000ff00) <<  8) | \
+	(((i) & 0x000000ff) << 24) )
+
+#define byteswap16(i) ( \
+	(((i) & 0xff00) >> 8) | \
+	(((i) & 0x00ff) << 8) )
+
+static __inline int littleendian(void)
+{
+	unsigned int value=1;
+	unsigned char *ptr=(unsigned char *)(&value);
+	if(ptr[0]==1 && ptr[3]==0) return 1;
+	else return 0;
+}
+
+#ifndef BI_BITFIELDS
+#define BI_BITFIELDS 3L
+#endif
+#ifndef BI_RGB
+#define BI_RGB 0L
+#endif
+
+#define BMPHDRSIZE 54
+typedef struct _bmphdr
+{
+	unsigned short bfType;
+	unsigned int bfSize;
+	unsigned short bfReserved1, bfReserved2;
+	unsigned int bfOffBits;
+
+	unsigned int biSize;
+	int biWidth, biHeight;
+	unsigned short biPlanes, biBitCount;
+	unsigned int biCompression, biSizeImage;
+	int biXPelsPerMeter, biYPelsPerMeter;
+	unsigned int biClrUsed, biClrImportant;
+} bmphdr;
+
+static const char *__bmperr="No error";
+
+static const int ps[BMPPIXELFORMATS]={3, 4, 3, 4, 4, 4};
+static const int roffset[BMPPIXELFORMATS]={0, 0, 2, 2, 3, 1};
+static const int goffset[BMPPIXELFORMATS]={1, 1, 1, 1, 2, 2};
+static const int boffset[BMPPIXELFORMATS]={2, 2, 0, 0, 1, 3};
+
+#define _throw(m) {__bmperr=m;  retcode=-1;  goto finally;}
+#define _unix(f) {if((f)==-1) _throw(strerror(errno));}
+#define _catch(f) {if((f)==-1) {retcode=-1;  goto finally;}}
+
+#define readme(fd, addr, size) \
+	if((bytesread=read(fd, addr, (size)))==-1) _throw(strerror(errno)); \
+	if(bytesread!=(size)) _throw("Read error");
+
+void pixelconvert(unsigned char *srcbuf, enum BMPPIXELFORMAT srcformat,
+	int srcpitch, unsigned char *dstbuf, enum BMPPIXELFORMAT dstformat, int dstpitch,
+	int w, int h, int flip)
+{
+	unsigned char *srcptr, *srcptr0, *dstptr, *dstptr0;
+	int i, j;
+
+	srcptr=flip? &srcbuf[srcpitch*(h-1)]:srcbuf;
+	for(j=0, dstptr=dstbuf; j<h; j++,
+		srcptr+=flip? -srcpitch:srcpitch, dstptr+=dstpitch)
+	{
+		for(i=0, srcptr0=srcptr, dstptr0=dstptr; i<w; i++,
+			srcptr0+=ps[srcformat], dstptr0+=ps[dstformat])
+		{
+			dstptr0[roffset[dstformat]]=srcptr0[roffset[srcformat]];
+			dstptr0[goffset[dstformat]]=srcptr0[goffset[srcformat]];
+			dstptr0[boffset[dstformat]]=srcptr0[boffset[srcformat]];
+		}
+	}
+}
+
+int loadppm(int *fd, unsigned char **buf, int *w, int *h,
+	enum BMPPIXELFORMAT f, int align, int dstbottomup, int ascii)
+{
+	FILE *fs=NULL;  int retcode=0, scalefactor, dstpitch;
+	unsigned char *tempbuf=NULL;  char temps[255], temps2[255];
+	int numread=0, totalread=0, pixel[3], i, j;
+
+	if((fs=fdopen(*fd, "r"))==NULL) _throw(strerror(errno));
+
+	do
+	{
+		if(!fgets(temps, 255, fs)) _throw("Read error");
+		if(strlen(temps)==0 || temps[0]=='\n') continue;
+		if(sscanf(temps, "%s", temps2)==1 && temps2[1]=='#') continue;
+		switch(totalread)
+		{
+			case 0:
+				if((numread=sscanf(temps, "%d %d %d", w, h, &scalefactor))==EOF)
+					_throw("Read error");
+				break;
+			case 1:
+				if((numread=sscanf(temps, "%d %d", h, &scalefactor))==EOF)
+					_throw("Read error");
+				break;
+			case 2:
+				if((numread=sscanf(temps, "%d", &scalefactor))==EOF)
+					_throw("Read error");
+				break;
+		}
+		totalread+=numread;
+	} while(totalread<3);
+	if((*w)<1 || (*h)<1 || scalefactor<1) _throw("Corrupt PPM header");
+
+	dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));
+	if((*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)
+		_throw("Memory allocation error");
+	if(ascii)
+	{
+		for(j=0; j<*h; j++)
+		{
+			for(i=0; i<*w; i++)
+			{
+				if(fscanf(fs, "%d%d%d", &pixel[0], &pixel[1], &pixel[2])!=3)
+					_throw("Read error");
+				(*buf)[j*dstpitch+i*ps[f]+roffset[f]]=(unsigned char)(pixel[0]*255/scalefactor);
+				(*buf)[j*dstpitch+i*ps[f]+goffset[f]]=(unsigned char)(pixel[1]*255/scalefactor);
+				(*buf)[j*dstpitch+i*ps[f]+boffset[f]]=(unsigned char)(pixel[2]*255/scalefactor);
+			}
+		}
+	}
+	else
+	{
+		if(scalefactor!=255)
+			_throw("Binary PPMs must have 8-bit components");
+		if((tempbuf=(unsigned char *)malloc((*w)*(*h)*3))==NULL)
+			_throw("Memory allocation error");
+		if(fread(tempbuf, (*w)*(*h)*3, 1, fs)!=1) _throw("Read error");
+		pixelconvert(tempbuf, BMP_RGB, (*w)*3, *buf, f, dstpitch, *w, *h, dstbottomup);
+	}
+
+	finally:
+	if(fs) {fclose(fs);  *fd=-1;}
+	if(tempbuf) free(tempbuf);
+	return retcode;
+}
+
+
+int loadbmp(char *filename, unsigned char **buf, int *w, int *h, 
+	enum BMPPIXELFORMAT f, int align, int dstbottomup)
+{
+	int fd=-1, bytesread, srcpitch, srcbottomup=1, srcps, dstpitch,
+		retcode=0;
+	unsigned char *tempbuf=NULL;
+	bmphdr bh;  int flags=O_RDONLY;
+
+	dstbottomup=dstbottomup? 1:0;
+	#ifdef _WIN32
+	flags|=O_BINARY;
+	#endif
+	if(!filename || !buf || !w || !h || f<0 || f>BMPPIXELFORMATS-1 || align<1)
+		_throw("invalid argument to loadbmp()");
+	if((align&(align-1))!=0)
+		_throw("Alignment must be a power of 2");
+	_unix(fd=open(filename, flags));
+
+	readme(fd, &bh.bfType, sizeof(unsigned short));
+	if(!littleendian())	bh.bfType=byteswap16(bh.bfType);
+
+	if(bh.bfType==0x3650)
+	{
+		_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 0));
+		goto finally;
+	}
+	if(bh.bfType==0x3350)
+	{
+		_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 1));
+		goto finally;
+	}
+
+	readme(fd, &bh.bfSize, sizeof(unsigned int));
+	readme(fd, &bh.bfReserved1, sizeof(unsigned short));
+	readme(fd, &bh.bfReserved2, sizeof(unsigned short));
+	readme(fd, &bh.bfOffBits, sizeof(unsigned int));
+	readme(fd, &bh.biSize, sizeof(unsigned int));
+	readme(fd, &bh.biWidth, sizeof(int));
+	readme(fd, &bh.biHeight, sizeof(int));
+	readme(fd, &bh.biPlanes, sizeof(unsigned short));
+	readme(fd, &bh.biBitCount, sizeof(unsigned short));
+	readme(fd, &bh.biCompression, sizeof(unsigned int));
+	readme(fd, &bh.biSizeImage, sizeof(unsigned int));
+	readme(fd, &bh.biXPelsPerMeter, sizeof(int));
+	readme(fd, &bh.biYPelsPerMeter, sizeof(int));
+	readme(fd, &bh.biClrUsed, sizeof(unsigned int));
+	readme(fd, &bh.biClrImportant, sizeof(unsigned int));
+
+	if(!littleendian())
+	{
+		bh.bfSize=byteswap(bh.bfSize);
+		bh.bfOffBits=byteswap(bh.bfOffBits);
+		bh.biSize=byteswap(bh.biSize);
+		bh.biWidth=byteswap(bh.biWidth);
+		bh.biHeight=byteswap(bh.biHeight);
+		bh.biPlanes=byteswap16(bh.biPlanes);
+		bh.biBitCount=byteswap16(bh.biBitCount);
+		bh.biCompression=byteswap(bh.biCompression);
+		bh.biSizeImage=byteswap(bh.biSizeImage);
+		bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
+		bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
+		bh.biClrUsed=byteswap(bh.biClrUsed);
+		bh.biClrImportant=byteswap(bh.biClrImportant);
+	}
+
+	if(bh.bfType!=0x4d42 || bh.bfOffBits<BMPHDRSIZE
+	|| bh.biWidth<1 || bh.biHeight==0)
+		_throw("Corrupt bitmap header");
+	if((bh.biBitCount!=24 && bh.biBitCount!=32) || bh.biCompression!=BI_RGB)
+		_throw("Only uncompessed RGB bitmaps are supported");
+
+	*w=bh.biWidth;  *h=bh.biHeight;  srcps=bh.biBitCount/8;
+	if(*h<0) {*h=-(*h);  srcbottomup=0;}
+	srcpitch=(((*w)*srcps)+3)&(~3);
+	dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));
+
+	if(srcpitch*(*h)+bh.bfOffBits!=bh.bfSize) _throw("Corrupt bitmap header");
+	if((tempbuf=(unsigned char *)malloc(srcpitch*(*h)))==NULL
+	|| (*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)
+		_throw("Memory allocation error");
+	if(lseek(fd, (long)bh.bfOffBits, SEEK_SET)!=(long)bh.bfOffBits)
+		_throw(strerror(errno));
+	_unix(bytesread=read(fd, tempbuf, srcpitch*(*h)));
+	if(bytesread!=srcpitch*(*h)) _throw("Read error");
+
+	pixelconvert(tempbuf, BMP_BGR, srcpitch, *buf, f, dstpitch, *w, *h, 
+		srcbottomup!=dstbottomup);
+
+	finally:
+	if(tempbuf) free(tempbuf);
+	if(fd!=-1) close(fd);
+	return retcode;
+}
+
+#define writeme(fd, addr, size) \
+	if((byteswritten=write(fd, addr, (size)))==-1) _throw(strerror(errno)); \
+	if(byteswritten!=(size)) _throw("Write error");
+
+int saveppm(char *filename, unsigned char *buf, int w, int h,
+	enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)
+{
+	FILE *fs=NULL;  int retcode=0;
+	unsigned char *tempbuf=NULL;
+
+	if((fs=fopen(filename, "wb"))==NULL) _throw(strerror(errno));
+	if(fprintf(fs, "P6\n")<1) _throw("Write error");
+	if(fprintf(fs, "%d %d\n", w, h)<1) _throw("Write error");
+	if(fprintf(fs, "255\n")<1) _throw("Write error");
+
+	if((tempbuf=(unsigned char *)malloc(w*h*3))==NULL)
+		_throw("Memory allocation error");
+
+	pixelconvert(buf, f, srcpitch, tempbuf, BMP_RGB, w*3, w, h, 
+		srcbottomup);
+
+	if((fwrite(tempbuf, w*h*3, 1, fs))!=1) _throw("Write error");
+
+	finally:
+	if(tempbuf) free(tempbuf);
+	if(fs) fclose(fs);
+	return retcode;
+}
+
+int savebmp(char *filename, unsigned char *buf, int w, int h,
+	enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)
+{
+	int fd=-1, byteswritten, dstpitch, retcode=0;
+	int flags=O_RDWR|O_CREAT|O_TRUNC;
+	unsigned char *tempbuf=NULL;  char *temp;
+	bmphdr bh;  int mode;
+
+	#ifdef _WIN32
+	flags|=O_BINARY;  mode=_S_IREAD|_S_IWRITE;
+	#else
+	mode=S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
+	#endif
+	if(!filename || !buf || w<1 || h<1 || f<0 || f>BMPPIXELFORMATS-1 || srcpitch<0)
+		_throw("bad argument to savebmp()");
+
+	if(srcpitch==0) srcpitch=w*ps[f];
+
+	if((temp=strrchr(filename, '.'))!=NULL)
+	{
+		if(!strcasecmp(temp, ".ppm"))
+			return saveppm(filename, buf, w, h, f, srcpitch, srcbottomup);
+	}
+
+	_unix(fd=open(filename, flags, mode));
+	dstpitch=((w*3)+3)&(~3);
+
+	bh.bfType=0x4d42;
+	bh.bfSize=BMPHDRSIZE+dstpitch*h;
+	bh.bfReserved1=0;  bh.bfReserved2=0;
+	bh.bfOffBits=BMPHDRSIZE;
+	bh.biSize=40;
+	bh.biWidth=w;  bh.biHeight=h;
+	bh.biPlanes=0;  bh.biBitCount=24;
+	bh.biCompression=BI_RGB;  bh.biSizeImage=0;
+	bh.biXPelsPerMeter=0;  bh.biYPelsPerMeter=0;
+	bh.biClrUsed=0;  bh.biClrImportant=0;
+
+	if(!littleendian())
+	{
+		bh.bfType=byteswap16(bh.bfType);
+		bh.bfSize=byteswap(bh.bfSize);
+		bh.bfOffBits=byteswap(bh.bfOffBits);
+		bh.biSize=byteswap(bh.biSize);
+		bh.biWidth=byteswap(bh.biWidth);
+		bh.biHeight=byteswap(bh.biHeight);
+		bh.biPlanes=byteswap16(bh.biPlanes);
+		bh.biBitCount=byteswap16(bh.biBitCount);
+		bh.biCompression=byteswap(bh.biCompression);
+		bh.biSizeImage=byteswap(bh.biSizeImage);
+		bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
+		bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
+		bh.biClrUsed=byteswap(bh.biClrUsed);
+		bh.biClrImportant=byteswap(bh.biClrImportant);
+	}
+
+	writeme(fd, &bh.bfType, sizeof(unsigned short));
+	writeme(fd, &bh.bfSize, sizeof(unsigned int));
+	writeme(fd, &bh.bfReserved1, sizeof(unsigned short));
+	writeme(fd, &bh.bfReserved2, sizeof(unsigned short));
+	writeme(fd, &bh.bfOffBits, sizeof(unsigned int));
+	writeme(fd, &bh.biSize, sizeof(unsigned int));
+	writeme(fd, &bh.biWidth, sizeof(int));
+	writeme(fd, &bh.biHeight, sizeof(int));
+	writeme(fd, &bh.biPlanes, sizeof(unsigned short));
+	writeme(fd, &bh.biBitCount, sizeof(unsigned short));
+	writeme(fd, &bh.biCompression, sizeof(unsigned int));
+	writeme(fd, &bh.biSizeImage, sizeof(unsigned int));
+	writeme(fd, &bh.biXPelsPerMeter, sizeof(int));
+	writeme(fd, &bh.biYPelsPerMeter, sizeof(int));
+	writeme(fd, &bh.biClrUsed, sizeof(unsigned int));
+	writeme(fd, &bh.biClrImportant, sizeof(unsigned int));
+
+	if((tempbuf=(unsigned char *)malloc(dstpitch*h))==NULL)
+		_throw("Memory allocation error");
+
+	pixelconvert(buf, f, srcpitch, tempbuf, BMP_BGR, dstpitch, w, h, 
+		!srcbottomup);
+
+	if((byteswritten=write(fd, tempbuf, dstpitch*h))!=dstpitch*h)
+		_throw(strerror(errno));
+
+	finally:
+	if(tempbuf) free(tempbuf);
+	if(fd!=-1) close(fd);
+	return retcode;
+}
+
+const char *bmpgeterr(void)
+{
+	return __bmperr;
+}
diff --git a/test/bmp.h b/test/bmp.h
new file mode 100644
index 0000000..055b1ee
--- /dev/null
+++ b/test/bmp.h
@@ -0,0 +1,49 @@
+/* Copyright (C)2004 Landmark Graphics Corporation
+ * Copyright (C)2005 Sun Microsystems, Inc.
+ * Copyright (C)2011 D. R. Commander
+ *
+ * This library is free software and may be redistributed and/or modified under
+ * the terms of the wxWindows Library License, Version 3.1 or (at your option)
+ * any later version.  The full license is in the LICENSE.txt file included
+ * with this distribution.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * wxWindows Library License for more details.
+*/
+
+// This provides rudimentary facilities for loading and saving true color
+// BMP and PPM files
+
+#ifndef __BMP_H__
+#define __BMP_H__
+
+#define BMPPIXELFORMATS 6
+enum BMPPIXELFORMAT {BMP_RGB=0, BMP_RGBX, BMP_BGR, BMP_BGRX, BMP_XBGR, BMP_XRGB};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This will load a Windows bitmap from a file and return a buffer with the
+// specified pixel format, scanline alignment, and orientation.  The width and
+// height are returned in w and h.
+
+int loadbmp(char *filename, unsigned char **buf, int *w, int *h,
+	enum BMPPIXELFORMAT f, int align, int dstbottomup);
+
+// This will save a buffer with the specified pixel format, pitch, orientation,
+// width, and height as a 24-bit Windows bitmap or PPM (the filename determines
+// which format to use)
+
+int savebmp(char *filename, unsigned char *buf, int w, int h,
+	enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup);
+
+const char *bmpgeterr(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/test/tjbench.c b/test/tjbench.c
new file mode 100644
index 0000000..b1f343f
--- /dev/null
+++ b/test/tjbench.c
@@ -0,0 +1,658 @@
+/*
+ * 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
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <errno.h>
+#include "./bmp.h"
+#include "./tjutil.h"
+#include "./turbojpeg.h"
+
+
+#define _throw(op, err) {  \
+	printf("ERROR in line %d while %s:\n%s\n", __LINE__, op, err);  \
+  retval=-1;  goto bailout;}
+#define _throwunix(m) _throw(m, strerror(errno))
+#define _throwtj(m) _throw(m, tjGetErrorStr())
+#define _throwbmp(m) _throw(m, bmpgeterr())
+
+int flags=0, decomponly=0, quiet=0, dotile=0, pf=TJPF_BGR;
+char *ext="ppm";
+const char *pixFormatStr[TJ_NUMPF]=
+{
+	"RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "GRAY"
+};
+const int bmpPF[TJ_NUMPF]=
+{
+	BMP_RGB, BMP_BGR, BMP_RGBX, BMP_BGRX, BMP_XBGR, BMP_XRGB, -1
+};
+const char *subNameLong[TJ_NUMSAMP]=
+{
+	"4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0"
+};
+const char *subName[NUMSUBOPT]={"444", "422", "420", "GRAY", "440"};
+tjscalingfactor *scalingfactors=NULL, sf={1, 1};  int nsf=0;
+double benchtime=5.0;
+
+
+char *sigfig(double val, int figs, char *buf, int len)
+{
+	char format[80];
+	int digitsafterdecimal=figs-(int)ceil(log10(fabs(val)));
+	if(digitsafterdecimal<1) snprintf(format, 80, "%%.0f");
+	else snprintf(format, 80, "%%.%df", digitsafterdecimal);
+	snprintf(buf, len, format, val);
+	return buf;
+}
+
+
+/* Decompression test */
+int decomptest(unsigned char *srcbuf, unsigned char **jpegbuf,
+	unsigned long *jpegsize, unsigned char *dstbuf, int w, int h,
+	int subsamp, int jpegqual, char *filename, int tilew, int tileh)
+{
+	char tempstr[1024], sizestr[20]="\0", qualstr[6]="\0", *ptr;
+	FILE *file=NULL;  tjhandle handle=NULL;
+	int row, col, i, dstbufalloc=0, retval=0;
+	double start, elapsed;
+	int ps=tjPixelSize[pf];
+	int bufsize;
+	int scaledw=TJSCALED(w, sf);
+	int scaledh=TJSCALED(h, sf);
+	int pitch=scaledw*ps;
+	int ntilesw=(w+tilew-1)/tilew, ntilesh=(h+tileh-1)/tileh;
+	unsigned char *dstptr, *dstptr2;
+
+	if(jpegqual>0)
+	{
+		snprintf(qualstr, 6, "_Q%d", jpegqual);
+		qualstr[5]=0;
+	}
+
+	if((handle=tjInitDecompress())==NULL)
+		_throwtj("executing tjInitDecompress()");
+
+	bufsize=pitch*scaledh;
+	if(dstbuf==NULL)
+	{
+		if((dstbuf=(unsigned char *)malloc(bufsize)) == NULL)
+			_throwunix("allocating image buffer");
+		dstbufalloc=1;
+	}
+	/* Set the destination buffer to gray so we know whether the decompressor
+	   attempted to write to it */
+	memset(dstbuf, 127, bufsize);
+
+	/* Execute once to preload cache */
+	if(tjDecompress2(handle, jpegbuf[0], jpegsize[0], dstbuf, scaledw,
+		pitch, scaledh, pf, flags)==-1)
+		_throwtj("executing tjDecompress2()");
+
+	/* Benchmark */
+	for(i=0, start=gettime(); (elapsed=gettime()-start)<benchtime; i++)
+	{
+		int tile=0;
+		for(row=0, dstptr=dstbuf; row<ntilesh; row++, dstptr+=pitch*tileh)
+		{
+			for(col=0, dstptr2=dstptr; col<ntilesw; col++, tile++, dstptr2+=ps*tilew)
+			{
+				int width=dotile? min(tilew, w-col*tilew):scaledw;
+				int height=dotile? min(tileh, h-row*tileh):scaledh;
+				if(tjDecompress2(handle, jpegbuf[tile], jpegsize[tile], dstptr2, width,
+					pitch, height, pf, flags)==-1)
+					_throwtj("executing tjDecompress2()");
+			}
+		}
+	}
+
+	if(tjDestroy(handle)==-1) _throwtj("executing tjDestroy()");
+	handle=NULL;
+
+	if(quiet)
+	{
+		printf("%s\n",
+			sigfig((double)(w*h)/1000000.*(double)i/elapsed, 4, tempstr, 1024));
+	}
+	else
+	{
+		printf("D--> Frame rate:           %f fps\n", (double)i/elapsed);
+		printf("     Dest. throughput:     %f Megapixels/sec\n",
+			(double)(w*h)/1000000.*(double)i/elapsed);
+	}
+	if(sf.num!=1 || sf.denom!=1)
+		snprintf(sizestr, 20, "%d_%d", sf.num, sf.denom);
+	else if(tilew!=w || tileh!=h)
+		snprintf(sizestr, 20, "%dx%d", tilew, tileh);
+	else snprintf(sizestr, 20, "full");
+	if(decomponly)
+		snprintf(tempstr, 1024, "%s_%s.%s", filename, sizestr, ext);
+	else
+		snprintf(tempstr, 1024, "%s_%s%s_%s.%s", filename, subName[subsamp],
+			qualstr, sizestr, ext);
+	if(savebmp(tempstr, dstbuf, scaledw, scaledh, bmpPF[pf], pitch,
+		(flags&TJFLAG_BOTTOMUP)!=0)==-1)
+		_throwbmp("saving bitmap");
+	ptr=strrchr(tempstr, '.');
+	snprintf(ptr, 1024-(ptr-tempstr), "-err.%s", ext);
+	if(srcbuf && sf.num==1 && sf.denom==1)
+	{
+		if(!quiet) printf("Compression error written to %s.\n", tempstr);
+		if(subsamp==TJ_GRAYSCALE)
+		{
+			int index, index2;
+			for(row=0, index=0; row<h; row++, index+=pitch)
+			{
+				for(col=0, index2=index; col<w; col++, index2+=ps)
+				{
+					int rindex=index2+tjRedOffset[pf];
+					int gindex=index2+tjGreenOffset[pf];
+					int bindex=index2+tjBlueOffset[pf];
+					int y=(int)((double)srcbuf[rindex]*0.299
+						+ (double)srcbuf[gindex]*0.587
+						+ (double)srcbuf[bindex]*0.114 + 0.5);
+					if(y>255) y=255;  if(y<0) y=0;
+					dstbuf[rindex]=abs(dstbuf[rindex]-y);
+					dstbuf[gindex]=abs(dstbuf[gindex]-y);
+					dstbuf[bindex]=abs(dstbuf[bindex]-y);
+				}
+			}
+		}		
+		else
+		{
+			for(row=0; row<h; row++)
+				for(col=0; col<w*ps; col++)
+					dstbuf[pitch*row+col]
+						=abs(dstbuf[pitch*row+col]-srcbuf[pitch*row+col]);
+		}
+		if(savebmp(tempstr, dstbuf, w, h, bmpPF[pf], pitch,
+			(flags&TJFLAG_BOTTOMUP)!=0)==-1)
+			_throwbmp("saving bitmap");
+	}
+
+	bailout:
+	if(file) {fclose(file);  file=NULL;}
+	if(handle) {tjDestroy(handle);  handle=NULL;}
+	if(dstbuf && dstbufalloc) {free(dstbuf);  dstbuf=NULL;}
+	return retval;
+}
+
+
+void dotest(unsigned char *srcbuf, int w, int h, int subsamp, int jpegqual,
+	char *filename)
+{
+	char tempstr[1024], tempstr2[80];
+	FILE *file=NULL;  tjhandle handle=NULL;
+	unsigned char **jpegbuf=NULL, *tmpbuf=NULL, *srcptr, *srcptr2;
+	double start, elapsed;
+	int totaljpegsize=0, row, col, i, tilew=w, tileh=h, retval=0;
+	unsigned long *jpegsize=NULL;
+	int ps=tjPixelSize[pf], ntilesw=1, ntilesh=1, pitch=w*ps;
+
+	if((tmpbuf=(unsigned char *)malloc(pitch*h)) == NULL)
+		_throwunix("allocating temporary image buffer");
+
+	if(!quiet)
+		printf(">>>>>  %s (%s) <--> JPEG %s Q%d  <<<<<\n", pixFormatStr[pf],
+			(flags&TJFLAG_BOTTOMUP)? "Bottom-up":"Top-down", subNameLong[subsamp],
+			jpegqual);
+
+	for(tilew=dotile? 8:w, tileh=dotile? 8:h; ; tilew*=2, tileh*=2)
+	{
+		if(tilew>w) tilew=w;  if(tileh>h) tileh=h;
+		ntilesw=(w+tilew-1)/tilew;  ntilesh=(h+tileh-1)/tileh;
+
+		if((jpegbuf=(unsigned char **)malloc(sizeof(unsigned char *)
+			*ntilesw*ntilesh))==NULL)
+			_throwunix("allocating JPEG tile array");
+		memset(jpegbuf, 0, sizeof(unsigned char *)*ntilesw*ntilesh);
+		if((jpegsize=(unsigned long *)malloc(sizeof(unsigned long)
+			*ntilesw*ntilesh))==NULL)
+			_throwunix("allocating JPEG size array");
+		memset(jpegsize, 0, sizeof(unsigned long)*ntilesw*ntilesh);
+
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			if((jpegbuf[i]=(unsigned char *)malloc(tjBufSize(tilew, tileh,
+				subsamp)))==NULL)
+				_throwunix("allocating JPEG tiles");
+		}
+
+		/* Compression test */
+		if(quiet==1)
+			printf("%s\t%s\t%s\t%d\t", pixFormatStr[pf],
+				(flags&TJFLAG_BOTTOMUP)? "BU":"TD", subNameLong[subsamp], jpegqual);
+		for(i=0; i<h; i++)
+			memcpy(&tmpbuf[pitch*i], &srcbuf[w*ps*i], w*ps);
+		if((handle=tjInitCompress())==NULL)
+			_throwtj("executing tjInitCompress()");
+
+		/* Execute once to preload cache */
+		if(tjCompress2(handle, srcbuf, tilew, pitch, tileh, pf, &jpegbuf[0],
+			&jpegsize[0], subsamp, jpegqual, flags)==-1)
+			_throwtj("executing tjCompress2()");
+
+		/* Benchmark */
+		for(i=0, start=gettime(); (elapsed=gettime()-start)<benchtime; i++)
+		{
+			int tile=0;
+			totaljpegsize=0;
+			for(row=0, srcptr=srcbuf; row<ntilesh; row++, srcptr+=pitch*tileh)
+			{
+				for(col=0, srcptr2=srcptr; col<ntilesw; col++, tile++,
+					srcptr2+=ps*tilew)
+				{
+					int width=min(tilew, w-col*tilew);
+					int height=min(tileh, h-row*tileh);
+					if(tjCompress2(handle, srcptr2, width, pitch, height, pf,
+						&jpegbuf[tile], &jpegsize[tile], subsamp, jpegqual, flags)==-1)
+						_throwtj("executing tjCompress()2");
+					totaljpegsize+=jpegsize[tile];
+				}
+			}
+		}
+
+		if(tjDestroy(handle)==-1) _throwtj("executing tjDestroy()");
+		handle=NULL;
+
+		if(quiet==1) printf("%-4d  %-4d\t", tilew, tileh);
+		if(quiet)
+		{
+			printf("%s%c%s%c",
+				sigfig((double)(w*h)/1000000.*(double)i/elapsed, 4, tempstr, 1024),
+				quiet==2? '\n':'\t',
+				sigfig((double)(w*h*ps)/(double)totaljpegsize, 4, tempstr2, 80),
+				quiet==2? '\n':'\t');
+		}
+		else
+		{
+			printf("\n%s size: %d x %d\n", dotile? "Tile":"Image", tilew,
+				tileh);
+			printf("C--> Frame rate:           %f fps\n", (double)i/elapsed);
+			printf("     Output image size:    %d bytes\n", totaljpegsize);
+			printf("     Compression ratio:    %f:1\n",
+				(double)(w*h*ps)/(double)totaljpegsize);
+			printf("     Source throughput:    %f Megapixels/sec\n",
+				(double)(w*h)/1000000.*(double)i/elapsed);
+			printf("     Output bit stream:    %f Megabits/sec\n",
+				(double)totaljpegsize*8./1000000.*(double)i/elapsed);
+		}
+		if(tilew==w && tileh==h)
+		{
+			snprintf(tempstr, 1024, "%s_%s_Q%d.jpg", filename, subName[subsamp],
+				jpegqual);
+			if((file=fopen(tempstr, "wb"))==NULL)
+				_throwunix("opening reference image");
+			if(fwrite(jpegbuf[0], jpegsize[0], 1, file)!=1)
+				_throwunix("writing reference image");
+			fclose(file);  file=NULL;
+			if(!quiet) printf("Reference image written to %s\n", tempstr);
+		}
+
+		/* Decompression test */
+		if(decomptest(srcbuf, jpegbuf, jpegsize, tmpbuf, w, h, subsamp, jpegqual,
+			filename, tilew, tileh)==-1)
+			goto bailout;
+
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			if(jpegbuf[i]) free(jpegbuf[i]);  jpegbuf[i]=NULL;
+		}
+		free(jpegbuf);  jpegbuf=NULL;
+		free(jpegsize);  jpegsize=NULL;
+
+		if(tilew==w && tileh==h) break;
+	}
+
+	bailout:
+	if(file) {fclose(file);  file=NULL;}
+	if(jpegbuf)
+	{
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			if(jpegbuf[i]) free(jpegbuf[i]);  jpegbuf[i]=NULL;
+		}
+		free(jpegbuf);  jpegbuf=NULL;
+	}
+	if(jpegsize) {free(jpegsize);  jpegsize=NULL;}
+	if(tmpbuf) {free(tmpbuf);  tmpbuf=NULL;}
+	if(handle) {tjDestroy(handle);  handle=NULL;}
+	return;
+}
+
+
+void dodecomptest(char *filename)
+{
+	FILE *file=NULL;  tjhandle handle=NULL;
+	unsigned char **jpegbuf=NULL, *srcbuf=NULL;
+	unsigned long *jpegsize=NULL, srcsize;
+	int w=0, h=0, subsamp=-1, _w, _h, _tilew, _tileh, _subsamp;
+	char *temp=NULL;
+	int i, tilew, tileh, ntilesw=1, ntilesh=1, retval=0;
+
+	if((file=fopen(filename, "rb"))==NULL)
+		_throwunix("opening file");
+	if(fseek(file, 0, SEEK_END)<0 || (srcsize=ftell(file))<0)
+		_throwunix("determining file size");
+	if((srcbuf=(unsigned char *)malloc(srcsize))==NULL)
+		_throwunix("allocating memory");
+	if(fseek(file, 0, SEEK_SET)<0)
+		_throwunix("setting file position");
+	if(fread(srcbuf, srcsize, 1, file)<1)
+		_throwunix("reading JPEG data");
+	fclose(file);  file=NULL;
+
+	temp=strrchr(filename, '.');
+	if(temp!=NULL) *temp='\0';
+
+	if((handle=tjInitDecompress())==NULL)
+		_throwtj("executing tjInitDecompress()");
+	if(tjDecompressHeader2(handle, srcbuf, srcsize, &w, &h, &subsamp)==-1)
+		_throwtj("executing tjDecompressHeader2()");
+
+	if(quiet==1)
+	{
+		printf("All performance values in Mpixels/sec\n\n");
+		printf("Bitmap\tBitmap\tJPEG\t%s %s \tXform\tComp\tDecomp\n",
+			dotile? "Tile ":"Image", dotile? "Tile ":"Image");
+		printf("Format\tOrder\tSubsamp\tWidth Height\tPerf \tRatio\tPerf\n\n");
+	}
+	else if(!quiet)
+	{
+		printf(">>>>>  JPEG %s --> %s (%s)  <<<<<\n", subNameLong[subsamp],
+			pixFormatStr[pf], (flags&TJFLAG_BOTTOMUP)? "Bottom-up":"Top-down");
+	}
+
+	for(tilew=dotile? 16:w, tileh=dotile? 16:h; ; tilew*=2, tileh*=2)
+	{
+		if(tilew>w) tilew=w;  if(tileh>h) tileh=h;
+		ntilesw=(w+tilew-1)/tilew;  ntilesh=(h+tileh-1)/tileh;
+
+		if((jpegbuf=(unsigned char **)malloc(sizeof(unsigned char *)
+			*ntilesw*ntilesh))==NULL)
+			_throwunix("allocating JPEG tile array");
+		memset(jpegbuf, 0, sizeof(unsigned char *)*ntilesw*ntilesh);
+		if((jpegsize=(unsigned long *)malloc(sizeof(unsigned long)
+			*ntilesw*ntilesh))==NULL)
+			_throwunix("allocating JPEG size array");
+		memset(jpegsize, 0, sizeof(unsigned long)*ntilesw*ntilesh);
+
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			if((jpegbuf[i]=(unsigned char *)malloc(tjBufSize(tilew, tileh,
+				subsamp)))==NULL)
+				_throwunix("allocating JPEG tiles");
+		}
+
+		_w=w;  _h=h;  _tilew=tilew;  _tileh=tileh;
+		if(!quiet)
+		{
+			printf("\n%s size: %d x %d", dotile? "Tile":"Image", _tilew,
+				_tileh);
+			if(sf.num!=1 || sf.denom!=1)
+				printf(" --> %d x %d", TJSCALED(_w, sf), TJSCALED(_h, sf));
+			printf("\n");
+		}
+		else if(quiet==1)
+		{
+			printf("%s\t%s\t%s\t", pixFormatStr[pf],
+				(flags&TJFLAG_BOTTOMUP)? "BU":"TD", subNameLong[subsamp]);
+			printf("%-4d  %-4d\t", tilew, tileh);
+		}
+
+		_subsamp=subsamp;
+		if(quiet==1) printf("N/A\tN/A\t");
+		jpegsize[0]=srcsize;
+		memcpy(jpegbuf[0], srcbuf, srcsize);
+
+		if(w==tilew) _tilew=_w;
+		if(h==tileh) _tileh=_h;
+		if(decomptest(NULL, jpegbuf, jpegsize, NULL, _w, _h, _subsamp, 0,
+			filename, _tilew, _tileh)==-1)
+			goto bailout;
+		else if(quiet==1) printf("N/A\n");
+
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			free(jpegbuf[i]);  jpegbuf[i]=NULL;
+		}
+		free(jpegbuf);  jpegbuf=NULL;
+		if(jpegsize) {free(jpegsize);  jpegsize=NULL;}
+
+		if(tilew==w && tileh==h) break;
+	}
+
+	bailout:
+	if(file) {fclose(file);  file=NULL;}
+	if(jpegbuf)
+	{
+		for(i=0; i<ntilesw*ntilesh; i++)
+		{
+			if(jpegbuf[i]) free(jpegbuf[i]);  jpegbuf[i]=NULL;
+		}
+		free(jpegbuf);  jpegbuf=NULL;
+	}
+	if(jpegsize) {free(jpegsize);  jpegsize=NULL;}
+	if(srcbuf) {free(srcbuf);  srcbuf=NULL;}
+	if(handle) {tjDestroy(handle);  handle=NULL;}
+	return;
+}
+
+
+void usage(char *progname)
+{
+	int i;
+	printf("USAGE: %s\n", progname);
+	printf("       <Inputfile (BMP|PPM)> <%% Quality> [options]\n\n");
+	printf("       %s\n", progname);
+	printf("       <Inputfile (JPG)> [options]\n\n");
+	printf("Options:\n\n");
+	printf("-bmp = Generate output images in Windows Bitmap format (default=PPM)\n");
+	printf("-bottomup = Test bottom-up compression/decompression\n");
+	printf("-tile = Test performance of the codec when the image is encoded as separate\n");
+	printf("     tiles of varying sizes.\n");
+	printf("-forcemmx, -forcesse, -forcesse2, -forcesse3 =\n");
+	printf("     Force MMX, SSE, SSE2, or SSE3 code paths in the underlying codec\n");
+	printf("-rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb =\n");
+	printf("     Test the specified color conversion path in the codec (default: BGR)\n");
+	printf("-fastupsample = Use fast, inaccurate upsampling code to perform 4:2:2 and 4:2:0\n");
+	printf("     YUV decoding\n");
+	printf("-quiet = Output results in tabular rather than verbose format\n");
+	printf("-scale M/N = scale down the width/height of the decompressed JPEG image by a\n");
+	printf("     factor of M/N (M/N = ");
+	for(i=0; i<nsf; i++)
+	{
+		printf("%d/%d", scalingfactors[i].num, scalingfactors[i].denom);
+		if(nsf==2 && i!=nsf-1) printf(" or ");
+		else if(nsf>2)
+		{
+			if(i!=nsf-1) printf(", ");
+			if(i==nsf-2) printf("or ");
+		}
+	}
+	printf(")\n");
+	printf("-benchtime <t> = Run each benchmark for at least <t> seconds (default = 5.0)\n\n");
+	printf("NOTE:  If the quality is specified as a range (e.g. 90-100), a separate\n");
+	printf("test will be performed for all quality values in the range.\n\n");
+	exit(1);
+}
+
+
+int main(int argc, char *argv[])
+{
+	unsigned char *srcbuf=NULL;  int w, h, i, j;
+	int minqual=-1, maxqual=-1;  char *temp;
+	int minarg=2;  int retval=0;
+
+	if((scalingfactors=tjGetScalingFactors(&nsf))==NULL || nsf==0)
+		_throwtj("executing tjGetScalingFactors()");
+
+	if(argc<minarg) usage(argv[0]);
+
+	temp=strrchr(argv[1], '.');
+	if(temp!=NULL)
+	{
+		if(!strcasecmp(temp, ".bmp")) ext="bmp";
+		if(!strcasecmp(temp, ".jpg") || !strcasecmp(temp, ".jpeg")) decomponly=1;
+	}
+
+	printf("\n");
+
+	if(!decomponly)
+	{
+		minarg=3;
+		if(argc<minarg) usage(argv[0]);
+		if((minqual=atoi(argv[2]))<1 || minqual>100)
+		{
+			puts("ERROR: Quality must be between 1 and 100.");
+			exit(1);
+		}
+		if((temp=strchr(argv[2], '-'))!=NULL && strlen(temp)>1
+			&& sscanf(&temp[1], "%d", &maxqual)==1 && maxqual>minqual && maxqual>=1
+			&& maxqual<=100) {}
+		else maxqual=minqual;
+	}
+
+	if(argc>minarg)
+	{
+		for(i=minarg; i<argc; i++)
+		{
+			if(!strcasecmp(argv[i], "-tile"))
+			{
+				dotile=1;
+			}
+			if(!strcasecmp(argv[i], "-forcesse3"))
+			{
+				printf("Forcing SSE3 code\n\n");
+				flags|=TJFLAG_FORCESSE3;
+			}
+			if(!strcasecmp(argv[i], "-forcesse2"))
+			{
+				printf("Forcing SSE2 code\n\n");
+				flags|=TJFLAG_FORCESSE2;
+			}
+			if(!strcasecmp(argv[i], "-forcesse"))
+			{
+				printf("Forcing SSE code\n\n");
+				flags|=TJFLAG_FORCESSE;
+			}
+			if(!strcasecmp(argv[i], "-forcemmx"))
+			{
+				printf("Forcing MMX code\n\n");
+				flags|=TJFLAG_FORCEMMX;
+			}
+			if(!strcasecmp(argv[i], "-fastupsample"))
+			{
+				printf("Using fast upsampling code\n\n");
+				flags|=TJFLAG_FASTUPSAMPLE;
+			}
+			if(!strcasecmp(argv[i], "-rgb")) pf=TJPF_RGB;
+			if(!strcasecmp(argv[i], "-rgbx")) pf=TJPF_RGBX;
+			if(!strcasecmp(argv[i], "-bgr")) pf=TJPF_BGR;
+			if(!strcasecmp(argv[i], "-bgrx")) pf=TJPF_BGRX;
+			if(!strcasecmp(argv[i], "-xbgr")) pf=TJPF_XBGR;
+			if(!strcasecmp(argv[i], "-xrgb")) pf=TJPF_XRGB;
+			if(!strcasecmp(argv[i], "-bottomup")) flags|=TJFLAG_BOTTOMUP;
+			if(!strcasecmp(argv[i], "-quiet")) quiet=1;
+			if(!strcasecmp(argv[i], "-qq")) quiet=2;
+			if(!strcasecmp(argv[i], "-scale") && i<argc-1)
+			{
+				int temp1=0, temp2=0, match=0;
+				if(sscanf(argv[++i], "%d/%d", &temp1, &temp2)==2)
+				{
+					for(j=0; j<nsf; j++)
+					{
+						if(temp1==scalingfactors[j].num && temp2==scalingfactors[j].denom)
+						{
+							sf=scalingfactors[j];
+							match=1;  break;
+						}
+					}
+					if(!match) usage(argv[0]);
+				}
+				else usage(argv[0]);
+			}
+			if(!strcasecmp(argv[i], "-benchtime") && i<argc-1)
+			{
+				double temp=atof(argv[++i]);
+				if(temp>0.0) benchtime=temp;
+				else usage(argv[0]);
+			}
+			if(!strcmp(argv[i], "-?")) usage(argv[0]);
+			if(!strcasecmp(argv[i], "-bmp")) ext="bmp";
+		}
+	}
+
+	if((sf.num!=1 || sf.denom!=1) && dotile)
+	{
+		printf("Disabling tiled compression/decompression tests, because those tests do not\n");
+		printf("work when scaled decompression is enabled.\n");
+		dotile=0;
+	}
+
+	if(!decomponly)
+	{
+		if(loadbmp(argv[1], &srcbuf, &w, &h, bmpPF[pf], 1,
+			(flags&TJFLAG_BOTTOMUP)!=0)==-1)
+			_throwbmp("loading bitmap");
+		temp=strrchr(argv[1], '.');
+		if(temp!=NULL) *temp='\0';
+	}
+
+	if(quiet==1 && !decomponly)
+	{
+		printf("All performance values in Mpixels/sec\n\n");
+		printf("Bitmap\tBitmap\tJPEG\tJPEG\t%s %s \tComp\tComp\tDecomp\n",
+			dotile? "Tile ":"Image", dotile? "Tile ":"Image");
+		printf("Format\tOrder\tSubsamp\tQual\tWidth Height\tPerf \tRatio\tPerf\n\n");
+	}
+
+	if(decomponly)
+	{
+		dodecomptest(argv[1]);
+		printf("\n");
+		goto bailout;
+	}
+	for(i=maxqual; i>=minqual; i--)
+		dotest(srcbuf, w, h, TJ_GRAYSCALE, i, argv[1]);
+	printf("\n");
+	for(i=maxqual; i>=minqual; i--)
+		dotest(srcbuf, w, h, TJ_420, i, argv[1]);
+	printf("\n");
+	for(i=maxqual; i>=minqual; i--)
+		dotest(srcbuf, w, h, TJ_422, i, argv[1]);
+	printf("\n");
+	for(i=maxqual; i>=minqual; i--)
+		dotest(srcbuf, w, h, TJ_444, i, argv[1]);
+	printf("\n");
+
+	bailout:
+	if(srcbuf) free(srcbuf);
+	return retval;
+}
diff --git a/test/tjunittest.c b/test/tjunittest.c
new file mode 100644
index 0000000..c9960eb
--- /dev/null
+++ b/test/tjunittest.c
@@ -0,0 +1,461 @@
+/*
+ * 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
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This program tests the various code paths in the TurboJPEG C Wrapper
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "./tjutil.h"
+#include "./turbojpeg.h"
+#ifdef _WIN32
+ #include <time.h>
+ #define random() rand()
+#endif
+
+
+#define _throwtj() {printf("TurboJPEG ERROR:\n%s\n", tjGetErrorStr());  \
+	bailout();}
+#define _tj(f) {if((f)==-1) _throwtj();}
+#define _throw(m) {printf("ERROR: %s\n", m);  bailout();}
+
+const char *subNameLong[TJ_NUMSAMP]=
+{
+	"4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0"
+};
+const char *subName[TJ_NUMSAMP]={"444", "422", "420", "GRAY", "440"};
+
+const char *pixFormatStr[TJ_NUMPF]=
+{
+	"RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
+	"RGBA", "BGRA", "ABGR", "ARGB"
+};
+
+const int alphaOffset[TJ_NUMPF] = {-1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0};
+
+const int _3byteFormats[]={TJPF_RGB, TJPF_BGR};
+const int _4byteFormats[]={TJPF_RGBX, TJPF_BGRX, TJPF_XBGR, TJPF_XRGB};
+const int _onlyGray[]={TJPF_GRAY};
+const int _onlyRGB[]={TJPF_RGB};
+
+int exitStatus=0;
+#define bailout() {exitStatus=-1;  goto bailout;}
+
+
+void initBuf(unsigned char *buf, int w, int h, int pf, int flags)
+{
+	int roffset=tjRedOffset[pf];
+	int goffset=tjGreenOffset[pf];
+	int boffset=tjBlueOffset[pf];
+	int ps=tjPixelSize[pf];
+	int index, row, col, halfway=16;
+
+	memset(buf, 0, w*h*ps);
+	if(pf==TJPF_GRAY)
+	{
+		for(row=0; row<h; row++)
+		{
+			for(col=0; col<w; col++)
+			{
+				if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
+				else index=row*w+col;
+				if(((row/8)+(col/8))%2==0) buf[index]=(row<halfway)? 255:0;
+				else buf[index]=(row<halfway)? 76:226;
+			}
+		}
+	}
+	else
+	{
+		for(row=0; row<h; row++)
+		{
+			for(col=0; col<w; col++)
+			{
+				if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
+				else index=row*w+col;
+				if(((row/8)+(col/8))%2==0)
+				{
+					if(row<halfway)
+					{
+						buf[index*ps+roffset]=255;
+						buf[index*ps+goffset]=255;
+						buf[index*ps+boffset]=255;
+					}
+				}
+				else
+				{
+					buf[index*ps+roffset]=255;
+					if(row>=halfway) buf[index*ps+goffset]=255;
+				}
+			}
+		}
+	}
+}
+
+
+#define checkval(v, cv) { \
+	if(v<cv-1 || v>cv+1) { \
+		printf("\nComp. %s at %d,%d should be %d, not %d\n",  \
+			#v, row, col, cv, v); \
+		retval=0;  exitStatus=-1;  goto bailout; \
+	}}
+
+#define checkval0(v) { \
+	if(v>1) { \
+		printf("\nComp. %s at %d,%d should be 0, not %d\n", #v, row, col, v); \
+		retval=0;  exitStatus=-1;  goto bailout; \
+	}}
+
+#define checkval255(v) { \
+	if(v<254) { \
+		printf("\nComp. %s at %d,%d should be 255, not %d\n", #v, row, col, v); \
+		retval=0;  exitStatus=-1;  goto bailout; \
+	}}
+
+
+int checkBuf(unsigned char *buf, int w, int h, int pf, int subsamp,
+	tjscalingfactor sf, int flags)
+{
+	int roffset=tjRedOffset[pf];
+	int goffset=tjGreenOffset[pf];
+	int boffset=tjBlueOffset[pf];
+	int aoffset=alphaOffset[pf];
+	int ps=tjPixelSize[pf];
+	int index, row, col, retval=1;
+	int halfway=16*sf.num/sf.denom;
+	int blocksize=8*sf.num/sf.denom;
+
+	for(row=0; row<h; row++)
+	{
+		for(col=0; col<w; col++)
+		{
+			unsigned char r, g, b, a;
+			if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
+			else index=row*w+col;
+			r=buf[index*ps+roffset];
+			g=buf[index*ps+goffset];
+			b=buf[index*ps+boffset];
+			a=aoffset>=0? buf[index*ps+aoffset]:0xFF;
+			if(((row/blocksize)+(col/blocksize))%2==0)
+			{
+				if(row<halfway)
+				{
+					checkval255(r);  checkval255(g);  checkval255(b);
+				}
+				else
+				{
+					checkval0(r);  checkval0(g);  checkval0(b);
+				}
+			}
+			else
+			{
+				if(subsamp==TJSAMP_GRAY)
+				{
+					if(row<halfway)
+					{
+						checkval(r, 76);  checkval(g, 76);  checkval(b, 76);
+					}
+					else
+					{
+						checkval(r, 226);  checkval(g, 226);  checkval(b, 226);
+					}
+				}
+				else
+				{
+					if(row<halfway)
+					{
+						checkval255(r);  checkval0(g);  checkval0(b);
+					}
+					else
+					{
+						checkval255(r);  checkval255(g);  checkval0(b);
+					}
+				}
+			}
+			checkval255(a);
+		}
+	}
+
+	bailout:
+	if(retval==0)
+	{
+		printf("\n");
+		for(row=0; row<h; row++)
+		{
+			for(col=0; col<w; col++)
+			{
+				printf("%.3d/%.3d/%.3d ", buf[(row*w+col)*ps+roffset],
+					buf[(row*w+col)*ps+goffset], buf[(row*w+col)*ps+boffset]);
+			}
+			printf("\n");
+		}
+	}
+	return retval;
+}
+
+
+void writeJPEG(unsigned char *jpegBuf, unsigned long jpegSize, char *filename)
+{
+	FILE *file=fopen(filename, "wb");
+	if(!file || fwrite(jpegBuf, jpegSize, 1, file)!=1)
+	{
+		printf("ERROR: Could not write to %s.\n%s\n", filename, strerror(errno));
+		bailout();
+	}
+
+	bailout:
+	if(file) fclose(file);
+}
+
+
+void compTest(tjhandle handle, unsigned char **dstBuf,
+	unsigned long *dstSize, int w, int h, int pf, char *basename,
+	int subsamp, int jpegQual, int flags)
+{
+	char tempStr[1024];  unsigned char *srcBuf=NULL;
+	double t;
+
+	printf("%s %s -> %s Q%d ... ", pixFormatStr[pf],
+		(flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ", subNameLong[subsamp],
+		jpegQual);
+
+	if((srcBuf=(unsigned char *)malloc(w*h*tjPixelSize[pf]))==NULL)
+		_throw("Memory allocation failure");
+	initBuf(srcBuf, w, h, pf, flags);
+	if(*dstBuf && *dstSize>0) memset(*dstBuf, 0, *dstSize);
+
+	t=gettime();
+	*dstSize=tjBufSize(w, h, subsamp);
+	_tj(tjCompress2(handle, srcBuf, w, 0, h, pf, dstBuf, dstSize, subsamp,
+		jpegQual, flags));
+	t=gettime()-t;
+
+	snprintf(tempStr, 1024, "%s_enc_%s_%s_%s_Q%d.jpg", basename,
+		pixFormatStr[pf], (flags&TJFLAG_BOTTOMUP)? "BU":"TD", subName[subsamp],
+		jpegQual);
+	writeJPEG(*dstBuf, *dstSize, tempStr);
+	printf("Done.");
+	printf("  %f ms\n  Result in %s\n", t*1000., tempStr);
+
+	bailout:
+	if(srcBuf) free(srcBuf);
+}
+
+
+void _decompTest(tjhandle handle, unsigned char *jpegBuf,
+	unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
+	int flags, tjscalingfactor sf)
+{
+	unsigned char *dstBuf=NULL;
+	int _hdrw=0, _hdrh=0, _hdrsubsamp=-1;  double t;
+	int scaledWidth=TJSCALED(w, sf);
+	int scaledHeight=TJSCALED(h, sf);
+	unsigned long dstSize=0;
+
+	printf("JPEG -> %s %s ", pixFormatStr[pf],
+		(flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ");
+	if(sf.num!=1 || sf.denom!=1)
+		printf("%d/%d ... ", sf.num, sf.denom);
+	else printf("... ");
+
+	_tj(tjDecompressHeader2(handle, jpegBuf, jpegSize, &_hdrw, &_hdrh,
+		&_hdrsubsamp));
+	if(_hdrw!=w || _hdrh!=h || _hdrsubsamp!=subsamp)
+		_throw("Incorrect JPEG header");
+
+	dstSize=scaledWidth*scaledHeight*tjPixelSize[pf];
+	if((dstBuf=(unsigned char *)malloc(dstSize))==NULL)
+		_throw("Memory allocation failure");
+	memset(dstBuf, 0, dstSize);
+
+	t=gettime();
+	_tj(tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, scaledWidth, 0,
+		scaledHeight, pf, flags));
+	t=gettime()-t;
+
+	if(checkBuf(dstBuf, scaledWidth, scaledHeight, pf, subsamp, sf, flags))
+		printf("Passed.");
+	else printf("FAILED!");
+	printf("  %f ms\n", t*1000.);
+
+	bailout:
+	if(dstBuf) free(dstBuf);
+}
+
+
+void decompTest(tjhandle handle, unsigned char *jpegBuf,
+	unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
+	int flags)
+{
+	int i, n=0;
+	tjscalingfactor *sf=tjGetScalingFactors(&n), sf1={1, 1};
+	if(!sf || !n) _throwtj();
+
+	if((subsamp==TJSAMP_444 || subsamp==TJSAMP_GRAY))
+	{
+		for(i=0; i<n; i++)
+			_decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
+				flags, sf[i]);
+	}
+	else
+		_decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp, flags,
+			sf1);
+
+	bailout:
+	printf("\n");
+}
+
+
+void doTest(int w, int h, const int *formats, int nformats, int subsamp,
+	char *basename)
+{
+	tjhandle chandle=NULL, dhandle=NULL;
+	unsigned char *dstBuf=NULL;
+	unsigned long size=0;  int pfi, pf, i;
+
+	size=tjBufSize(w, h, subsamp);
+	if((dstBuf=(unsigned char *)malloc(size))==NULL)
+		_throw("Memory allocation failure.");
+
+	if((chandle=tjInitCompress())==NULL || (dhandle=tjInitDecompress())==NULL)
+		_throwtj();
+
+	for(pfi=0; pfi<nformats; pfi++)
+	{
+		for(i=0; i<2; i++)
+		{
+			int flags=0;
+			if(subsamp==TJSAMP_422 || subsamp==TJSAMP_420 || subsamp==TJSAMP_440)
+				flags|=TJFLAG_FASTUPSAMPLE;
+			if(i==1) flags|=TJFLAG_BOTTOMUP;
+			pf=formats[pfi];
+			compTest(chandle, &dstBuf, &size, w, h, pf, basename, subsamp, 100,
+				flags);
+			decompTest(dhandle, dstBuf, size, w, h, pf, basename, subsamp,
+				flags);
+			if(pf>=TJPF_RGBX && pf<=TJPF_XRGB)
+				decompTest(dhandle, dstBuf, size, w, h, pf+(TJPF_RGBA-TJPF_RGBX),
+					basename, subsamp, flags);
+		}
+	}
+
+	bailout:
+	if(chandle) tjDestroy(chandle);
+	if(dhandle) tjDestroy(dhandle);
+
+	if(dstBuf) free(dstBuf);
+}
+
+
+void bufSizeTest(void)
+{
+	int w, h, i, subsamp;
+	unsigned char *srcBuf=NULL, *jpegBuf=NULL;
+	tjhandle handle=NULL;
+	unsigned long jpegSize=0;
+
+	if((handle=tjInitCompress())==NULL) _throwtj();
+
+	printf("Buffer size regression test\n");
+	for(subsamp=0; subsamp<TJ_NUMSAMP; subsamp++)
+	{
+		for(w=1; w<48; w++)
+		{
+			int maxh=(w==1)? 2048:48;
+			for(h=1; h<maxh; h++)
+			{
+				if(h%100==0) printf("%.4d x %.4d\b\b\b\b\b\b\b\b\b\b\b", w, h);
+				if((srcBuf=(unsigned char *)malloc(w*h*4))==NULL)
+					_throw("Memory allocation failure");
+				if((jpegBuf=(unsigned char *)malloc(tjBufSize(w, h, subsamp)))
+					==NULL)
+					_throw("Memory allocation failure");
+				jpegSize=tjBufSize(w, h, subsamp);
+
+				for(i=0; i<w*h*4; i++)
+				{
+					if(random()<RAND_MAX/2) srcBuf[i]=0;
+					else srcBuf[i]=255;
+				}
+
+				_tj(tjCompress2(handle, srcBuf, w, 0, h, TJPF_BGRX, &jpegBuf,
+					&jpegSize, subsamp, 100, 0));
+				free(srcBuf);  srcBuf=NULL;
+				free(jpegBuf);  jpegBuf=NULL;
+
+				if((srcBuf=(unsigned char *)malloc(h*w*4))==NULL)
+					_throw("Memory allocation failure");
+				if((jpegBuf=(unsigned char *)malloc(tjBufSize(h, w, subsamp)))
+					==NULL)
+					_throw("Memory allocation failure");
+				jpegSize=tjBufSize(h, w, subsamp);
+
+				for(i=0; i<h*w*4; i++)
+				{
+					if(random()<RAND_MAX/2) srcBuf[i]=0;
+					else srcBuf[i]=255;
+				}
+
+				_tj(tjCompress2(handle, srcBuf, h, 0, w, TJPF_BGRX, &jpegBuf,
+					&jpegSize, subsamp, 100, 0));
+				free(srcBuf);  srcBuf=NULL;
+				free(jpegBuf);  jpegBuf=NULL;
+			}
+		}
+	}
+	printf("Done.      \n");
+
+	bailout:
+	if(srcBuf) free(srcBuf);
+	if(jpegBuf) free(jpegBuf);
+	if(handle) tjDestroy(handle);
+}
+
+
+int main(int argc, char *argv[])
+{
+	#ifdef _WIN32
+	srand((unsigned int)time(NULL));
+	#endif
+	doTest(35, 39, _3byteFormats, 2, TJSAMP_444, "test");
+	doTest(39, 41, _4byteFormats, 4, TJSAMP_444, "test");
+	doTest(41, 35, _3byteFormats, 2, TJSAMP_422, "test");
+	doTest(35, 39, _4byteFormats, 4, TJSAMP_422, "test");
+	doTest(39, 41, _3byteFormats, 2, TJSAMP_420, "test");
+	doTest(41, 35, _4byteFormats, 4, TJSAMP_420, "test");
+	doTest(35, 39, _3byteFormats, 2, TJSAMP_440, "test");
+	doTest(39, 41, _4byteFormats, 4, TJSAMP_440, "test");
+	doTest(35, 39, _onlyGray, 1, TJSAMP_GRAY, "test");
+	doTest(39, 41, _3byteFormats, 2, TJSAMP_GRAY, "test");
+	doTest(41, 35, _4byteFormats, 4, TJSAMP_GRAY, "test");
+	bufSizeTest();
+
+	return exitStatus;
+}
diff --git a/test/tjutil.c b/test/tjutil.c
new file mode 100644
index 0000000..6618d15
--- /dev/null
+++ b/test/tjutil.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C)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
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+static double getfreq(void)
+{
+	LARGE_INTEGER freq;
+	if(!QueryPerformanceFrequency(&freq)) return 0.0;
+	return (double)freq.QuadPart;
+}
+
+static double f=-1.0;
+
+double gettime(void)
+{
+	LARGE_INTEGER t;
+	if(f<0.0) f=getfreq();
+	if(f==0.0) return (double)GetTickCount()/1000.;
+	else
+	{
+		QueryPerformanceCounter(&t);
+		return (double)t.QuadPart/f;
+	}
+}
+
+#else
+
+#include <stdlib.h>
+#include <sys/time.h>
+
+double gettime(void)
+{
+	struct timeval tv;
+	if(gettimeofday(&tv, NULL)<0) return 0.0;
+	else return (double)tv.tv_sec+((double)tv.tv_usec/1000000.);
+}
+
+#endif
diff --git a/test/tjutil.h b/test/tjutil.h
new file mode 100644
index 0000000..bdad348
--- /dev/null
+++ b/test/tjutil.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C)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
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+	#ifndef __MINGW32__
+		#include <stdio.h>
+		#define snprintf(str, n, format, ...)  \
+			_snprintf_s(str, n, _TRUNCATE, format, __VA_ARGS__)
+	#endif
+	#define strcasecmp stricmp
+	#define strncasecmp strnicmp
+#endif
+
+#ifndef min
+ #define min(a,b) ((a)<(b)?(a):(b))
+#endif
+
+#ifndef max
+ #define max(a,b) ((a)>(b)?(a):(b))
+#endif
+
+extern double gettime(void);
diff --git a/x11vnc/Makefile.am b/x11vnc/Makefile.am
index cef82f3..12ca9f1 100644
--- a/x11vnc/Makefile.am
+++ b/x11vnc/Makefile.am
@@ -36,7 +36,7 @@ x11vnc_SOURCES = 8to24.c appshare.c avahi.c cleanup.c connections.c cursor.c gui
 if HAVE_SYSTEM_LIBVNCSERVER
 INCLUDES_LIBVNCSERVER = @SYSTEM_LIBVNCSERVER_CFLAGS@
 else
-INCLUDES_LIBVNCSERVER =
+INCLUDES_LIBVNCSERVER = -I${top_srcdir}
 endif
 INCLUDES = $(INCLUDES_LIBVNCSERVER) @X_CFLAGS@ @AVAHI_CFLAGS@