diff options
Diffstat (limited to 'common')
| -rw-r--r-- | common/turbojpeg.c | 424 | ||||
| -rw-r--r-- | common/turbojpeg.h | 255 |
2 files changed, 679 insertions, 0 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 |