Add TurboVNC encoding support.

TurboVNC is a variant of TightVNC that uses the same client/server protocol (RFB version 3.8t),
and thus it is fully cross-compatible with TightVNC and TigerVNC (with one exception, which is noted below.)
Both the TightVNC and TurboVNC encoders analyze each rectangle, pick out regions of solid color to send
separately, and send the remaining subrectangles using mono, indexed color, JPEG, or raw encoding, depending
on the number of colors in the subrectangle.  However, TurboVNC uses a fundamentally different selection
algorithm to determine the appropriate subencoding to use for each subrectangle.  Thus, while it sends a
protocol stream that can be decoded by any TightVNC-compatible viewer, the mix of subencoding types in this
protocol stream will be different from those generated by a TightVNC server.

The research that led to TurboVNC is described in the following report:
http://www.virtualgl.org/pmwiki/uploads/About/tighttoturbo.pdf.
In summary:  20 RFB captures, representing "common" 2D and 3D application workloads (the 3D workloads were
run using VirtualGL), were studied using the TightVNC encoder in isolation.  Some of the analysis features
in the TightVNC encoder, such as smoothness detection, were found to generate a lot of CPU usage with little
or no benefit in compression, so those features were disabled.  JPEG encoding was accelerated using
libjpeg-turbo (which achieves a 2-4x speedup over plain libjpeg on modern x86 or ARM processors.)  Finally,
the "palette threshold" (minimum number of colors that the subrectangle must have before it is compressed
using JPEG or raw) was adjusted to account for the fact that JPEG encoding is now quite a bit faster
(meaning that we can now use it more without a CPU penalty.)  TurboVNC has additional optimizations,
such as the ability to count colors and encode JPEG images directly from the framebuffer without first
translating the pixels into RGB.  The TurboVNC encoder compares quite favorably in terms of compression
ratio with TightVNC and generally encodes a great deal faster (often an order of magnitude or more.)

The version of the TurboVNC encoder included in this patch is roughly equivalent to the one found in version
0.6 of the Unix TurboVNC Server, with a few minor patches integrated from TurboVNC 1.1.  TurboVNC 1.0
added multi-threading capabilities, which can be added in later if desired (at the expense of making
libvncserver depend on libpthread.)

Because TurboVNC uses a fundamentally different mix of subencodings than TightVNC, because it uses
the identical protocol (and thus a viewer really has no idea whether it's talking to a TightVNC or
TurboVNC server), and because it doesn't support rfbTightPng (and in fact conflicts with it-- see below),
the TurboVNC and TightVNC encoders cannot be enabled simultaneously.

Compatibility:

In *most* cases, a TurboVNC-enabled viewer is fully compatible with a TightVNC server, and vice versa.
TurboVNC supports pseudo-encodings for specifying a fine-grained (1-100) quality scale and specifying
chrominance subsampling.  If a TurboVNC viewer sends those to a TightVNC server, then the TightVNC server
ignores them, so the TurboVNC viewer also sends the quality on a 0-9 scale that the TightVNC server can
understand.  Similarly, the TurboVNC server checks first for fine-grained quality and subsampling
pseudo-encodings from the viewer, and failing to receive those, it then checks for the TightVNC 0-9
quality pseudo-encoding.

There is one case in which the two systems are not compatible, and that is when a TightVNC or TigerVNC
viewer requests compression level 0 without JPEG from a TurboVNC server.  For performance reasons,
this causes the TurboVNC server to send images directly to the viewer, bypassing Zlib.  When the
TurboVNC server does this, it also sets bits 7-4 in the compression control byte to rfbTightNoZlib (0x0A),
which is unfortunately the same value as rfbTightPng.  Older TightVNC viewers that don't handle PNG
will assume that the stream is uncompressed but still encapsulated in a Zlib structure, whereas newer
PNG-supporting TightVNC viewers will assume that the stream is PNG.  In either case, the viewer will
probably crash.  Since most VNC viewers don't expose compression level 0 in the GUI, this is a
relatively rare situation.

Description of changes:

configure.ac
-- Added support for libjpeg-turbo.  If passed an argument of --with-turbovnc, configure will now run
   (or, if cross-compiling, just link) a test program that determines whether the libjpeg library being
   used is libjpeg-turbo.  libjpeg-turbo must be used when building the TurboVNC encoder, because the
   TurboVNC encoder relies on the libjpeg-turbo colorspace extensions in order to compress images directly
   out of the framebuffer (which may be, for instance, BGRA rather than RGB.)  libjpeg-turbo can optionally
   be used with the TightVNC encoder as well, but the speedup will only be marginal (the report linked
   above explains why in more detail, but basically it's because of Amdahl's Law.  The TightVNC encoder
    was designed with the assumption that JPEG had a very high CPU cost, and thus JPEG is used only sparingly.)
-- Added a new configure variable, JPEG_LDFLAGS.  This is necessitated by the fact that libjpeg-turbo
   often distributes libjpeg.a and libjpeg.so in /opt/libjpeg-turbo/lib32 or /opt/libjpeg-turbo/lib64,
   and many people prefer to statically link with it.  Thus, more flexibility is needed than is provided
   by --with-jpeg.  If JPEG_LDFLAGS is specified, then it overrides the changes to LDFLAGS enacted by
   --with-jpeg (but --with-jpeg is still used to set the include path.)  The addition of JPEG_LDFLAGS
   necessitated replacing AC_CHECK_LIB with AC_LINK_IFELSE (because AC_CHECK_LIB automatically sets
   LIBS to -ljpeg, which is not what we want if we're, for instance, linking statically with libjpeg-turbo.)
-- configure does not check for PNG support if TurboVNC encoding is enabled.  This prevents the
   rfbSendRectEncodingTightPng() function from being compiled in, since the TurboVNC encoder doesn't
   (and can't) support it.

common/turbojpeg.c, common/turbojpeg.h
-- TurboJPEG is a simple API used to compress and decompress JPEG images in memory.  It was originally
   implemented because it was desirable to use different types of underlying technologies to compress
   JPEG on different platforms (mediaLib on SPARC, Quicktime on PPC Macs, Intel Performance Primitives, etc.)
   These days, however, libjpeg-turbo is the only underlying technology used by TurboVNC, so TurboJPEG's
   purpose is largely just code simplicity and flexibility.  Thus, since there is no real need for
   libvncserver to use any technology other than libjpeg-turbo for compressing JPEG, the TurboJPEG wrapper
   for libjpeg-turbo has been included in-tree so that libvncserver can be directly linked with libjpeg-turbo.
   This is convenient because many modern Linux distros (Fedora, Ubuntu, etc.) now ship libjpeg-turbo as
   their default libjpeg library.

libvncserver/rfbserver.c
-- Added logic to check for the TurboVNC fine-grained quality level and subsampling encodings and to
   map Tight (0-9) quality levels to appropriate fine-grained quality level and subsampling values if
   communicating with a TightVNC/TigerVNC viewer.

libvncserver/turbo.c
-- TurboVNC encoder (compiled instead of libvncserver/tight.c)

rfb/rfb.h
-- Added support for the TurboVNC subsampling level

rfb/rfbproto.h
-- Added constants for the TurboVNC fine quality level and subsampling encodings as well as the rfbTightNoZlib
   constant and notes on its usage.

8 files changed, 2395 insertions, 8 deletions

diff --git a/common/turbojpeg.c b/common/turbojpeg.c
new file mode 100644
index 0000000..497ec59
--- /dev/null
+++ b/common/turbojpeg.c
@@ -0,0 +1,424 @@
+/* Copyright (C)2004 Landmark Graphics Corporation
+ * Copyright (C)2005 Sun Microsystems, Inc.
+ * Copyright (C)2009-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 implements a JPEG compressor/decompressor using the libjpeg API
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <jpeglib.h>
+#include <jerror.h>
+#include <setjmp.h>
+#include "./turbojpeg.h"
+
+
+#define CSTATE_START 100
+#define DSTATE_START 200
+
+
+// Error handling
+
+static char lasterror[JMSG_LENGTH_MAX]="No error";
+
+typedef struct _error_mgr
+{
+	struct jpeg_error_mgr pub;
+	jmp_buf jb;
+} error_mgr;
+
+static void my_error_exit(j_common_ptr cinfo)
+{
+	error_mgr *myerr = (error_mgr *)cinfo->err;
+	(*cinfo->err->output_message)(cinfo);
+	longjmp(myerr->jb, 1);
+}
+
+static void my_output_message(j_common_ptr cinfo)
+{
+	(*cinfo->err->format_message)(cinfo, lasterror);
+}
+
+
+// Global structures, macros, etc.
+
+typedef struct _jpgstruct
+{
+	struct jpeg_compress_struct cinfo;
+	struct jpeg_decompress_struct dinfo;
+	struct jpeg_destination_mgr jdms;
+	struct jpeg_source_mgr jsms;
+	error_mgr jerr;
+	int initc, initd;
+} jpgstruct;
+
+static const int hsampfactor[NUMSUBOPT]={1, 2, 2, 1};
+static const int vsampfactor[NUMSUBOPT]={1, 1, 2, 1};
+static const int pixelsize[NUMSUBOPT]={3, 3, 3, 1};
+
+#define _throw(c) {sprintf(lasterror, "%s", c);  retval=-1;  goto bailout;}
+#define checkhandle(h) jpgstruct *j=(jpgstruct *)h; \
+	if(!j) {sprintf(lasterror, "Invalid handle");  return -1;}
+
+
+// CO
+
+static boolean empty_output_buffer(struct jpeg_compress_struct *cinfo)
+{
+	ERREXIT(cinfo, JERR_BUFFER_SIZE);
+	return TRUE;
+}
+
+static void destination_noop(struct jpeg_compress_struct *cinfo)
+{
+}
+
+DLLEXPORT tjhandle DLLCALL tjInitCompress(void)
+{
+	jpgstruct *j=NULL;
+	if((j=(jpgstruct *)malloc(sizeof(jpgstruct)))==NULL)
+		{sprintf(lasterror, "Memory allocation failure");  return NULL;}
+	memset(j, 0, sizeof(jpgstruct));
+	j->cinfo.err=jpeg_std_error(&j->jerr.pub);
+	j->jerr.pub.error_exit=my_error_exit;
+	j->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(j->jerr.jb))
+	{ // this will execute if LIBJPEG has an error
+		if(j) free(j);  return NULL;
+	}
+
+	jpeg_create_compress(&j->cinfo);
+	j->cinfo.dest=&j->jdms;
+	j->jdms.init_destination=destination_noop;
+	j->jdms.empty_output_buffer=empty_output_buffer;
+	j->jdms.term_destination=destination_noop;
+
+	j->initc=1;
+	return (tjhandle)j;
+}
+
+
+DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height)
+{
+	unsigned long retval=0;
+	if(width<1 || height<1)
+		_throw("Invalid argument in TJBUFSIZE()");
+
+	// 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=((width+15)&(~15)) * ((height+15)&(~15)) * 6 + 2048;
+
+	bailout:
+	return retval;
+}
+
+
+DLLEXPORT int DLLCALL tjCompress(tjhandle h,
+	unsigned char *srcbuf, int width, int pitch, int height, int ps,
+	unsigned char *dstbuf, unsigned long *size,
+	int jpegsub, int qual, int flags)
+{
+	int i, retval=0;  JSAMPROW *row_pointer=NULL;
+
+	checkhandle(h);
+
+	if(srcbuf==NULL || width<=0 || pitch<0 || height<=0
+		|| dstbuf==NULL || size==NULL
+		|| jpegsub<0 || jpegsub>=NUMSUBOPT || qual<0 || qual>100)
+		_throw("Invalid argument in tjCompress()");
+	if(ps!=3 && ps!=4 && ps!=1)
+		_throw("This compressor can only handle 24-bit and 32-bit RGB or 8-bit grayscale input");
+	if(!j->initc) _throw("Instance has not been initialized for compression");
+
+	if(pitch==0) pitch=width*ps;
+
+	j->cinfo.image_width = width;
+	j->cinfo.image_height = height;
+	j->cinfo.input_components = ps;
+
+	if(ps==1) j->cinfo.in_color_space = JCS_GRAYSCALE;
+	#if JCS_EXTENSIONS==1
+	else j->cinfo.in_color_space = JCS_EXT_RGB;
+	if(ps==3 && (flags&TJ_BGR))
+		j->cinfo.in_color_space = JCS_EXT_BGR;
+	else if(ps==4 && !(flags&TJ_BGR) && !(flags&TJ_ALPHAFIRST))
+		j->cinfo.in_color_space = JCS_EXT_RGBX;
+	else if(ps==4 && (flags&TJ_BGR) && !(flags&TJ_ALPHAFIRST))
+		j->cinfo.in_color_space = JCS_EXT_BGRX;
+	else if(ps==4 && (flags&TJ_BGR) && (flags&TJ_ALPHAFIRST))
+		j->cinfo.in_color_space = JCS_EXT_XBGR;
+	else if(ps==4 && !(flags&TJ_BGR) && (flags&TJ_ALPHAFIRST))
+		j->cinfo.in_color_space = JCS_EXT_XRGB;
+	#else
+	#error "TurboJPEG requires JPEG colorspace extensions"
+	#endif
+
+	if(flags&TJ_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+	else if(flags&TJ_FORCESSE) putenv("JSIMD_FORCESSE=1");
+	else if(flags&TJ_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+
+	if(setjmp(j->jerr.jb))
+	{  // this will execute if LIBJPEG has an error
+		retval=-1;
+		goto bailout;
+	}
+
+	jpeg_set_defaults(&j->cinfo);
+
+	jpeg_set_quality(&j->cinfo, qual, TRUE);
+	if(jpegsub==TJ_GRAYSCALE)
+		jpeg_set_colorspace(&j->cinfo, JCS_GRAYSCALE);
+	else
+		jpeg_set_colorspace(&j->cinfo, JCS_YCbCr);
+	if(qual>=96) j->cinfo.dct_method=JDCT_ISLOW;
+	else j->cinfo.dct_method=JDCT_FASTEST;
+
+	j->cinfo.comp_info[0].h_samp_factor=hsampfactor[jpegsub];
+	j->cinfo.comp_info[1].h_samp_factor=1;
+	j->cinfo.comp_info[2].h_samp_factor=1;
+	j->cinfo.comp_info[0].v_samp_factor=vsampfactor[jpegsub];
+	j->cinfo.comp_info[1].v_samp_factor=1;
+	j->cinfo.comp_info[2].v_samp_factor=1;
+
+	j->jdms.next_output_byte = dstbuf;
+	j->jdms.free_in_buffer = TJBUFSIZE(j->cinfo.image_width, j->cinfo.image_height);
+
+	jpeg_start_compress(&j->cinfo, TRUE);
+	if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
+		_throw("Memory allocation failed in tjCompress()");
+	for(i=0; i<height; i++)
+	{
+		if(flags&TJ_BOTTOMUP) row_pointer[i]= &srcbuf[(height-i-1)*pitch];
+		else row_pointer[i]= &srcbuf[i*pitch];
+	}
+	while(j->cinfo.next_scanline<j->cinfo.image_height)
+	{
+		jpeg_write_scanlines(&j->cinfo, &row_pointer[j->cinfo.next_scanline],
+			j->cinfo.image_height-j->cinfo.next_scanline);
+	}
+	jpeg_finish_compress(&j->cinfo);
+	*size=TJBUFSIZE(j->cinfo.image_width, j->cinfo.image_height)
+		-(unsigned long)(j->jdms.free_in_buffer);
+
+	bailout:
+	if(j->cinfo.global_state>CSTATE_START) jpeg_abort_compress(&j->cinfo);
+	if(row_pointer) free(row_pointer);
+	return retval;
+}
+
+
+// DEC
+
+static boolean fill_input_buffer (struct jpeg_decompress_struct *dinfo)
+{
+	ERREXIT(dinfo, JERR_BUFFER_SIZE);
+	return TRUE;
+}
+
+static void skip_input_data (struct jpeg_decompress_struct *dinfo, long num_bytes)
+{
+	dinfo->src->next_input_byte += (size_t) num_bytes;
+	dinfo->src->bytes_in_buffer -= (size_t) num_bytes;
+}
+
+static void source_noop (struct jpeg_decompress_struct *dinfo)
+{
+}
+
+DLLEXPORT tjhandle DLLCALL tjInitDecompress(void)
+{
+	jpgstruct *j;
+	if((j=(jpgstruct *)malloc(sizeof(jpgstruct)))==NULL)
+		{sprintf(lasterror, "Memory allocation failure");  return NULL;}
+	memset(j, 0, sizeof(jpgstruct));
+	j->dinfo.err=jpeg_std_error(&j->jerr.pub);
+	j->jerr.pub.error_exit=my_error_exit;
+	j->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(j->jerr.jb))
+	{ // this will execute if LIBJPEG has an error
+		free(j);  return NULL;
+	}
+
+	jpeg_create_decompress(&j->dinfo);
+	j->dinfo.src=&j->jsms;
+	j->jsms.init_source=source_noop;
+	j->jsms.fill_input_buffer = fill_input_buffer;
+	j->jsms.skip_input_data = skip_input_data;
+	j->jsms.resync_to_restart = jpeg_resync_to_restart;
+	j->jsms.term_source = source_noop;
+
+	j->initd=1;
+	return (tjhandle)j;
+}
+
+
+DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle h,
+	unsigned char *srcbuf, unsigned long size,
+	int *width, int *height, int *jpegsub)
+{
+	int i, k, retval=0;
+
+	checkhandle(h);
+
+	if(srcbuf==NULL || size<=0 || width==NULL || height==NULL || jpegsub==NULL)
+		_throw("Invalid argument in tjDecompressHeader2()");
+	if(!j->initd) _throw("Instance has not been initialized for decompression");
+
+	if(setjmp(j->jerr.jb))
+	{  // this will execute if LIBJPEG has an error
+		return -1;
+	}
+
+	j->jsms.bytes_in_buffer = size;
+	j->jsms.next_input_byte = srcbuf;
+
+	jpeg_read_header(&j->dinfo, TRUE);
+
+	*width=j->dinfo.image_width;  *height=j->dinfo.image_height;
+	*jpegsub=-1;
+	for(i=0; i<NUMSUBOPT; i++)
+	{
+		if(j->dinfo.num_components==pixelsize[i])
+		{
+			if(j->dinfo.comp_info[0].h_samp_factor==hsampfactor[i]
+				&& j->dinfo.comp_info[0].v_samp_factor==vsampfactor[i])
+			{
+				int match=0;
+				for(k=1; k<j->dinfo.num_components; k++)
+				{
+					if(j->dinfo.comp_info[k].h_samp_factor==1
+						&& j->dinfo.comp_info[k].v_samp_factor==1)
+						match++;
+				}
+				if(match==j->dinfo.num_components-1)
+				{
+					*jpegsub=i;  break;
+				}
+			}
+		}
+	}
+
+	jpeg_abort_decompress(&j->dinfo);
+
+	if(*jpegsub<0) _throw("Could not determine subsampling type for JPEG image");
+	if(*width<1 || *height<1) _throw("Invalid data returned in header");
+
+	bailout:
+	return retval;
+}
+
+
+DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle h,
+	unsigned char *srcbuf, unsigned long size,
+	int *width, int *height)
+{
+	int jpegsub;
+	return tjDecompressHeader2(h, srcbuf, size, width, height, &jpegsub);
+}
+
+
+DLLEXPORT int DLLCALL tjDecompress(tjhandle h,
+	unsigned char *srcbuf, unsigned long size,
+	unsigned char *dstbuf, int width, int pitch, int height, int ps,
+	int flags)
+{
+	int i, retval=0;  JSAMPROW *row_pointer=NULL;
+
+	checkhandle(h);
+
+	if(srcbuf==NULL || size<=0
+		|| dstbuf==NULL || width<=0 || pitch<0 || height<=0)
+		_throw("Invalid argument in tjDecompress()");
+	if(ps!=3 && ps!=4 && ps!=1)
+		_throw("This decompressor can only handle 24-bit and 32-bit RGB or 8-bit grayscale output");
+	if(!j->initd) _throw("Instance has not been initialized for decompression");
+
+	if(pitch==0) pitch=width*ps;
+
+	if(flags&TJ_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+	else if(flags&TJ_FORCESSE) putenv("JSIMD_FORCESSE=1");
+	else if(flags&TJ_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
+
+	if(setjmp(j->jerr.jb))
+	{  // this will execute if LIBJPEG has an error
+		retval=-1;
+		goto bailout;
+	}
+
+	j->jsms.bytes_in_buffer = size;
+	j->jsms.next_input_byte = srcbuf;
+
+	jpeg_read_header(&j->dinfo, TRUE);
+
+	if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
+		_throw("Memory allocation failed in tjDecompress()");
+	for(i=0; i<height; i++)
+	{
+		if(flags&TJ_BOTTOMUP) row_pointer[i]= &dstbuf[(height-i-1)*pitch];
+		else row_pointer[i]= &dstbuf[i*pitch];
+	}
+
+	if(ps==1) j->dinfo.out_color_space = JCS_GRAYSCALE;
+	#if JCS_EXTENSIONS==1
+	else j->dinfo.out_color_space = JCS_EXT_RGB;
+	if(ps==3 && (flags&TJ_BGR))
+		j->dinfo.out_color_space = JCS_EXT_BGR;
+	else if(ps==4 && !(flags&TJ_BGR) && !(flags&TJ_ALPHAFIRST))
+		j->dinfo.out_color_space = JCS_EXT_RGBX;
+	else if(ps==4 && (flags&TJ_BGR) && !(flags&TJ_ALPHAFIRST))
+		j->dinfo.out_color_space = JCS_EXT_BGRX;
+	else if(ps==4 && (flags&TJ_BGR) && (flags&TJ_ALPHAFIRST))
+		j->dinfo.out_color_space = JCS_EXT_XBGR;
+	else if(ps==4 && !(flags&TJ_BGR) && (flags&TJ_ALPHAFIRST))
+		j->dinfo.out_color_space = JCS_EXT_XRGB;
+	#else
+	#error "TurboJPEG requires JPEG colorspace extensions"
+	#endif
+
+	if(flags&TJ_FASTUPSAMPLE) j->dinfo.do_fancy_upsampling=FALSE;
+
+	jpeg_start_decompress(&j->dinfo);
+	while(j->dinfo.output_scanline<j->dinfo.output_height)
+	{
+		jpeg_read_scanlines(&j->dinfo, &row_pointer[j->dinfo.output_scanline],
+			j->dinfo.output_height-j->dinfo.output_scanline);
+	}
+	jpeg_finish_decompress(&j->dinfo);
+
+	bailout:
+	if(j->dinfo.global_state>DSTATE_START) jpeg_abort_decompress(&j->dinfo);
+	if(row_pointer) free(row_pointer);
+	return retval;
+}
+
+
+// General
+
+DLLEXPORT char* DLLCALL tjGetErrorStr(void)
+{
+	return lasterror;
+}
+
+DLLEXPORT int DLLCALL tjDestroy(tjhandle h)
+{
+	checkhandle(h);
+	if(setjmp(j->jerr.jb)) return -1;
+	if(j->initc) jpeg_destroy_compress(&j->cinfo);
+	if(j->initd) jpeg_destroy_decompress(&j->dinfo);
+	free(j);
+	return 0;
+}
diff --git a/common/turbojpeg.h b/common/turbojpeg.h
new file mode 100644
index 0000000..6e3e259
--- /dev/null
+++ b/common/turbojpeg.h
@@ -0,0 +1,255 @@
+/* Copyright (C)2004 Landmark Graphics Corporation
+ * Copyright (C)2005, 2006 Sun Microsystems, Inc.
+ * Copyright (C)2009-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.
+ */
+
+#if (defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__)) \
+	&& defined(_WIN32) && defined(DLLDEFINE)
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
+#define DLLCALL
+
+
+/* Subsampling */
+#define NUMSUBOPT 4
+
+enum {TJ_444=0, TJ_422, TJ_420, TJ_GRAYSCALE};
+#define TJ_411 TJ_420  /* for backward compatibility with VirtualGL <= 2.1.x,
+                          TurboVNC <= 0.6, and TurboJPEG/IPP */
+
+
+/* Flags */
+#define TJ_BGR             1
+  /* The components of each pixel in the source/destination bitmap are stored
+     in B,G,R order, not R,G,B */
+#define TJ_BOTTOMUP        2
+  /* The source/destination bitmap is stored in bottom-up (Windows, OpenGL)
+     order, not top-down (X11) order */
+#define TJ_FORCEMMX        8
+  /* Turn off CPU auto-detection and force TurboJPEG to use MMX code
+     (IPP and 32-bit libjpeg-turbo versions only) */
+#define TJ_FORCESSE       16
+  /* Turn off CPU auto-detection and force TurboJPEG to use SSE code
+     (32-bit IPP and 32-bit libjpeg-turbo versions only) */
+#define TJ_FORCESSE2      32
+  /* Turn off CPU auto-detection and force TurboJPEG to use SSE2 code
+     (32-bit IPP and 32-bit libjpeg-turbo versions only) */
+#define TJ_ALPHAFIRST     64
+  /* If the source/destination bitmap is 32 bpp, assume that each pixel is
+     ARGB/XRGB (or ABGR/XBGR if TJ_BGR is also specified) */
+#define TJ_FORCESSE3     128
+  /* Turn off CPU auto-detection and force TurboJPEG to use SSE3 code
+     (64-bit IPP version only) */
+#define TJ_FASTUPSAMPLE  256
+  /* Use fast, inaccurate 4:2:2 and 4:2:0 YUV upsampling routines
+     (libjpeg and libjpeg-turbo versions only) */
+
+
+typedef void* tjhandle;
+
+#define TJPAD(p) (((p)+3)&(~3))
+#ifndef max
+ #define max(a,b) ((a)>(b)?(a):(b))
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* API follows */
+
+
+/*
+  tjhandle tjInitCompress(void)
+
+  Creates a new JPEG compressor instance, allocates memory for the structures,
+  and returns a handle to the instance.  Most applications will only
+  need to call this once at the beginning of the program or once for each
+  concurrent thread.  Don't try to create a new instance every time you
+  compress an image, because this may cause performance to suffer in some
+  TurboJPEG implementations.
+
+  RETURNS: NULL on error
+*/
+DLLEXPORT tjhandle DLLCALL tjInitCompress(void);
+
+
+/*
+  int tjCompress(tjhandle j,
+     unsigned char *srcbuf, int width, int pitch, int height, int pixelsize,
+     unsigned char *dstbuf, unsigned long *size,
+     int jpegsubsamp, int jpegqual, int flags)
+
+  [INPUT] j = instance handle previously returned from a call to
+     tjInitCompress()
+  [INPUT] srcbuf = pointer to user-allocated image buffer containing RGB or
+     grayscale pixels to be compressed
+  [INPUT] width = width (in pixels) of the source image
+  [INPUT] pitch = bytes per line of the source image (width*pixelsize if the
+     bitmap is unpadded, else TJPAD(width*pixelsize) if each line of the bitmap
+     is padded to the nearest 32-bit boundary, such 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
+     width*pixelsize.
+  [INPUT] height = height (in pixels) of the source image
+  [INPUT] pixelsize = size (in bytes) of each pixel in the source image
+     RGBX/BGRX/XRGB/XBGR: 4, RGB/BGR: 3, Grayscale: 1
+  [INPUT] dstbuf = pointer to user-allocated image buffer that will receive
+     the JPEG image.  Use the TJBUFSIZE(width, height) function to determine
+     the appropriate size for this buffer based on the image width and height.
+  [OUTPUT] size = pointer to unsigned long that receives the size (in bytes)
+     of the compressed image
+  [INPUT] jpegsubsamp = Specifies either 4:2:0, 4:2:2, 4:4:4, or grayscale
+     subsampling.  When the image is converted from the RGB to YCbCr colorspace
+     as part of the JPEG compression process, every other Cb and Cr
+     (chrominance) pixel can be discarded 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.)
+
+     TJ_420: 4:2:0 subsampling.  Discards every other Cb, Cr pixel in both
+        horizontal and vertical directions
+     TJ_422: 4:2:2 subsampling.  Discards every other Cb, Cr pixel only in
+        the horizontal direction
+     TJ_444: no subsampling
+     TJ_GRAYSCALE: Generate grayscale JPEG image
+
+  [INPUT] jpegqual = JPEG quality (an integer between 0 and 100 inclusive)
+  [INPUT] flags = the bitwise OR of one or more of the flags described in the
+     "Flags" section above
+
+  RETURNS: 0 on success, -1 on error
+*/
+DLLEXPORT int DLLCALL tjCompress(tjhandle j,
+	unsigned char *srcbuf, int width, int pitch, int height, int pixelsize,
+	unsigned char *dstbuf, unsigned long *size,
+	int jpegsubsamp, int jpegqual, int flags);
+
+
+/*
+  unsigned long TJBUFSIZE(int width, int height)
+
+  Convenience function that returns the maximum size of the buffer required to
+  hold a JPEG image with the given width and height
+
+  RETURNS: -1 if arguments are out of bounds
+*/
+DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height);
+
+
+/*
+  tjhandle tjInitDecompress(void)
+
+  Creates a new JPEG decompressor instance, allocates memory for the
+  structures, and returns a handle to the instance.  Most applications will
+  only need to call this once at the beginning of the program or once for each
+  concurrent thread.  Don't try to create a new instance every time you
+  decompress an image, because this may cause performance to suffer in some
+  TurboJPEG implementations.
+
+  RETURNS: NULL on error
+*/
+DLLEXPORT tjhandle DLLCALL tjInitDecompress(void);
+
+
+/*
+  int tjDecompressHeader2(tjhandle j,
+     unsigned char *srcbuf, unsigned long size,
+     int *width, int *height, int *jpegsubsamp)
+
+  [INPUT] j = instance handle previously returned from a call to
+     tjInitDecompress()
+  [INPUT] srcbuf = pointer to a user-allocated buffer containing a JPEG image
+  [INPUT] size = size of the JPEG image buffer (in bytes)
+  [OUTPUT] width = width (in pixels) of the JPEG image
+  [OUTPUT] height = height (in pixels) of the JPEG image
+  [OUTPUT] jpegsubsamp = type of chrominance subsampling used when compressing
+     the JPEG image
+
+  RETURNS: 0 on success, -1 on error
+*/
+DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle j,
+	unsigned char *srcbuf, unsigned long size,
+	int *width, int *height, int *jpegsubsamp);
+
+/*
+  Legacy version of the above function
+*/
+DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle j,
+	unsigned char *srcbuf, unsigned long size,
+	int *width, int *height);
+
+
+/*
+  int tjDecompress(tjhandle j,
+     unsigned char *srcbuf, unsigned long size,
+     unsigned char *dstbuf, int width, int pitch, int height, int pixelsize,
+     int flags)
+
+  [INPUT] j = instance handle previously returned from a call to
+     tjInitDecompress()
+  [INPUT] srcbuf = pointer to a user-allocated buffer containing the JPEG image
+     to decompress
+  [INPUT] size = size of the JPEG image buffer (in bytes)
+  [INPUT] dstbuf = pointer to user-allocated image buffer that will receive
+     the bitmap image.  This buffer should normally be pitch*height
+     bytes in size, although this pointer may also be used to decompress into
+     a specific region of a larger buffer.
+  [INPUT] width = width (in pixels) of the destination image
+  [INPUT] pitch = bytes per line of the destination image (width*pixelsize if
+     the bitmap is unpadded, else TJPAD(width*pixelsize) if each line of the
+     bitmap is padded to the nearest 32-bit boundary, such 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 width*pixelsize.
+  [INPUT] height = height (in pixels) of the destination image
+  [INPUT] pixelsize = size (in bytes) of each pixel in the destination image
+     RGBX/BGRX/XRGB/XBGR: 4, RGB/BGR: 3, Grayscale: 1
+  [INPUT] flags = the bitwise OR of one or more of the flags described in the
+     "Flags" section above.
+
+  RETURNS: 0 on success, -1 on error
+*/
+DLLEXPORT int DLLCALL tjDecompress(tjhandle j,
+	unsigned char *srcbuf, unsigned long size,
+	unsigned char *dstbuf, int width, int pitch, int height, int pixelsize,
+	int flags);
+
+
+/*
+  int tjDestroy(tjhandle h)
+
+  Frees structures associated with a compression or decompression instance
+  
+  [INPUT] h = instance handle (returned from a previous call to
+     tjInitCompress() or tjInitDecompress()
+
+  RETURNS: 0 on success, -1 on error
+*/
+DLLEXPORT int DLLCALL tjDestroy(tjhandle h);
+
+
+/*
+  char *tjGetErrorStr(void)
+  
+  Returns a descriptive error message explaining why the last command failed
+*/
+DLLEXPORT char* DLLCALL tjGetErrorStr(void);
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/configure.ac b/configure.ac
index c5578fa..211cad6 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,15 +577,67 @@ 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
 fi
 
+AC_ARG_WITH(turbovnc,
+[  --with-turbovnc         use TurboVNC encoder instead of TightVNC encoder],,)
+
+AC_MSG_CHECKING(whether to enable TurboVNC encoder)
+if test "x$with_turbovnc" = "xyes"; then
+	if test "x$HAVE_LIBJPEG_TURBO" != "xtrue"; then
+		AC_MSG_ERROR([
+==========================================================================
+*** The TurboVNC encoder requires libjpeg-turbo, which was not detected.
+You can obtain libjpeg-turbo from:
+https://sourceforge.net/projects/libjpeg-turbo/files/
+Optionally, you can pass --without-turbovnc to configure to use the
+TightVNC encoder instead. ***
+==========================================================================
+])
+	fi
+	AC_DEFINE(HAVE_TURBOVNC, 1, TurboVNC support enabled)
+	AC_MSG_RESULT(yes)
+else
+	AC_MSG_RESULT(no)
+fi
+
+AM_CONDITIONAL(HAVE_TURBOVNC, test "x$with_turbovnc" = "xyes" )
+
 AC_ARG_WITH(png,
 [  --without-png           disable support for png]
 [  --with-png=DIR          use png include/library files in DIR],,)
@@ -582,7 +648,7 @@ AC_ARG_WITH(png,
 #	-without-png              with_png="no"
 #	-with-png=/foo/dir        with_png="/foo/dir"
 
-if test "x$with_png" != "xno"; then
+if test "x$with_png" != "xno" -a "x$with_turbovnc" != "xyes"; then
 	if test ! -z "$with_png" -a "x$with_png" != "xyes"; then
 		# add user supplied directory to flags:
 		saved_CPPFLAGS="$CPPFLAGS"
diff --git a/libvncserver/Makefile.am b/libvncserver/Makefile.am
index fce398d..6a29b84 100644
--- a/libvncserver/Makefile.am
+++ b/libvncserver/Makefile.am
@@ -46,9 +46,13 @@ 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
+if HAVE_TURBOVNC
+TIGHTSRCS = turbo.c ../common/turbojpeg.c
+else
 TIGHTSRCS = tight.c
 endif
 endif
+endif
 
 LIB_SRCS = main.c rfbserver.c rfbregion.c auth.c sockets.c $(WEBSOCKETSSRCS) \
 	stats.c corre.c hextile.c rre.c translate.c cutpaste.c \
diff --git a/libvncserver/rfbserver.c b/libvncserver/rfbserver.c
index 9be255f..04231f2 100644
--- a/libvncserver/rfbserver.c
+++ b/libvncserver/rfbserver.c
@@ -3,6 +3,7 @@
  */
 
 /*
+ *  Copyright (C) 2011 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>.
@@ -85,6 +86,21 @@ static int compat_mkdir(const char *path, int mode)
 #define mkdir compat_mkdir
 #endif
 
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+/*
+ * Map of quality levels to provide compatibility with TightVNC/TigerVNC
+ * clients
+ */
+
+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);
@@ -367,6 +383,9 @@ rfbNewTCPOrUDPClient(rfbScreenInfoPtr rfbScreen,
 #if defined(LIBVNCSERVER_HAVE_LIBJPEG) || defined(LIBVNCSERVER_HAVE_LIBPNG)
       cl->tightCompressLevel = TIGHT_DEFAULT_COMPRESSION;
 #endif
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+      cl->tightSubsampLevel = TIGHT_DEFAULT_SUBSAMP;
+#endif
 #ifdef LIBVNCSERVER_HAVE_LIBJPEG
       {
 	int i;
@@ -2077,11 +2096,30 @@ rfbProcessClientNormalMessage(rfbClientPtr cl)
 		    rfbLog("Using compression level %d for client %s\n",
 			   cl->tightCompressLevel, cl->host);
 #endif
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+		} else if ( enc >= (uint32_t)rfbEncodingSubsamp1X &&
+			    enc <= (uint32_t)rfbEncodingSubsampGray ) {
+		    cl->tightSubsampLevel = enc & 0xFF;
+		    rfbLog("Using JPEG subsampling %d for client %s\n",
+			   cl->tightSubsampLevel, cl->host);
+		} else if ( enc >= (uint32_t)rfbEncodingQualityLevel0 &&
+			    enc <= (uint32_t)rfbEncodingQualityLevel9 ) {
+		    cl->tightQualityLevel = tight2turbo_qual[enc & 0x0F];
+		    cl->tightSubsampLevel = tight2turbo_subsamp[enc & 0x0F];
+		    rfbLog("Using JPEG subsampling %d, Q%d for client %s\n",
+			   cl->tightSubsampLevel, cl->tightQualityLevel, cl->host);
+		} else if ( enc >= (uint32_t)rfbEncodingFineQualityLevel0 + 1 &&
+			    enc <= (uint32_t)rfbEncodingFineQualityLevel100 ) {
+		    cl->tightQualityLevel = enc & 0xFF;
+		    rfbLog("Using image quality level %d for client %s\n",
+			   cl->tightQualityLevel, cl->host);
+#else
 		} else if ( enc >= (uint32_t)rfbEncodingQualityLevel0 &&
 			    enc <= (uint32_t)rfbEncodingQualityLevel9 ) {
 		    cl->tightQualityLevel = enc & 0x0F;
 		    rfbLog("Using image quality level %d for client %s\n",
 			   cl->tightQualityLevel, cl->host);
+#endif
 		} else
 #endif
 		{
diff --git a/libvncserver/turbo.c b/libvncserver/turbo.c
new file mode 100644
index 0000000..f205b6d
--- /dev/null
+++ b/libvncserver/turbo.c
@@ -0,0 +1,1566 @@
+/*
+ * turbo.c
+ *
+ * Routines to implement TurboVNC Encoding
+ */
+
+/*
+ *  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.
+ *
+ *  This is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This software 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
+ *  GNU General Public License for more details.
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ *  USA.
+ */
+
+#include <rfb/rfb.h>
+#include "private.h"
+
+#include "turbojpeg.h"
+
+
+/* Note: The following constant should not be changed. */
+#define TIGHT_MIN_TO_COMPRESS 12
+
+/* The parameters below may be adjusted. */
+#define MIN_SPLIT_RECT_SIZE     4096
+#define MIN_SOLID_SUBRECT_SIZE  2048
+#define MAX_SPLIT_TILE_SIZE       16
+
+/*
+ * There is so much access of the Tight encoding static data buffers
+ * that we resort to using thread local storage instead of having
+ * per-client data.
+ */
+#if LIBVNCSERVER_HAVE_LIBPTHREAD && LIBVNCSERVER_HAVE_TLS && !defined(TLS) && defined(__linux__)
+#define TLS __thread
+#endif
+#ifndef TLS
+#define TLS
+#endif
+
+/* 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;
+    int idxZlibLevel, monoZlibLevel, rawZlibLevel;
+    int idxMaxColorsDivisor;
+    int palMaxColorsWithJPEG;
+} TIGHT_CONF;
+
+static TIGHT_CONF tightConf[3] = {
+    { 65536, 2048,   6, 0, 0, 0,   4, 24 },
+    { 65536, 2048,  32, 1, 1, 1,  96, 24 },
+    { 65536, 2048,  32, 3, 3, 2,  96, 96 }
+};
+
+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. */
+
+typedef struct COLOR_LIST_s {
+    struct COLOR_LIST_s *next;
+    int idx;
+    uint32_t rgb;
+} COLOR_LIST;
+
+typedef struct PALETTE_ENTRY_s {
+    COLOR_LIST *listNode;
+    int numPixels;
+} PALETTE_ENTRY;
+
+typedef struct PALETTE_s {
+    PALETTE_ENTRY entry[256];
+    COLOR_LIST *hash[256];
+    COLOR_LIST list[256];
+} PALETTE;
+
+/* TODO: move into rfbScreen struct */
+static TLS int paletteNumColors = 0;
+static TLS int paletteMaxColors = 0;
+static TLS uint32_t monoBackground = 0;
+static TLS uint32_t monoForeground = 0;
+static TLS PALETTE palette;
+
+/* Pointers to dynamically-allocated buffers. */
+
+static TLS int tightBeforeBufSize = 0;
+static TLS char *tightBeforeBuf = NULL;
+
+static TLS int tightAfterBufSize = 0;
+static TLS char *tightAfterBuf = NULL;
+
+static TLS tjhandle j = NULL;
+
+void rfbTightCleanup (rfbScreenInfoPtr screen)
+{
+    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 void FindBestSolidArea (rfbClientPtr cl, int x, int y, int w, int h,
+                               uint32_t colorValue, int *w_ptr, int *h_ptr);
+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);
+static rfbBool CheckSolidTile8   (rfbClientPtr cl, int x, int y, int w, int h,
+                                  uint32_t *colorPtr, rfbBool needSameColor);
+static rfbBool CheckSolidTile16  (rfbClientPtr cl, int x, int y, int w, int h,
+                                  uint32_t *colorPtr, rfbBool needSameColor);
+static rfbBool CheckSolidTile32  (rfbClientPtr cl, int x, int y, int w, int h,
+                                  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);
+static rfbBool SendTightHeader   (rfbClientPtr cl, int x, int y, int w, int h);
+
+static rfbBool SendSolidRect     (rfbClientPtr cl);
+static rfbBool SendMonoRect      (rfbClientPtr cl, int w, int h);
+static rfbBool SendIndexedRect   (rfbClientPtr cl, int w, int h);
+static rfbBool SendFullColorRect (rfbClientPtr cl, int w, int h);
+
+static rfbBool CompressData (rfbClientPtr cl, int streamId, int dataLen,
+                             int zlibLevel, int zlibStrategy);
+static rfbBool SendCompressedData (rfbClientPtr cl, char *buf,
+                                   int compressedLen);
+
+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 PaletteReset (void);
+static int PaletteInsert (uint32_t rgb, int numPixels, int bpp);
+
+static void Pack24 (rfbClientPtr cl, char *buf, rfbPixelFormat *fmt,
+                    int count);
+
+static void EncodeIndexedRect16 (uint8_t *buf, int count);
+static void EncodeIndexedRect32 (uint8_t *buf, int count);
+
+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);
+
+/*
+ * Tight encoding implementation.
+ */
+
+int
+rfbNumCodedRectsTight(rfbClientPtr cl,
+                      int x,
+                      int y,
+                      int w,
+                      int h)
+{
+    int maxRectSize, maxRectWidth;
+    int subrectMaxWidth, subrectMaxHeight;
+
+    /* 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;
+
+    maxRectSize = tightConf[compressLevel].maxRectSize;
+    maxRectWidth = tightConf[compressLevel].maxRectWidth;
+
+    if (w > maxRectWidth || w * h > maxRectSize) {
+        subrectMaxWidth = (w > maxRectWidth) ? maxRectWidth : w;
+        subrectMaxHeight = maxRectSize / subrectMaxWidth;
+        return (((w - 1) / maxRectWidth + 1) *
+                ((h - 1) / subrectMaxHeight + 1));
+    } else {
+        return 1;
+    }
+}
+
+rfbBool
+rfbSendRectEncodingTight(rfbClientPtr cl,
+                         int x,
+                         int y,
+                         int w,
+                         int h)
+{
+    int nMaxRows;
+    uint32_t colorValue;
+    int dx, dy, dw, dh;
+    int x_best, y_best, w_best, h_best;
+    char *fbptr;
+
+    rfbSendUpdateBuf(cl);
+
+    compressLevel = cl->tightCompressLevel;
+    qualityLevel = cl->tightQualityLevel;
+    subsampLevel = cl->tightSubsampLevel;
+
+    /* 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.")  CL 2 is a mixed bag.
+       It can be shown to reduce bandwidth (and commensurately increase CPU
+       usage) by typically 30-40% relative to CL 1, but only when it is used in
+       conjunction with high-quality JPEG, and only on workloads that have low
+       numbers of unique colors.  Increasing the amount of Zlib compression
+       beyond CL 2 cannot be shown to provide any significant bandwidth savings
+       except in very rare corner cases that are not performance-critical to
+       begin with, and higher Zlib levels increase CPU usage exponentially. */
+    if (qualityLevel != -1) {
+        if (compressLevel < 1) compressLevel = 1;
+        if (compressLevel > 2) compressLevel = 2;
+    }
+
+    /* With JPEG disabled, increasing the Zlib compression level beyond CL 1
+       offers no significant bandwidth savings, and the CPU usage starts to
+       increase exponentially. */
+    else if (compressLevel > 1) compressLevel = 1;
+
+    if ( cl->format.depth == 24 && cl->format.redMax == 0xFF &&
+         cl->format.greenMax == 0xFF && cl->format.blueMax == 0xFF ) {
+        usePixelFormat24 = TRUE;
+    } else {
+        usePixelFormat24 = FALSE;
+    }
+
+    if (!cl->enableLastRectEncoding || w * h < MIN_SPLIT_RECT_SIZE)
+        return SendRectSimple(cl, x, y, w, h);
+
+    /* Make sure we can write at least one pixel into tightBeforeBuf. */
+
+    if (tightBeforeBufSize < 4) {
+        tightBeforeBufSize = 4;
+        if (tightBeforeBuf == NULL)
+            tightBeforeBuf = (char *)malloc(tightBeforeBufSize);
+        else
+            tightBeforeBuf = (char *)realloc(tightBeforeBuf,
+                                             tightBeforeBufSize);
+    }
+
+    /* Calculate maximum number of rows in one non-solid rectangle. */
+
+    {
+        int maxRectSize, maxRectWidth, nMaxWidth;
+
+        maxRectSize = tightConf[compressLevel].maxRectSize;
+        maxRectWidth = tightConf[compressLevel].maxRectWidth;
+        nMaxWidth = (w > maxRectWidth) ? maxRectWidth : w;
+        nMaxRows = maxRectSize / nMaxWidth;
+    }
+
+    /* Try to find large solid-color areas and send them separately. */
+
+    for (dy = y; dy < y + h; dy += MAX_SPLIT_TILE_SIZE) {
+
+        /* If a rectangle becomes too large, send its upper part now. */
+
+        if (dy - y >= nMaxRows) {
+            if (!SendRectSimple(cl, x, y, w, nMaxRows))
+                return 0;
+            y += nMaxRows;
+            h -= nMaxRows;
+        }
+
+        dh = (dy + MAX_SPLIT_TILE_SIZE <= y + h) ?
+             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);
+
+            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),
+				  colorValue, &w_best, &h_best);
+
+                /* Make sure a solid rectangle is large enough
+                   (or the whole rectangle is of the same color). */
+
+                if ( w_best * h_best != w * h &&
+                     w_best * h_best < MIN_SOLID_SUBRECT_SIZE )
+                    continue;
+
+                /* Try to extend solid rectangle to maximum size. */
+
+                x_best = dx; y_best = dy;
+                ExtendSolidArea(cl, x, y, w, h, colorValue,
+                                &x_best, &y_best, &w_best, &h_best);
+
+                /* Send rectangles at top and left to solid-color area. */
+
+                if ( y_best != y &&
+                     !SendRectSimple(cl, x, y, w, y_best-y) )
+                    return FALSE;
+                if ( x_best != x &&
+                     !rfbSendRectEncodingTight(cl, x, y_best,
+                                               x_best-x, h_best) )
+                    return FALSE;
+
+                /* Send solid-color rectangle. */
+
+                if (!SendTightHeader(cl, x_best, y_best, w_best, h_best))
+                    return FALSE;
+
+                fbptr = (cl->scaledScreen->frameBuffer +
+                         (cl->scaledScreen->paddedWidthInBytes * y_best) +
+                         (x_best * (cl->scaledScreen->bitsPerPixel / 8)));
+
+                (*cl->translateFn)(cl->translateLookupTable, &cl->screen->serverFormat,
+                                   &cl->format, fbptr, tightBeforeBuf,
+                                   cl->scaledScreen->paddedWidthInBytes, 1, 1);
+
+                if (!SendSolidRect(cl))
+                    return FALSE;
+
+                /* Send remaining rectangles (at right and bottom). */
+
+                if ( x_best + w_best != x + w &&
+                     !rfbSendRectEncodingTight(cl, x_best + w_best, y_best,
+                                               w - (x_best-x) - w_best, h_best) )
+                    return FALSE;
+                if ( y_best + h_best != y + h &&
+                     !rfbSendRectEncodingTight(cl, x, y_best + h_best,
+                                               w, h - (y_best-y) - h_best) )
+                    return FALSE;
+
+                /* Return after all recursive calls are done. */
+
+                return TRUE;
+            }
+
+        }
+
+    }
+
+    /* No suitable solid-color rectangles found. */
+
+    return SendRectSimple(cl, x, y, w, h);
+}
+
+
+static void
+FindBestSolidArea(rfbClientPtr cl,
+                  int x,
+                  int y,
+                  int w,
+                  int h,
+                  uint32_t colorValue,
+                  int *w_ptr,
+                  int *h_ptr)
+{
+    int dx, dy, dw, dh;
+    int w_prev;
+    int w_best = 0, h_best = 0;
+
+    w_prev = w;
+
+    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);
+        dw = (w_prev > MAX_SPLIT_TILE_SIZE) ?
+             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);
+            if (!CheckSolidTile(cl, dx, dy, dw, dh, &colorValue, TRUE))
+                break;
+	    dx += dw;
+        }
+
+        w_prev = dx - x;
+        if (w_prev * (dy + dh - y) > w_best * h_best) {
+            w_best = w_prev;
+            h_best = dy + dh - y;
+        }
+    }
+
+    *w_ptr = w_best;
+    *h_ptr = h_best;
+}
+
+
+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)
+{
+    int cx, cy;
+
+    /* Try to extend the area upwards. */
+    for ( cy = *y_ptr - 1;
+          cy >= y && CheckSolidTile(cl, *x_ptr, cy, *w_ptr, 1, &colorValue, TRUE);
+          cy-- );
+    *h_ptr += *y_ptr - (cy + 1);
+    *y_ptr = cy + 1;
+
+    /* ... downwards. */
+    for ( cy = *y_ptr + *h_ptr;
+          cy < y + h &&
+              CheckSolidTile(cl, *x_ptr, cy, *w_ptr, 1, &colorValue, TRUE);
+          cy++ );
+    *h_ptr += cy - (*y_ptr + *h_ptr);
+
+    /* ... to the left. */
+    for ( cx = *x_ptr - 1;
+          cx >= x && CheckSolidTile(cl, cx, *y_ptr, 1, *h_ptr, &colorValue, TRUE);
+          cx-- );
+    *w_ptr += *x_ptr - (cx + 1);
+    *x_ptr = cx + 1;
+
+    /* ... to the right. */
+    for ( cx = *x_ptr + *w_ptr;
+          cx < x + w &&
+              CheckSolidTile(cl, cx, *y_ptr, 1, *h_ptr, &colorValue, TRUE);
+          cx++ );
+    *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
+ * *colorPtr value. The result is 1 if the test is successfull, and in
+ * that case new color will be stored in *colorPtr.
+ */
+
+static rfbBool CheckSolidTile(rfbClientPtr cl, int x, int y, int w, int h, uint32_t* colorPtr, rfbBool needSameColor)
+{
+    switch(cl->screen->serverFormat.bitsPerPixel) {
+    case 32:
+        return CheckSolidTile32(cl, x, y, w, h, colorPtr, needSameColor);
+    case 16:
+        return CheckSolidTile16(cl, x, y, w, h, colorPtr, needSameColor);
+    default:
+        return CheckSolidTile8(cl, x, y, w, h, colorPtr, needSameColor);
+    }
+}
+
+
+#define DEFINE_CHECK_SOLID_FUNCTION(bpp)                                      \
+                                                                              \
+static rfbBool                                                                \
+CheckSolidTile##bpp(rfbClientPtr cl, int x, int y, int w, int h,              \
+		uint32_t* colorPtr, rfbBool needSameColor)                    \
+{                                                                             \
+    uint##bpp##_t *fbptr;                                                     \
+    uint##bpp##_t colorValue;                                                 \
+    int dx, dy;                                                               \
+                                                                              \
+    fbptr = (uint##bpp##_t *)&cl->scaledScreen->frameBuffer                   \
+        [y * cl->scaledScreen->paddedWidthInBytes + x * (bpp/8)];             \
+                                                                              \
+    colorValue = *fbptr;                                                      \
+    if (needSameColor && (uint32_t)colorValue != *colorPtr)                   \
+        return FALSE;                                                         \
+                                                                              \
+    for (dy = 0; dy < h; dy++) {                                              \
+        for (dx = 0; dx < w; dx++) {                                          \
+            if (colorValue != fbptr[dx])                                      \
+                return FALSE;                                                 \
+        }                                                                     \
+        fbptr = (uint##bpp##_t *)((uint8_t *)fbptr                            \
+                 + cl->scaledScreen->paddedWidthInBytes);                     \
+    }                                                                         \
+                                                                              \
+    *colorPtr = (uint32_t)colorValue;                                         \
+    return TRUE;                                                              \
+}
+
+DEFINE_CHECK_SOLID_FUNCTION(8)
+DEFINE_CHECK_SOLID_FUNCTION(16)
+DEFINE_CHECK_SOLID_FUNCTION(32)
+
+static rfbBool
+SendRectSimple(rfbClientPtr cl, int x, int y, int w, int h)
+{
+    int maxBeforeSize, maxAfterSize;
+    int maxRectSize, maxRectWidth;
+    int subrectMaxWidth, subrectMaxHeight;
+    int dx, dy;
+    int rw, rh;
+
+    maxRectSize = tightConf[compressLevel].maxRectSize;
+    maxRectWidth = tightConf[compressLevel].maxRectWidth;
+
+    maxBeforeSize = maxRectSize * (cl->format.bitsPerPixel / 8);
+    maxAfterSize = maxBeforeSize + (maxBeforeSize + 99) / 100 + 12;
+
+    if (tightBeforeBufSize < maxBeforeSize) {
+        tightBeforeBufSize = maxBeforeSize;
+        if (tightBeforeBuf == NULL)
+            tightBeforeBuf = (char *)malloc(tightBeforeBufSize);
+        else
+            tightBeforeBuf = (char *)realloc(tightBeforeBuf,
+                                             tightBeforeBufSize);
+    }
+
+    if (tightAfterBufSize < maxAfterSize) {
+        tightAfterBufSize = maxAfterSize;
+        if (tightAfterBuf == NULL)
+            tightAfterBuf = (char *)malloc(tightAfterBufSize);
+        else
+            tightAfterBuf = (char *)realloc(tightAfterBuf,
+                                            tightAfterBufSize);
+    }
+
+    if (w > maxRectWidth || w * h > maxRectSize) {
+        subrectMaxWidth = (w > maxRectWidth) ? maxRectWidth : w;
+        subrectMaxHeight = maxRectSize / subrectMaxWidth;
+
+        for (dy = 0; dy < h; dy += subrectMaxHeight) {
+            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))
+                    return FALSE;
+            }
+        }
+    } else {
+        if (!SendSubrect(cl, x, y, w, h))
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static rfbBool
+SendSubrect(rfbClientPtr cl,
+            int x,
+            int y,
+            int w,
+            int h)
+{
+    char *fbptr;
+    rfbBool success = FALSE;
+
+    /* Send pending data if there is more than 128 bytes. */
+    if (cl->ublen > 128) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    if (!SendTightHeader(cl, x, y, w, h))
+        return FALSE;
+
+    fbptr = (cl->scaledScreen->frameBuffer
+             + (cl->scaledScreen->paddedWidthInBytes * y)
+             + (x * (cl->scaledScreen->bitsPerPixel / 8)));
+
+    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;
+    }
+
+    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 (qualityLevel != -1) {
+            success = SendJpegRect(cl, x, y, w, h, qualityLevel);
+        } else {
+            success = SendFullColorRect(cl, w, h);
+        }
+        break;
+    case 1:
+        /* Solid rectangle */
+        success = SendSolidRect(cl);
+        break;
+    case 2:
+        /* Two-color rectangle */
+        success = SendMonoRect(cl, w, h);
+        break;
+    default:
+        /* Up to 256 different colors */
+        success = SendIndexedRect(cl, w, h);
+    }
+    return success;
+}
+
+static rfbBool
+SendTightHeader(rfbClientPtr cl,
+                int x,
+                int y,
+                int w,
+                int h)
+{
+    rfbFramebufferUpdateRectHeader rect;
+
+    if (cl->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    rect.r.x = Swap16IfLE(x);
+    rect.r.y = Swap16IfLE(y);
+    rect.r.w = Swap16IfLE(w);
+    rect.r.h = Swap16IfLE(h);
+    rect.encoding = Swap32IfLE(rfbEncodingTight);
+
+    memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,
+           sz_rfbFramebufferUpdateRectHeader);
+    cl->ublen += sz_rfbFramebufferUpdateRectHeader;
+
+    rfbStatRecordEncodingSent(cl, rfbEncodingTight,
+                              sz_rfbFramebufferUpdateRectHeader,
+                              sz_rfbFramebufferUpdateRectHeader
+                                  + w * (cl->format.bitsPerPixel / 8) * h);
+
+    return TRUE;
+}
+
+/*
+ * Subencoding implementations.
+ */
+
+static rfbBool
+SendSolidRect(rfbClientPtr cl)
+{
+    int len;
+
+    if (usePixelFormat24) {
+        Pack24(cl, tightBeforeBuf, &cl->format, 1);
+        len = 3;
+    } else
+        len = cl->format.bitsPerPixel / 8;
+
+    if (cl->ublen + 1 + len > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    cl->updateBuf[cl->ublen++] = (char)(rfbTightFill << 4);
+    memcpy (&cl->updateBuf[cl->ublen], tightBeforeBuf, len);
+    cl->ublen += len;
+
+    rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, len + 1);
+
+    return TRUE;
+}
+
+static rfbBool
+SendMonoRect(rfbClientPtr cl,
+             int w,
+             int h)
+{
+    int streamId = 1;
+    int paletteLen, dataLen;
+
+    if ( cl->ublen + TIGHT_MIN_TO_COMPRESS + 6 +
+	 2 * cl->format.bitsPerPixel / 8 > UPDATE_BUF_SIZE ) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    /* Prepare tight encoding header. */
+    dataLen = (w + 7) / 8;
+    dataLen *= h;
+
+    if (tightConf[compressLevel].monoZlibLevel == 0)
+        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;
+
+    /* Prepare palette, convert image. */
+    switch (cl->format.bitsPerPixel) {
+
+    case 32:
+        EncodeMonoRect32((uint8_t *)tightBeforeBuf, w, h);
+
+        ((uint32_t *)tightAfterBuf)[0] = monoBackground;
+        ((uint32_t *)tightAfterBuf)[1] = monoForeground;
+        if (usePixelFormat24) {
+            Pack24(cl, tightAfterBuf, &cl->format, 2);
+            paletteLen = 6;
+        } else
+            paletteLen = 8;
+
+        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteLen);
+        cl->ublen += paletteLen;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 3 + paletteLen);
+        break;
+
+    case 16:
+        EncodeMonoRect16((uint8_t *)tightBeforeBuf, w, h);
+
+        ((uint16_t *)tightAfterBuf)[0] = (uint16_t)monoBackground;
+        ((uint16_t *)tightAfterBuf)[1] = (uint16_t)monoForeground;
+
+        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, 4);
+        cl->ublen += 4;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 7);
+        break;
+
+    default:
+        EncodeMonoRect8((uint8_t *)tightBeforeBuf, w, h);
+
+        cl->updateBuf[cl->ublen++] = (char)monoBackground;
+        cl->updateBuf[cl->ublen++] = (char)monoForeground;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 5);
+    }
+
+    return CompressData(cl, streamId, dataLen,
+                        tightConf[compressLevel].monoZlibLevel,
+                        Z_DEFAULT_STRATEGY);
+}
+
+static rfbBool
+SendIndexedRect(rfbClientPtr cl,
+                int w,
+                int h)
+{
+    int streamId = 2;
+    int i, entryLen;
+
+    if ( cl->ublen + TIGHT_MIN_TO_COMPRESS + 6 +
+	 paletteNumColors * cl->format.bitsPerPixel / 8 >
+         UPDATE_BUF_SIZE ) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    /* Prepare tight encoding header. */
+    if (tightConf[compressLevel].idxZlibLevel == 0)
+        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);
+
+    /* Prepare palette, convert image. */
+    switch (cl->format.bitsPerPixel) {
+
+    case 32:
+        EncodeIndexedRect32((uint8_t *)tightBeforeBuf, w * h);
+
+        for (i = 0; i < paletteNumColors; i++) {
+            ((uint32_t *)tightAfterBuf)[i] =
+                palette.entry[i].listNode->rgb;
+        }
+        if (usePixelFormat24) {
+            Pack24(cl, tightAfterBuf, &cl->format, paletteNumColors);
+            entryLen = 3;
+        } else
+            entryLen = 4;
+
+        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf,
+               paletteNumColors * entryLen);
+        cl->ublen += paletteNumColors * entryLen;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight,
+                                     3 + paletteNumColors * entryLen);
+        break;
+
+    case 16:
+        EncodeIndexedRect16((uint8_t *)tightBeforeBuf, w * h);
+
+        for (i = 0; i < paletteNumColors; i++) {
+            ((uint16_t *)tightAfterBuf)[i] =
+                (uint16_t)palette.entry[i].listNode->rgb;
+        }
+
+        memcpy(&cl->updateBuf[cl->ublen], tightAfterBuf, paletteNumColors * 2);
+        cl->ublen += paletteNumColors * 2;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight,
+                                     3 + paletteNumColors * 2);
+        break;
+
+    default:
+        return FALSE;           /* Should never happen. */
+    }
+
+    return CompressData(cl, streamId, w * h,
+                        tightConf[compressLevel].idxZlibLevel,
+                        Z_DEFAULT_STRATEGY);
+}
+
+static rfbBool
+SendFullColorRect(rfbClientPtr cl,
+                  int w,
+                  int h)
+{
+    int streamId = 0;
+    int len;
+
+    if (cl->ublen + TIGHT_MIN_TO_COMPRESS + 1 > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    if (tightConf[compressLevel].rawZlibLevel == 0)
+        cl->updateBuf[cl->ublen++] = (char)(rfbTightNoZlib << 4);
+    else
+        cl->updateBuf[cl->ublen++] = 0x00;  /* stream id = 0, no flushing, no filter */
+    rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
+
+    if (usePixelFormat24) {
+        Pack24(cl, tightBeforeBuf, &cl->format, w * h);
+        len = 3;
+    } else
+        len = cl->format.bitsPerPixel / 8;
+
+    return CompressData(cl, streamId, w * h * len,
+                        tightConf[compressLevel].rawZlibLevel,
+                        Z_DEFAULT_STRATEGY);
+}
+
+static rfbBool
+CompressData(rfbClientPtr cl,
+             int streamId,
+             int dataLen,
+             int zlibLevel,
+             int zlibStrategy)
+{
+    z_streamp pz;
+    int err;
+
+    if (dataLen < TIGHT_MIN_TO_COMPRESS) {
+        memcpy(&cl->updateBuf[cl->ublen], tightBeforeBuf, dataLen);
+        cl->ublen += dataLen;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, dataLen);
+        return TRUE;
+    }
+
+    if (zlibLevel == 0)
+        return SendCompressedData (cl, tightBeforeBuf, dataLen);
+
+    pz = &cl->zsStruct[streamId];
+
+    /* Initialize compression stream if needed. */
+    if (!cl->zsActive[streamId]) {
+        pz->zalloc = Z_NULL;
+        pz->zfree = Z_NULL;
+        pz->opaque = Z_NULL;
+
+        err = deflateInit2 (pz, zlibLevel, Z_DEFLATED, MAX_WBITS,
+                            MAX_MEM_LEVEL, zlibStrategy);
+        if (err != Z_OK)
+            return FALSE;
+
+        cl->zsActive[streamId] = TRUE;
+        cl->zsLevel[streamId] = zlibLevel;
+    }
+
+    /* Prepare buffer pointers. */
+    pz->next_in = (Bytef *)tightBeforeBuf;
+    pz->avail_in = dataLen;
+    pz->next_out = (Bytef *)tightAfterBuf;
+    pz->avail_out = tightAfterBufSize;
+
+    /* Change compression parameters if needed. */
+    if (zlibLevel != cl->zsLevel[streamId]) {
+        if (deflateParams (pz, zlibLevel, zlibStrategy) != Z_OK) {
+            return FALSE;
+        }
+        cl->zsLevel[streamId] = zlibLevel;
+    }
+
+    /* Actual compression. */
+    if (deflate(pz, Z_SYNC_FLUSH) != Z_OK ||
+        pz->avail_in != 0 || pz->avail_out == 0) {
+        return FALSE;
+    }
+
+    return SendCompressedData(cl, tightAfterBuf,
+                              tightAfterBufSize - pz->avail_out);
+}
+
+static rfbBool SendCompressedData(rfbClientPtr cl, char *buf,
+                                  int compressedLen)
+{
+    int i, portionLen;
+
+    cl->updateBuf[cl->ublen++] = compressedLen & 0x7F;
+    rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
+    if (compressedLen > 0x7F) {
+        cl->updateBuf[cl->ublen-1] |= 0x80;
+        cl->updateBuf[cl->ublen++] = compressedLen >> 7 & 0x7F;
+        rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
+        if (compressedLen > 0x3FFF) {
+            cl->updateBuf[cl->ublen-1] |= 0x80;
+            cl->updateBuf[cl->ublen++] = compressedLen >> 14 & 0xFF;
+            rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
+        }
+    }
+
+    portionLen = UPDATE_BUF_SIZE;
+    for (i = 0; i < compressedLen; i += portionLen) {
+        if (i + portionLen > compressedLen) {
+            portionLen = compressedLen - i;
+        }
+        if (cl->ublen + portionLen > UPDATE_BUF_SIZE) {
+            if (!rfbSendUpdateBuf(cl))
+                return FALSE;
+        }
+        memcpy(&cl->updateBuf[cl->ublen], &buf[i], portionLen);
+        cl->ublen += portionLen;
+    }
+    rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, compressedLen);
+
+    return TRUE;
+}
+
+
+/*
+ * Code to determine how many different colors used in rectangle.
+ */
+
+static void
+FillPalette8(int count)
+{
+    uint8_t *data = (uint8_t *)tightBeforeBuf;
+    uint8_t c0, c1;
+    int i, n0, n1;
+
+    paletteNumColors = 0;
+
+    c0 = data[0];
+    for (i = 1; i < count && data[i] == c0; i++);
+    if (i == count) {
+        paletteNumColors = 1;
+        return;                 /* Solid rectangle */
+    }
+
+    if (paletteMaxColors < 2)
+        return;
+
+    n0 = i;
+    c1 = data[i];
+    n1 = 0;
+    for (i++; i < count; i++) {
+        if (data[i] == c0) {
+            n0++;
+        } else if (data[i] == c1) {
+            n1++;
+        } else
+            break;
+    }
+    if (i == count) {
+        if (n0 > n1) {
+            monoBackground = (uint32_t)c0;
+            monoForeground = (uint32_t)c1;
+        } else {
+            monoBackground = (uint32_t)c1;
+            monoForeground = (uint32_t)c0;
+        }
+        paletteNumColors = 2;   /* Two colors */
+    }
+}
+
+
+#define DEFINE_FILL_PALETTE_FUNCTION(bpp)                               \
+                                                                        \
+static void                                                             \
+FillPalette##bpp(int count) {                                           \
+    uint##bpp##_t *data = (uint##bpp##_t *)tightBeforeBuf;              \
+    uint##bpp##_t c0, c1, ci;                                           \
+    int i, n0, n1, ni;                                                  \
+                                                                        \
+    c0 = data[0];                                                       \
+    for (i = 1; i < count && data[i] == c0; i++);                       \
+    if (i >= count) {                                                   \
+        paletteNumColors = 1;   /* Solid rectangle */                   \
+        return;                                                         \
+    }                                                                   \
+                                                                        \
+    if (paletteMaxColors < 2) {                                         \
+        paletteNumColors = 0;   /* Full-color encoding preferred */     \
+        return;                                                         \
+    }                                                                   \
+                                                                        \
+    n0 = i;                                                             \
+    c1 = data[i];                                                       \
+    n1 = 0;                                                             \
+    for (i++; i < count; i++) {                                         \
+        ci = data[i];                                                   \
+        if (ci == c0) {                                                 \
+            n0++;                                                       \
+        } else if (ci == c1) {                                          \
+            n1++;                                                       \
+        } else                                                          \
+            break;                                                      \
+    }                                                                   \
+    if (i >= count) {                                                   \
+        if (n0 > n1) {                                                  \
+            monoBackground = (uint32_t)c0;                              \
+            monoForeground = (uint32_t)c1;                              \
+        } else {                                                        \
+            monoBackground = (uint32_t)c1;                              \
+            monoForeground = (uint32_t)c0;                              \
+        }                                                               \
+        paletteNumColors = 2;   /* Two colors */                        \
+        return;                                                         \
+    }                                                                   \
+                                                                        \
+    PaletteReset();                                                     \
+    PaletteInsert (c0, (uint32_t)n0, bpp);                              \
+    PaletteInsert (c1, (uint32_t)n1, bpp);                              \
+                                                                        \
+    ni = 1;                                                             \
+    for (i++; i < count; i++) {                                         \
+        if (data[i] == ci) {                                            \
+            ni++;                                                       \
+        } else {                                                        \
+            if (!PaletteInsert (ci, (uint32_t)ni, bpp))                 \
+                return;                                                 \
+            ci = data[i];                                               \
+            ni = 1;                                                     \
+        }                                                               \
+    }                                                                   \
+    PaletteInsert (ci, (uint32_t)ni, bpp);                              \
+}
+
+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))
+
+
+static void
+PaletteReset(void)
+{
+    paletteNumColors = 0;
+    memset(palette.hash, 0, 256 * sizeof(COLOR_LIST *));
+}
+
+
+static int
+PaletteInsert(uint32_t rgb,
+              int numPixels,
+              int bpp)
+{
+    COLOR_LIST *pnode;
+    COLOR_LIST *prev_pnode = NULL;
+    int hash_key, idx, new_idx, count;
+
+    hash_key = (bpp == 16) ? HASH_FUNC16(rgb) : HASH_FUNC32(rgb);
+
+    pnode = palette.hash[hash_key];
+
+    while (pnode != NULL) {
+        if (pnode->rgb == rgb) {
+            /* Such palette entry already exists. */
+            new_idx = idx = pnode->idx;
+            count = palette.entry[idx].numPixels + numPixels;
+            if (new_idx && palette.entry[new_idx-1].numPixels < count) {
+                do {
+                    palette.entry[new_idx] = palette.entry[new_idx-1];
+                    palette.entry[new_idx].listNode->idx = new_idx;
+                    new_idx--;
+                }
+                while (new_idx && palette.entry[new_idx-1].numPixels < count);
+                palette.entry[new_idx].listNode = pnode;
+                pnode->idx = new_idx;
+            }
+            palette.entry[new_idx].numPixels = count;
+            return paletteNumColors;
+        }
+        prev_pnode = pnode;
+        pnode = pnode->next;
+    }
+
+    /* Check if palette is full. */
+    if (paletteNumColors == 256 || paletteNumColors == paletteMaxColors) {
+        paletteNumColors = 0;
+        return 0;
+    }
+
+    /* Move palette entries with lesser pixel counts. */
+    for ( idx = paletteNumColors;
+          idx > 0 && palette.entry[idx-1].numPixels < numPixels;
+          idx-- ) {
+        palette.entry[idx] = palette.entry[idx-1];
+        palette.entry[idx].listNode->idx = idx;
+    }
+
+    /* Add new palette entry into the freed slot. */
+    pnode = &palette.list[paletteNumColors];
+    if (prev_pnode != NULL) {
+        prev_pnode->next = pnode;
+    } else {
+        palette.hash[hash_key] = pnode;
+    }
+    pnode->next = NULL;
+    pnode->idx = idx;
+    pnode->rgb = rgb;
+    palette.entry[idx].listNode = pnode;
+    palette.entry[idx].numPixels = numPixels;
+
+    return (++paletteNumColors);
+}
+
+
+/*
+ * Converting 32-bit color samples into 24-bit colors.
+ * Should be called only when redMax, greenMax and blueMax are 255.
+ * Color components assumed to be byte-aligned.
+ */
+
+static void Pack24(rfbClientPtr cl,
+                   char *buf,
+                   rfbPixelFormat *fmt,
+                   int count)
+{
+    uint32_t *buf32;
+    uint32_t pix;
+    int r_shift, g_shift, b_shift;
+
+    buf32 = (uint32_t *)buf;
+
+    if (!cl->screen->serverFormat.bigEndian == !fmt->bigEndian) {
+        r_shift = fmt->redShift;
+        g_shift = fmt->greenShift;
+        b_shift = fmt->blueShift;
+    } else {
+        r_shift = 24 - fmt->redShift;
+        g_shift = 24 - fmt->greenShift;
+        b_shift = 24 - fmt->blueShift;
+    }
+
+    while (count--) {
+        pix = *buf32++;
+        *buf++ = (char)(pix >> r_shift);
+        *buf++ = (char)(pix >> g_shift);
+        *buf++ = (char)(pix >> b_shift);
+    }
+}
+
+
+/*
+ * Converting truecolor samples into palette indices.
+ */
+
+#define DEFINE_IDX_ENCODE_FUNCTION(bpp)                                 \
+                                                                        \
+static void                                                             \
+EncodeIndexedRect##bpp(uint8_t *buf, int count) {                       \
+    COLOR_LIST *pnode;                                                  \
+    uint##bpp##_t *src;                                                 \
+    uint##bpp##_t rgb;                                                  \
+    int rep = 0;                                                        \
+                                                                        \
+    src = (uint##bpp##_t *) buf;                                        \
+                                                                        \
+    while (count--) {                                                   \
+        rgb = *src++;                                                   \
+        while (count && *src == rgb) {                                  \
+            rep++, src++, count--;                                      \
+        }                                                               \
+        pnode = palette.hash[HASH_FUNC##bpp(rgb)];                      \
+        while (pnode != NULL) {                                         \
+            if ((uint##bpp##_t)pnode->rgb == rgb) {                     \
+                *buf++ = (uint8_t)pnode->idx;                           \
+                while (rep) {                                           \
+                    *buf++ = (uint8_t)pnode->idx;                       \
+                    rep--;                                              \
+                }                                                       \
+                break;                                                  \
+            }                                                           \
+            pnode = pnode->next;                                        \
+        }                                                               \
+    }                                                                   \
+}
+
+DEFINE_IDX_ENCODE_FUNCTION(16)
+DEFINE_IDX_ENCODE_FUNCTION(32)
+
+
+#define DEFINE_MONO_ENCODE_FUNCTION(bpp)                                \
+                                                                        \
+static void                                                             \
+EncodeMonoRect##bpp(uint8_t *buf, int w, int h) {                       \
+    uint##bpp##_t *ptr;                                                 \
+    uint##bpp##_t bg;                                                   \
+    unsigned int value, mask;                                           \
+    int aligned_width;                                                  \
+    int x, y, bg_bits;                                                  \
+                                                                        \
+    ptr = (uint##bpp##_t *) buf;                                        \
+    bg = (uint##bpp##_t) monoBackground;                                \
+    aligned_width = w - w % 8;                                          \
+                                                                        \
+    for (y = 0; y < h; y++) {                                           \
+        for (x = 0; x < aligned_width; x += 8) {                        \
+            for (bg_bits = 0; bg_bits < 8; bg_bits++) {                 \
+                if (*ptr++ != bg)                                       \
+                    break;                                              \
+            }                                                           \
+            if (bg_bits == 8) {                                         \
+                *buf++ = 0;                                             \
+                continue;                                               \
+            }                                                           \
+            mask = 0x80 >> bg_bits;                                     \
+            value = mask;                                               \
+            for (bg_bits++; bg_bits < 8; bg_bits++) {                   \
+                mask >>= 1;                                             \
+                if (*ptr++ != bg) {                                     \
+                    value |= mask;                                      \
+                }                                                       \
+            }                                                           \
+            *buf++ = (uint8_t)value;                                    \
+        }                                                               \
+                                                                        \
+        mask = 0x80;                                                    \
+        value = 0;                                                      \
+        if (x >= w)                                                     \
+            continue;                                                   \
+                                                                        \
+        for (; x < w; x++) {                                            \
+            if (*ptr++ != bg) {                                         \
+                value |= mask;                                          \
+            }                                                           \
+            mask >>= 1;                                                 \
+        }                                                               \
+        *buf++ = (uint8_t)value;                                        \
+    }                                                                   \
+}
+
+DEFINE_MONO_ENCODE_FUNCTION(8)
+DEFINE_MONO_ENCODE_FUNCTION(16)
+DEFINE_MONO_ENCODE_FUNCTION(32)
+
+
+/*
+ * JPEG compression stuff.
+ */
+
+static rfbBool
+SendJpegRect(rfbClientPtr cl, int x, int y, int w, int h, int quality)
+{
+    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;
+
+    if (cl->screen->serverFormat.bitsPerPixel == 8)
+        return SendFullColorRect(cl, w, h);
+
+    if (ps < 2) {
+        rfbLog("Error: JPEG requires 16-bit, 24-bit, or 32-bit pixel format.\n");
+        return 0;
+    }
+    if (!j) {
+        if ((j = tjInitCompress()) == NULL) {
+            rfbLog("JPEG Error: %s\n", tjGetErrorStr());
+            return 0;
+        }
+    }
+
+    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;
+        }
+        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;
+        }
+        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;
+        }
+        return 0;
+    }
+
+    if (tmpbuf) {
+        free(tmpbuf);
+        tmpbuf = NULL;
+    }
+
+    if (cl->ublen + TIGHT_MIN_TO_COMPRESS + 1 > UPDATE_BUF_SIZE) {
+        if (!rfbSendUpdateBuf(cl))
+            return FALSE;
+    }
+
+    cl->updateBuf[cl->ublen++] = (char)(rfbTightJpeg << 4);
+    rfbStatRecordEncodingSentAdd(cl, rfbEncodingTight, 1);
+
+    return SendCompressedData(cl, tightAfterBuf, (int)size);
+}
diff --git a/rfb/rfb.h b/rfb/rfb.h
index e068e76..0d11357 100644
--- a/rfb/rfb.h
+++ b/rfb/rfb.h
@@ -599,6 +599,10 @@ typedef struct _rfbClientRec {
 #if defined(LIBVNCSERVER_HAVE_LIBJPEG) || defined(LIBVNCSERVER_HAVE_LIBPNG)
     int tightCompressLevel;
 #endif
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+    /* TurboVNC Encoding support (extends TightVNC) */
+    int tightSubsampLevel;
+#endif
 #endif
 
     /* Ultra Encoding support */
@@ -871,6 +875,10 @@ extern rfbBool rfbSendRectEncodingZlib(rfbClientPtr cl, int x, int y, int w,
 
 #define TIGHT_DEFAULT_COMPRESSION  6
 
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+#define TIGHT_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..d99fbe5 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,17 @@ typedef struct {
  *   0xFFFFFFF0 .. 0xFFFFFFFF -- cross-encoding compression levels.
  */
 
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+#define rfbEncodingFineQualityLevel0   0xFFFFFE00
+#define rfbEncodingFineQualityLevel100 0xFFFFFE64
+#define rfbEncodingSubsamp1X           0xFFFFFD00
+#define rfbEncodingSubsamp4X           0xFFFFFD01
+#define rfbEncodingSubsamp2X           0xFFFFFD02
+#define rfbEncodingSubsampGray         0xFFFFFD03
+#define rfbEncodingSubsamp8X           0xFFFFFD04
+#define rfbEncodingSubsamp16X          0xFFFFFD05
+#endif
+
 #define rfbEncodingCompressLevel0  0xFFFFFF00
 #define rfbEncodingCompressLevel1  0xFFFFFF01
 #define rfbEncodingCompressLevel2  0xFFFFFF02
@@ -719,12 +734,19 @@ 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",
+ *             (TurboVNC) if 1010 (0x0A), then the compression type is "basic"
+ *               and no Zlib compression was used,
+ *             (TurboVNC) if 1110 (0x0E), then the compression type is "basic",
+ *               no Zlib compression was used, and a "filter id" byte follows
+ *               this byte,
+ *             (TightVNC) 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,7 +858,11 @@ typedef struct {
 #define rfbTightExplicitFilter         0x04
 #define rfbTightFill                   0x08
 #define rfbTightJpeg                   0x09
+#ifdef LIBVNCSERVER_HAVE_TURBOVNC
+#define rfbTightNoZlib                 0x0A
+#else
 #define rfbTightPng                    0x0A
+#endif
 #define rfbTightMaxSubencoding         0x0A
 
 /* Filters to improve compression efficiency */