Replace TightVNC encoder with TurboVNC encoder. This patch is the result of further research and discussion that revealed the following:

-- TightPng encoding and the rfbTightNoZlib extension need not conflict.  Since
   TightPng is a separate encoding type, not supported by TurboVNC-compatible
   viewers, then the rfbTightNoZlib extension can be used solely whenever the
   encoding type is Tight and disabled with the encoding type is TightPng.

-- In the TightVNC encoder, compression levels above 5 are basically useless.
   On the set of 20 low-level datasets that were used to design the TurboVNC
   encoder (these include the eight 2D application captures that were also used
   when designing the TightVNC encoder, as well as 12 3D application captures
   provided by the VirtualGL Project--
   see http://www.virtualgl.org/pmwiki/uploads/About/tighttoturbo.pdf), moving
   from Compression Level (CL) 5 to CL 9 in the TightVNC encoder did not
   increase the compression ratio of any datasets more than 10%, and the
   compression ratio only increased by more than 5% on four of them.  The
   compression ratio actually decreased a few percent on five of them.  In
   exchange for this paltry increase in compression ratio, the CPU usage, on
   average, went up by a factor of 5.  Thus, for all intents and purposes,
   TightVNC CL 5 provides the "best useful compression" for that encoder.

-- TurboVNC's best compression level (CL 2) compresses 3D and video workloads
   significantly more "tightly" than TightVNC CL 5 (~70% better, in the
   aggregate) but does not quite achieve the same level of compression with 2D
   workloads (~20% worse, in the aggregate.) This decrease in compression ratio
   may or may not be noticeable, since many of the datasets it affects are not
   performance-critical (such as the console output of a compilation, etc.)
   However, for peace of mind, it was still desirable to have a mode that
   compressed with equal "tightness" to TightVNC CL 5, since we proposed to
   replace that encoder entirely.

-- A new mode was discovered in the TurboVNC encoder that produces, in the
   aggregate, similar compression ratios on 2D datasets as TightVNC CL 5.  That
   new mode involves using Zlib level 7 (the same level used by TightVNC CL 5)
   but setting the "palette threshold" to 256, so that indexed color encoding
   is used whenever possible.  This mode reduces bandwidth only marginally
   (typically 10-20%) relative to TurboVNC CL 2 on low-color workloads, in
   exchange for nearly doubling CPU usage, and it does not benefit high-color
   workloads at all (since those are usually encoded with JPEG.)  However, it
   provides a means of reproducing the same "tightness" as the TightVNC
   encoder on 2D workloads without sacrificing any compression for 3D/video
   workloads, and without using any more CPU time than necessary.

-- The TurboVNC encoder still performs as well or better than the TightVNC
   encoder when plain libjpeg is used instead of libjpeg-turbo.

Specific notes follow:

common/turbojpeg.c common/turbojpeg.h:
Added code to emulate the libjpeg-turbo colorspace extensions, so that the
TurboJPEG wrapper can be used with plain libjpeg as well.  This required
updating the TurboJPEG wrapper to the latest code from libjpeg-turbo 1.2.0,
mainly because the TurboJPEG 1.2 API handles pixel formats in a much cleaner
way, which made the conversion code easier to write.  It also eases the
maintenance to have the wrapper synced as much as possible with the upstream
code base (so I can merge any relevant bug fixes that are discovered upstream.)
The libvncserver version of the TurboJPEG wrapper is a "lite" version,
containing only the JPEG compression/decompression code and not the lossless
transform, YUV encoding/decoding, and dynamic buffer allocation features from
TurboJPEG 1.2.

configure.ac:
Removed the --with-turbovnc option.  configure still checks for the presence of
libjpeg-turbo, but only for the purposes of printing a performance warning if
it isn't available.

rfb/rfb.h:
Fix a bug introduced with the initial TurboVNC encoder patch.  We cannot use
tightQualityLevel for the TurboVNC 1-100 quality level, because
tightQualityLevel is also used by ZRLE.  Thus, a new parameter
(turboQualityLevel) was created.

rfb/rfbproto.h:
Remove TurboVNC-specific #ifdefs and language

libvncserver/rfbserver.c:
Remove TurboVNC-specific #ifdefs.  Fix afore-mentioned tightQualityLevel bug.

libvncserver/tight.c:
Replaced the TightVNC encoder with the TurboVNC encoder.  Relative to the
initial TurboVNC encoder patch, this patch also:
-- Adds TightPng support to the TurboVNC encoder
-- Adds the afore-mentioned low-bandwidth mode, which is mapped externally to
   Compression Level 9

test/*:
Included TJUnitTest (a regression test for the TurboJPEG wrapper) as well as
TJBench (a benchmark for same.)  These are useful for ensuring that the wrapper
still functions correctly and performantly if it needs to be modified for
whatever reason.  Both of these programs are derived from libjpeg-turbo 1.2.0.
As with the TurboJPEG wrapper, they do not contain the more advanced features
of TurboJPEG 1.2, such as YUV encoding/decoding and lossless transforms.

1 files changed, 685 insertions, 259 deletions

diff --git a/common/turbojpeg.c b/common/turbojpeg.c
index 497ec59..c145338 100644
--- a/common/turbojpeg.c
+++ b/common/turbojpeg.c
@@ -1,112 +1,517 @@
-/* Copyright (C)2004 Landmark Graphics Corporation
- * Copyright (C)2005 Sun Microsystems, Inc.
- * Copyright (C)2009-2011 D. R. Commander
+/*
+ * Copyright (C)2009-2012 D. R. Commander.  All Rights Reserved.
  *
- * 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.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
  *
- * 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.
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
-// This implements a JPEG compressor/decompressor using the libjpeg API
+/* TurboJPEG/OSS:  this implements the TurboJPEG API using libjpeg-turbo */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <jpeglib.h>
 #include <jerror.h>
+#ifndef JCS_EXTENSIONS
+#define JPEG_INTERNALS
+#include <jmorecfg.h>
+#endif
 #include <setjmp.h>
 #include "./turbojpeg.h"
 
+#define PAD(v, p) ((v+(p)-1)&(~((p)-1)))
 
 #define CSTATE_START 100
 #define DSTATE_START 200
+#define MEMZERO(ptr, size) memset(ptr, 0, size)
+
+#ifndef min
+ #define min(a,b) ((a)<(b)?(a):(b))
+#endif
+
+#ifndef max
+ #define max(a,b) ((a)>(b)?(a):(b))
+#endif
 
 
-// Error handling
+/* Error handling (based on example in example.c) */
 
-static char lasterror[JMSG_LENGTH_MAX]="No error";
+static char errStr[JMSG_LENGTH_MAX]="No error";
 
-typedef struct _error_mgr
+struct my_error_mgr
 {
 	struct jpeg_error_mgr pub;
-	jmp_buf jb;
-} error_mgr;
+	jmp_buf setjmp_buffer;
+};
+typedef struct my_error_mgr *my_error_ptr;
 
 static void my_error_exit(j_common_ptr cinfo)
 {
-	error_mgr *myerr = (error_mgr *)cinfo->err;
+	my_error_ptr myerr=(my_error_ptr)cinfo->err;
 	(*cinfo->err->output_message)(cinfo);
-	longjmp(myerr->jb, 1);
+	longjmp(myerr->setjmp_buffer, 1);
 }
 
+/* Based on output_message() in jerror.c */
+
 static void my_output_message(j_common_ptr cinfo)
 {
-	(*cinfo->err->format_message)(cinfo, lasterror);
+	(*cinfo->err->format_message)(cinfo, errStr);
 }
 
 
-// Global structures, macros, etc.
+/* Global structures, macros, etc. */
+
+enum {COMPRESS=1, DECOMPRESS=2};
 
-typedef struct _jpgstruct
+typedef struct _tjinstance
 {
 	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;
+	struct jpeg_destination_mgr jdst;
+	struct jpeg_source_mgr jsrc;
+	struct my_error_mgr jerr;
+	int init;
+} tjinstance;
+
+static const int pixelsize[TJ_NUMSAMP]={3, 3, 3, 1, 3};
+
+#define NUMSF 4
+static const tjscalingfactor sf[NUMSF]={
+	{1, 1},
+	{1, 2},
+	{1, 4},
+	{1, 8}
+};
+
+#define _throw(m) {snprintf(errStr, JMSG_LENGTH_MAX, "%s", m);  \
+	retval=-1;  goto bailout;}
+#define getinstance(handle) tjinstance *this=(tjinstance *)handle;  \
+	j_compress_ptr cinfo=NULL;  j_decompress_ptr dinfo=NULL;  \
+	if(!this) {snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle");  \
+		return -1;}  \
+	cinfo=&this->cinfo;  dinfo=&this->dinfo;
+
+static int getPixelFormat(int pixelSize, int flags)
+{
+	if(pixelSize==1) return TJPF_GRAY;
+	if(pixelSize==3)
+	{
+		if(flags&TJ_BGR) return TJPF_BGR;
+		else return TJPF_RGB;
+	}
+	if(pixelSize==4)
+	{
+		if(flags&TJ_ALPHAFIRST)
+		{
+			if(flags&TJ_BGR) return TJPF_XBGR;
+			else return TJPF_XRGB;
+		}
+		else
+		{
+			if(flags&TJ_BGR) return TJPF_BGRX;
+			else return TJPF_RGBX;
+		}
+	}
+	return -1;
+}
+
+static int setCompDefaults(struct jpeg_compress_struct *cinfo,
+	int pixelFormat, int subsamp, int jpegQual)
+{
+	int retval=0;
+
+	switch(pixelFormat)
+	{
+		case TJPF_GRAY:
+			cinfo->in_color_space=JCS_GRAYSCALE;  break;
+		#if JCS_EXTENSIONS==1
+		case TJPF_RGB:
+			cinfo->in_color_space=JCS_EXT_RGB;  break;
+		case TJPF_BGR:
+			cinfo->in_color_space=JCS_EXT_BGR;  break;
+		case TJPF_RGBX:
+		case TJPF_RGBA:
+			cinfo->in_color_space=JCS_EXT_RGBX;  break;
+		case TJPF_BGRX:
+		case TJPF_BGRA:
+			cinfo->in_color_space=JCS_EXT_BGRX;  break;
+		case TJPF_XRGB:
+		case TJPF_ARGB:
+			cinfo->in_color_space=JCS_EXT_XRGB;  break;
+		case TJPF_XBGR:
+		case TJPF_ABGR:
+			cinfo->in_color_space=JCS_EXT_XBGR;  break;
+		#else
+		case TJPF_RGB:
+		case TJPF_BGR:
+		case TJPF_RGBX:
+		case TJPF_BGRX:
+		case TJPF_XRGB:
+		case TJPF_XBGR:
+		case TJPF_RGBA:
+		case TJPF_BGRA:
+		case TJPF_ARGB:
+		case TJPF_ABGR:
+			cinfo->in_color_space=JCS_RGB;  pixelFormat=TJPF_RGB;
+			break;
+		#endif
+	}
+
+	cinfo->input_components=tjPixelSize[pixelFormat];
+	jpeg_set_defaults(cinfo);
+	if(jpegQual>=0)
+	{
+		jpeg_set_quality(cinfo, jpegQual, TRUE);
+		if(jpegQual>=96) cinfo->dct_method=JDCT_ISLOW;
+		else cinfo->dct_method=JDCT_FASTEST;
+	}
+	if(subsamp==TJSAMP_GRAY)
+		jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+	else
+		jpeg_set_colorspace(cinfo, JCS_YCbCr);
+
+	cinfo->comp_info[0].h_samp_factor=tjMCUWidth[subsamp]/8;
+	cinfo->comp_info[1].h_samp_factor=1;
+	cinfo->comp_info[2].h_samp_factor=1;
+	cinfo->comp_info[0].v_samp_factor=tjMCUHeight[subsamp]/8;
+	cinfo->comp_info[1].v_samp_factor=1;
+	cinfo->comp_info[2].v_samp_factor=1;
+
+	return retval;
+}
+
+static int setDecompDefaults(struct jpeg_decompress_struct *dinfo,
+	int pixelFormat)
+{
+	int retval=0;
+
+	switch(pixelFormat)
+	{
+		case TJPF_GRAY:
+			dinfo->out_color_space=JCS_GRAYSCALE;  break;
+		#if JCS_EXTENSIONS==1
+		case TJPF_RGB:
+			dinfo->out_color_space=JCS_EXT_RGB;  break;
+		case TJPF_BGR:
+			dinfo->out_color_space=JCS_EXT_BGR;  break;
+		case TJPF_RGBX:
+			dinfo->out_color_space=JCS_EXT_RGBX;  break;
+		case TJPF_BGRX:
+			dinfo->out_color_space=JCS_EXT_BGRX;  break;
+		case TJPF_XRGB:
+			dinfo->out_color_space=JCS_EXT_XRGB;  break;
+		case TJPF_XBGR:
+			dinfo->out_color_space=JCS_EXT_XBGR;  break;
+		#if JCS_ALPHA_EXTENSIONS==1
+		case TJPF_RGBA:
+			dinfo->out_color_space=JCS_EXT_RGBA;  break;
+		case TJPF_BGRA:
+			dinfo->out_color_space=JCS_EXT_BGRA;  break;
+		case TJPF_ARGB:
+			dinfo->out_color_space=JCS_EXT_ARGB;  break;
+		case TJPF_ABGR:
+			dinfo->out_color_space=JCS_EXT_ABGR;  break;
+		#endif
+		#else
+		case TJPF_RGB:
+		case TJPF_BGR:
+		case TJPF_RGBX:
+		case TJPF_BGRX:
+		case TJPF_XRGB:
+		case TJPF_XBGR:
+		case TJPF_RGBA:
+		case TJPF_BGRA:
+		case TJPF_ARGB:
+		case TJPF_ABGR:
+			dinfo->out_color_space=JCS_RGB;  break;
+		#endif
+		default:
+			_throw("Unsupported pixel format");
+	}
+
+	bailout:
+	return retval;
+}
+
+
+static int getSubsamp(j_decompress_ptr dinfo)
+{
+	int retval=-1, i, k;
+	for(i=0; i<NUMSUBOPT; i++)
+	{
+		if(dinfo->num_components==pixelsize[i])
+		{
+			if(dinfo->comp_info[0].h_samp_factor==tjMCUWidth[i]/8
+				&& dinfo->comp_info[0].v_samp_factor==tjMCUHeight[i]/8)
+			{
+				int match=0;
+				for(k=1; k<dinfo->num_components; k++)
+				{
+					if(dinfo->comp_info[k].h_samp_factor==1
+						&& dinfo->comp_info[k].v_samp_factor==1)
+						match++;
+				}
+				if(match==dinfo->num_components-1)
+				{
+					retval=i;  break;
+				}
+			}
+		}
+	}
+	return retval;
+}
+
+
+#ifndef JCS_EXTENSIONS
+
+/* Conversion functions to emulate the colorspace extensions.  This allows the
+   TurboJPEG wrapper to be used with libjpeg */
+
+#define TORGB(PS, ROFFSET, GOFFSET, BOFFSET) {  \
+	int rowPad=pitch-width*PS;  \
+	while(height--)  \
+	{  \
+		unsigned char *endOfRow=src+width*PS;  \
+		while(src<endOfRow)  \
+		{  \
+			dst[RGB_RED]=src[ROFFSET];  \
+			dst[RGB_GREEN]=src[GOFFSET];  \
+			dst[RGB_BLUE]=src[BOFFSET];  \
+			dst+=RGB_PIXELSIZE;  src+=PS;  \
+		}  \
+		src+=rowPad;  \
+	}  \
+}
+
+static unsigned char *toRGB(unsigned char *src, int width, int pitch,
+	int height, int pixelFormat, unsigned char *dst)
+{
+	unsigned char *retval=src;
+	switch(pixelFormat)
+	{
+		case TJPF_RGB:
+			#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
+			retval=dst;  TORGB(3, 0, 1, 2);
+			#endif
+			break;
+		case TJPF_BGR:
+			#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
+			retval=dst;  TORGB(3, 2, 1, 0);
+			#endif
+			break;
+		case TJPF_RGBX:
+		case TJPF_RGBA:
+			#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+			retval=dst;  TORGB(4, 0, 1, 2);
+			#endif
+			break;
+		case TJPF_BGRX:
+		case TJPF_BGRA:
+			#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+			retval=dst;  TORGB(4, 2, 1, 0);
+			#endif
+			break;
+		case TJPF_XRGB:
+		case TJPF_ARGB:
+			#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+			retval=dst;  TORGB(4, 1, 2, 3);
+			#endif
+			break;
+		case TJPF_XBGR:
+		case TJPF_ABGR:
+			#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+			retval=dst;  TORGB(4, 3, 2, 1);
+			#endif
+			break;
+	}
+	return retval;
+}
 
-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 FROMRGB(PS, ROFFSET, GOFFSET, BOFFSET, SETALPHA) {  \
+	int rowPad=pitch-width*PS;  \
+	while(height--)  \
+	{  \
+		unsigned char *endOfRow=dst+width*PS;  \
+		while(dst<endOfRow)  \
+		{  \
+			dst[ROFFSET]=src[RGB_RED];  \
+			dst[GOFFSET]=src[RGB_GREEN];  \
+			dst[BOFFSET]=src[RGB_BLUE];  \
+			SETALPHA  \
+			dst+=PS;  src+=RGB_PIXELSIZE;  \
+		}  \
+		dst+=rowPad;  \
+	}  \
+}
 
-#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;}
+static void fromRGB(unsigned char *src, unsigned char *dst, int width,
+	int pitch, int height, int pixelFormat)
+{
+	switch(pixelFormat)
+	{
+		case TJPF_RGB:
+			#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
+			FROMRGB(3, 0, 1, 2,);
+			#endif
+			break;
+		case TJPF_BGR:
+			#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
+			FROMRGB(3, 2, 1, 0,);
+			#endif
+			break;
+		case TJPF_RGBX:
+			#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 0, 1, 2,);
+			#endif
+			break;
+		case TJPF_RGBA:
+			#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 0, 1, 2, dst[3]=0xFF;);
+			#endif
+			break;
+		case TJPF_BGRX:
+			#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 2, 1, 0,);
+			#endif
+			break;
+		case TJPF_BGRA:
+			#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 2, 1, 0, dst[3]=0xFF;);  return;
+			#endif
+			break;
+		case TJPF_XRGB:
+			#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 1, 2, 3,);  return;
+			#endif
+			break;
+		case TJPF_ARGB:
+			#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 1, 2, 3, dst[0]=0xFF;);  return;
+			#endif
+			break;
+		case TJPF_XBGR:
+			#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 3, 2, 1,);  return;
+			#endif
+			break;
+		case TJPF_ABGR:
+			#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
+			FROMRGB(4, 3, 2, 1, dst[0]=0xFF;);  return;
+			#endif
+			break;
+	}
+}
 
+#endif
 
-// CO
 
-static boolean empty_output_buffer(struct jpeg_compress_struct *cinfo)
+/* General API functions */
+
+DLLEXPORT char* DLLCALL tjGetErrorStr(void)
+{
+	return errStr;
+}
+
+
+DLLEXPORT int DLLCALL tjDestroy(tjhandle handle)
+{
+	getinstance(handle);
+	if(setjmp(this->jerr.setjmp_buffer)) return -1;
+	if(this->init&COMPRESS) jpeg_destroy_compress(cinfo);
+	if(this->init&DECOMPRESS) jpeg_destroy_decompress(dinfo);
+	free(this);
+	return 0;
+}
+
+
+/* Compressor  */
+
+static boolean empty_output_buffer(j_compress_ptr cinfo)
 {
 	ERREXIT(cinfo, JERR_BUFFER_SIZE);
 	return TRUE;
 }
 
-static void destination_noop(struct jpeg_compress_struct *cinfo)
+static void dst_noop(j_compress_ptr cinfo)
 {
 }
 
+static tjhandle _tjInitCompress(tjinstance *this)
+{
+	/* This is also straight out of example.c */
+	this->cinfo.err=jpeg_std_error(&this->jerr.pub);
+	this->jerr.pub.error_exit=my_error_exit;
+	this->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
+		if(this) free(this);  return NULL;
+	}
+
+	jpeg_create_compress(&this->cinfo);
+	this->cinfo.dest=&this->jdst;
+	this->jdst.init_destination=dst_noop;
+	this->jdst.empty_output_buffer=empty_output_buffer;
+	this->jdst.term_destination=dst_noop;
+
+	this->init|=COMPRESS;
+	return (tjhandle)this;
+}
+
 DLLEXPORT tjhandle DLLCALL tjInitCompress(void)
 {
-	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;
+	tjinstance *this=NULL;
+	if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjInitCompress(): Memory allocation failure");
+		return NULL;
 	}
+	MEMZERO(this, sizeof(tjinstance));
+	return _tjInitCompress(this);
+}
+
 
-	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;
+DLLEXPORT unsigned long DLLCALL tjBufSize(int width, int height,
+	int jpegSubsamp)
+{
+	unsigned long retval=0;  int mcuw, mcuh, chromasf;
+	if(width<1 || height<1 || jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT)
+		_throw("tjBufSize(): Invalid argument");
 
-	j->initc=1;
-	return (tjhandle)j;
+	// This allows for rare corner cases in which a JPEG image can actually be
+	// larger than the uncompressed input (we wouldn't mention it if it hadn't
+	// happened before.)
+	mcuw=tjMCUWidth[jpegSubsamp];
+	mcuh=tjMCUHeight[jpegSubsamp];
+	chromasf=jpegSubsamp==TJSAMP_GRAY? 0: 4*64/(mcuw*mcuh);
+	retval=PAD(width, mcuw) * PAD(height, mcuh) * (2 + chromasf) + 2048;
+
+	bailout:
+	return retval;
 }
 
 
@@ -114,311 +519,332 @@ DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height)
 {
 	unsigned long retval=0;
 	if(width<1 || height<1)
-		_throw("Invalid argument in TJBUFSIZE()");
+		_throw("TJBUFSIZE(): Invalid argument");
 
 	// This allows for rare corner cases in which a JPEG image can actually be
 	// larger than the uncompressed input (we wouldn't mention it if it hadn't
 	// happened before.)
-	retval=((width+15)&(~15)) * ((height+15)&(~15)) * 6 + 2048;
+	retval=PAD(width, 16) * PAD(height, 16) * 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)
+DLLEXPORT int DLLCALL tjCompress2(tjhandle handle, unsigned char *srcBuf,
+	int width, int pitch, int height, int pixelFormat, unsigned char **jpegBuf,
+	unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
 {
 	int i, retval=0;  JSAMPROW *row_pointer=NULL;
-
-	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"
+	#ifndef JCS_EXTENSIONS
+	unsigned char *rgbBuf=NULL;
 	#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");
+	getinstance(handle)
+	if((this->init&COMPRESS)==0)
+		_throw("tjCompress2(): Instance has not been initialized for compression");
 
-	if(setjmp(j->jerr.jb))
-	{  // this will execute if LIBJPEG has an error
+	if(srcBuf==NULL || width<=0 || pitch<0 || height<=0 || pixelFormat<0
+		|| pixelFormat>=TJ_NUMPF || jpegBuf==NULL || jpegSize==NULL
+		|| jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT || jpegQual<0 || jpegQual>100)
+		_throw("tjCompress2(): Invalid argument");
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
 		retval=-1;
 		goto bailout;
 	}
 
-	jpeg_set_defaults(&j->cinfo);
+	if(pitch==0) pitch=width*tjPixelSize[pixelFormat];
 
-	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;
+	#ifndef JCS_EXTENSIONS
+	if(pixelFormat!=TJPF_GRAY)
+	{
+		rgbBuf=(unsigned char *)malloc(width*height*RGB_PIXELSIZE);
+		if(!rgbBuf) _throw("tjCompress2(): Memory allocation failure");
+		srcBuf=toRGB(srcBuf, width, pitch, height, pixelFormat, rgbBuf);
+		pitch=width*RGB_PIXELSIZE;
+	}
+	#endif
+
+	cinfo->image_width=width;
+	cinfo->image_height=height;
+
+	if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+	else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+	else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
 
-	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;
+	if(setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual)==-1)
+		return -1;
 
-	j->jdms.next_output_byte = dstbuf;
-	j->jdms.free_in_buffer = TJBUFSIZE(j->cinfo.image_width, j->cinfo.image_height);
+	this->jdst.next_output_byte=*jpegBuf;
+	this->jdst.free_in_buffer=tjBufSize(width, height, jpegSubsamp);
 
-	jpeg_start_compress(&j->cinfo, TRUE);
+	jpeg_start_compress(cinfo, TRUE);
 	if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
-		_throw("Memory allocation failed in tjCompress()");
+		_throw("tjCompress2(): Memory allocation failure");
 	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];
+		if(flags&TJFLAG_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)
+	while(cinfo->next_scanline<cinfo->image_height)
 	{
-		jpeg_write_scanlines(&j->cinfo, &row_pointer[j->cinfo.next_scanline],
-			j->cinfo.image_height-j->cinfo.next_scanline);
+		jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
+			cinfo->image_height-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);
+	jpeg_finish_compress(cinfo);
+ 	*jpegSize=tjBufSize(width, height, jpegSubsamp)
+		-(unsigned long)(this->jdst.free_in_buffer);
 
 	bailout:
-	if(j->cinfo.global_state>CSTATE_START) jpeg_abort_compress(&j->cinfo);
+	if(cinfo->global_state>CSTATE_START) jpeg_abort_compress(cinfo);
+	#ifndef JCS_EXTENSIONS
+	if(rgbBuf && rgbBuf!=srcBuf) free(rgbBuf);
+	#endif
 	if(row_pointer) free(row_pointer);
 	return retval;
 }
 
+DLLEXPORT int DLLCALL tjCompress(tjhandle handle, unsigned char *srcBuf,
+	int width, int pitch, int height, int pixelSize, unsigned char *jpegBuf,
+	unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
+{
+	int retval=0;  unsigned long size;
+	retval=tjCompress2(handle, srcBuf, width, pitch, height,
+		getPixelFormat(pixelSize, flags), &jpegBuf, &size, jpegSubsamp, jpegQual,
+		flags);
+	*jpegSize=size;
+	return retval;
+}
+
 
-// DEC
+/* Decompressor */
 
-static boolean fill_input_buffer (struct jpeg_decompress_struct *dinfo)
+static boolean fill_input_buffer(j_decompress_ptr dinfo)
 {
 	ERREXIT(dinfo, JERR_BUFFER_SIZE);
 	return TRUE;
 }
 
-static void skip_input_data (struct jpeg_decompress_struct *dinfo, long num_bytes)
+static void skip_input_data(j_decompress_ptr dinfo, long num_bytes)
 {
 	dinfo->src->next_input_byte += (size_t) num_bytes;
 	dinfo->src->bytes_in_buffer -= (size_t) num_bytes;
 }
 
-static void source_noop (struct jpeg_decompress_struct *dinfo)
+static void src_noop(j_decompress_ptr dinfo)
 {
 }
 
-DLLEXPORT tjhandle DLLCALL tjInitDecompress(void)
+static tjhandle _tjInitDecompress(tjinstance *this)
 {
-	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;
+	/* This is also straight out of example.c */
+	this->dinfo.err=jpeg_std_error(&this->jerr.pub);
+	this->jerr.pub.error_exit=my_error_exit;
+	this->jerr.pub.output_message=my_output_message;
+
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
+		if(this) free(this);  return NULL;
 	}
 
-	jpeg_create_decompress(&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;
+	jpeg_create_decompress(&this->dinfo);
+	this->dinfo.src=&this->jsrc;
+	this->jsrc.init_source=src_noop;
+	this->jsrc.fill_input_buffer=fill_input_buffer;
+	this->jsrc.skip_input_data=skip_input_data;
+	this->jsrc.resync_to_restart=jpeg_resync_to_restart;
+	this->jsrc.term_source=src_noop;
+
+	this->init|=DECOMPRESS;
+	return (tjhandle)this;
+}
 
-	j->initd=1;
-	return (tjhandle)j;
+DLLEXPORT tjhandle DLLCALL tjInitDecompress(void)
+{
+	tjinstance *this;
+	if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjInitDecompress(): Memory allocation failure");
+		return NULL;
+	}
+	MEMZERO(this, sizeof(tjinstance));
+	return _tjInitDecompress(this);
 }
 
 
-DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle h,
-	unsigned char *srcbuf, unsigned long size,
-	int *width, int *height, int *jpegsub)
+DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle handle,
+	unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height,
+	int *jpegSubsamp)
 {
-	int i, k, retval=0;
+	int retval=0;
 
-	checkhandle(h);
+	getinstance(handle);
+	if((this->init&DECOMPRESS)==0)
+		_throw("tjDecompressHeader2(): Instance has not been initialized for decompression");
 
-	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(jpegBuf==NULL || jpegSize<=0 || width==NULL || height==NULL
+		|| jpegSubsamp==NULL)
+		_throw("tjDecompressHeader2(): Invalid argument");
 
-	if(setjmp(j->jerr.jb))
-	{  // this will execute if LIBJPEG has an error
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
 		return -1;
 	}
 
-	j->jsms.bytes_in_buffer = size;
-	j->jsms.next_input_byte = srcbuf;
+	this->jsrc.bytes_in_buffer=jpegSize;
+	this->jsrc.next_input_byte=jpegBuf;
+	jpeg_read_header(dinfo, TRUE);
 
-	jpeg_read_header(&j->dinfo, TRUE);
+	*width=dinfo->image_width;
+	*height=dinfo->image_height;
+	*jpegSubsamp=getSubsamp(dinfo);
 
-	*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(dinfo);
 
-	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");
+	if(*jpegSubsamp<0)
+		_throw("tjDecompressHeader2(): Could not determine subsampling type for JPEG image");
+	if(*width<1 || *height<1)
+		_throw("tjDecompressHeader2(): Invalid data returned in header");
 
 	bailout:
 	return retval;
 }
 
+DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle handle,
+	unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height)
+{
+	int jpegSubsamp;
+	return tjDecompressHeader2(handle, jpegBuf, jpegSize, width, height,
+		&jpegSubsamp);
+}
 
-DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle h,
-	unsigned char *srcbuf, unsigned long size,
-	int *width, int *height)
+
+DLLEXPORT tjscalingfactor* DLLCALL tjGetScalingFactors(int *numscalingfactors)
 {
-	int jpegsub;
-	return tjDecompressHeader2(h, srcbuf, size, width, height, &jpegsub);
+	if(numscalingfactors==NULL)
+	{
+		snprintf(errStr, JMSG_LENGTH_MAX,
+			"tjGetScalingFactors(): Invalid argument");
+		return NULL;
+	}
+
+	*numscalingfactors=NUMSF;
+	return (tjscalingfactor *)sf;
 }
 
 
-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)
+DLLEXPORT int DLLCALL tjDecompress2(tjhandle handle, unsigned char *jpegBuf,
+	unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
+	int height, int pixelFormat, int flags)
 {
 	int i, retval=0;  JSAMPROW *row_pointer=NULL;
+	int jpegwidth, jpegheight, scaledw, scaledh;
+	#ifndef JCS_EXTENSIONS
+	unsigned char *rgbBuf=NULL;
+	unsigned char *_dstBuf=NULL;  int _pitch=0;
+	#endif
 
-	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");
+	getinstance(handle);
+	if((this->init&DECOMPRESS)==0)
+		_throw("tjDecompress2(): Instance has not been initialized for decompression");
 
-	if(pitch==0) pitch=width*ps;
+	if(jpegBuf==NULL || jpegSize<=0 || dstBuf==NULL || width<0 || pitch<0
+		|| height<0 || pixelFormat<0 || pixelFormat>=TJ_NUMPF)
+		_throw("tjDecompress2(): Invalid argument");
 
-	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(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
+	else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
+	else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
 
-	if(setjmp(j->jerr.jb))
-	{  // this will execute if LIBJPEG has an error
+	if(setjmp(this->jerr.setjmp_buffer))
+	{
+		/* If we get here, the JPEG code has signaled an error. */
 		retval=-1;
 		goto bailout;
 	}
 
-	j->jsms.bytes_in_buffer = size;
-	j->jsms.next_input_byte = srcbuf;
+	this->jsrc.bytes_in_buffer=jpegSize;
+	this->jsrc.next_input_byte=jpegBuf;
+	jpeg_read_header(dinfo, TRUE);
+	if(setDecompDefaults(dinfo, pixelFormat)==-1)
+	{
+		retval=-1;  goto bailout;
+	}
 
-	jpeg_read_header(&j->dinfo, TRUE);
+	if(flags&TJFLAG_FASTUPSAMPLE) dinfo->do_fancy_upsampling=FALSE;
 
-	if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
-		_throw("Memory allocation failed in tjDecompress()");
-	for(i=0; i<height; i++)
+	jpegwidth=dinfo->image_width;  jpegheight=dinfo->image_height;
+	if(width==0) width=jpegwidth;
+	if(height==0) height=jpegheight;
+	for(i=0; i<NUMSF; i++)
 	{
-		if(flags&TJ_BOTTOMUP) row_pointer[i]= &dstbuf[(height-i-1)*pitch];
-		else row_pointer[i]= &dstbuf[i*pitch];
+		scaledw=TJSCALED(jpegwidth, sf[i]);
+		scaledh=TJSCALED(jpegheight, sf[i]);
+		if(scaledw<=width && scaledh<=height)
+				break;
+	}
+	if(scaledw>width || scaledh>height)
+		_throw("tjDecompress2(): Could not scale down to desired image dimensions");
+	width=scaledw;  height=scaledh;
+	dinfo->scale_num=sf[i].num;
+	dinfo->scale_denom=sf[i].denom;
+
+	jpeg_start_decompress(dinfo);
+	if(pitch==0) pitch=dinfo->output_width*tjPixelSize[pixelFormat];
+
+	#ifndef JCS_EXTENSIONS
+	if(pixelFormat!=TJPF_GRAY &&
+		(RGB_RED!=tjRedOffset[pixelFormat] ||
+			RGB_GREEN!=tjGreenOffset[pixelFormat] ||
+			RGB_BLUE!=tjBlueOffset[pixelFormat] ||
+			RGB_PIXELSIZE!=tjPixelSize[pixelFormat]))
+	{
+		rgbBuf=(unsigned char *)malloc(width*height*3);
+		if(!rgbBuf) _throw("tjDecompress2(): Memory allocation failure");
+		_pitch=pitch;  pitch=width*3;
+		_dstBuf=dstBuf;  dstBuf=rgbBuf;
 	}
-
-	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)
+	if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)
+		*dinfo->output_height))==NULL)
+		_throw("tjDecompress2(): Memory allocation failure");
+	for(i=0; i<(int)dinfo->output_height; i++)
+	{
+		if(flags&TJFLAG_BOTTOMUP)
+			row_pointer[i]=&dstBuf[(dinfo->output_height-i-1)*pitch];
+		else row_pointer[i]=&dstBuf[i*pitch];
+	}
+	while(dinfo->output_scanline<dinfo->output_height)
 	{
-		jpeg_read_scanlines(&j->dinfo, &row_pointer[j->dinfo.output_scanline],
-			j->dinfo.output_height-j->dinfo.output_scanline);
+		jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
+			dinfo->output_height-dinfo->output_scanline);
 	}
-	jpeg_finish_decompress(&j->dinfo);
+	jpeg_finish_decompress(dinfo);
+
+	#ifndef JCS_EXTENSIONS
+	fromRGB(rgbBuf, _dstBuf, width, _pitch, height, pixelFormat);
+	#endif
 
 	bailout:
-	if(j->dinfo.global_state>DSTATE_START) jpeg_abort_decompress(&j->dinfo);
+	if(dinfo->global_state>DSTATE_START) jpeg_abort_decompress(dinfo);
+	#ifndef JCS_EXTENSIONS
+	if(rgbBuf && rgbBuf!=dstBuf) free(rgbBuf);
+	#endif
 	if(row_pointer) free(row_pointer);
 	return retval;
 }
 
-
-// General
-
-DLLEXPORT char* DLLCALL tjGetErrorStr(void)
-{
-	return lasterror;
-}
-
-DLLEXPORT int DLLCALL tjDestroy(tjhandle h)
+DLLEXPORT int DLLCALL tjDecompress(tjhandle handle, unsigned char *jpegBuf,
+	unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
+	int height, int pixelSize, int flags)
 {
-	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;
+	return tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, width, pitch,
+		height, getPixelFormat(pixelSize, flags), flags);
 }