Christian Beier
13 years ago
commit
413ca0dfef
@ -0,0 +1,849 @@
|
||||
/*
|
||||
* Copyright (C)2009-2012 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* TurboJPEG/OSS: this implements the TurboJPEG API using libjpeg-turbo */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifndef JCS_EXTENSIONS
|
||||
#define JPEG_INTERNAL_OPTIONS
|
||||
#endif
|
||||
#include <jpeglib.h>
|
||||
#include <jerror.h>
|
||||
#include <setjmp.h>
|
||||
#include "./turbojpeg.h"
|
||||
|
||||
#define PAD(v, p) ((v+(p)-1)&(~((p)-1)))
|
||||
|
||||
#define CSTATE_START 100
|
||||
#define DSTATE_START 200
|
||||
#define MEMZERO(ptr, size) memset(ptr, 0, size)
|
||||
|
||||
#ifndef min
|
||||
#define min(a,b) ((a)<(b)?(a):(b))
|
||||
#endif
|
||||
|
||||
#ifndef max
|
||||
#define max(a,b) ((a)>(b)?(a):(b))
|
||||
#endif
|
||||
|
||||
|
||||
/* Error handling (based on example in example.c) */
|
||||
|
||||
static char errStr[JMSG_LENGTH_MAX]="No error";
|
||||
|
||||
struct my_error_mgr
|
||||
{
|
||||
struct jpeg_error_mgr pub;
|
||||
jmp_buf setjmp_buffer;
|
||||
};
|
||||
typedef struct my_error_mgr *my_error_ptr;
|
||||
|
||||
static void my_error_exit(j_common_ptr cinfo)
|
||||
{
|
||||
my_error_ptr myerr=(my_error_ptr)cinfo->err;
|
||||
(*cinfo->err->output_message)(cinfo);
|
||||
longjmp(myerr->setjmp_buffer, 1);
|
||||
}
|
||||
|
||||
/* Based on output_message() in jerror.c */
|
||||
|
||||
static void my_output_message(j_common_ptr cinfo)
|
||||
{
|
||||
(*cinfo->err->format_message)(cinfo, errStr);
|
||||
}
|
||||
|
||||
|
||||
/* Global structures, macros, etc. */
|
||||
|
||||
enum {COMPRESS=1, DECOMPRESS=2};
|
||||
|
||||
typedef struct _tjinstance
|
||||
{
|
||||
struct jpeg_compress_struct cinfo;
|
||||
struct jpeg_decompress_struct dinfo;
|
||||
struct jpeg_destination_mgr jdst;
|
||||
struct jpeg_source_mgr jsrc;
|
||||
struct my_error_mgr jerr;
|
||||
int init;
|
||||
} tjinstance;
|
||||
|
||||
static const int pixelsize[TJ_NUMSAMP]={3, 3, 3, 1, 3};
|
||||
|
||||
#define NUMSF 4
|
||||
static const tjscalingfactor sf[NUMSF]={
|
||||
{1, 1},
|
||||
{1, 2},
|
||||
{1, 4},
|
||||
{1, 8}
|
||||
};
|
||||
|
||||
#define _throw(m) {snprintf(errStr, JMSG_LENGTH_MAX, "%s", m); \
|
||||
retval=-1; goto bailout;}
|
||||
#define getinstance(handle) tjinstance *this=(tjinstance *)handle; \
|
||||
j_compress_ptr cinfo=NULL; j_decompress_ptr dinfo=NULL; \
|
||||
if(!this) {snprintf(errStr, JMSG_LENGTH_MAX, "Invalid handle"); \
|
||||
return -1;} \
|
||||
cinfo=&this->cinfo; dinfo=&this->dinfo;
|
||||
|
||||
static int getPixelFormat(int pixelSize, int flags)
|
||||
{
|
||||
if(pixelSize==1) return TJPF_GRAY;
|
||||
if(pixelSize==3)
|
||||
{
|
||||
if(flags&TJ_BGR) return TJPF_BGR;
|
||||
else return TJPF_RGB;
|
||||
}
|
||||
if(pixelSize==4)
|
||||
{
|
||||
if(flags&TJ_ALPHAFIRST)
|
||||
{
|
||||
if(flags&TJ_BGR) return TJPF_XBGR;
|
||||
else return TJPF_XRGB;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(flags&TJ_BGR) return TJPF_BGRX;
|
||||
else return TJPF_RGBX;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int setCompDefaults(struct jpeg_compress_struct *cinfo,
|
||||
int pixelFormat, int subsamp, int jpegQual)
|
||||
{
|
||||
int retval=0;
|
||||
|
||||
switch(pixelFormat)
|
||||
{
|
||||
case TJPF_GRAY:
|
||||
cinfo->in_color_space=JCS_GRAYSCALE; break;
|
||||
#if JCS_EXTENSIONS==1
|
||||
case TJPF_RGB:
|
||||
cinfo->in_color_space=JCS_EXT_RGB; break;
|
||||
case TJPF_BGR:
|
||||
cinfo->in_color_space=JCS_EXT_BGR; break;
|
||||
case TJPF_RGBX:
|
||||
case TJPF_RGBA:
|
||||
cinfo->in_color_space=JCS_EXT_RGBX; break;
|
||||
case TJPF_BGRX:
|
||||
case TJPF_BGRA:
|
||||
cinfo->in_color_space=JCS_EXT_BGRX; break;
|
||||
case TJPF_XRGB:
|
||||
case TJPF_ARGB:
|
||||
cinfo->in_color_space=JCS_EXT_XRGB; break;
|
||||
case TJPF_XBGR:
|
||||
case TJPF_ABGR:
|
||||
cinfo->in_color_space=JCS_EXT_XBGR; break;
|
||||
#else
|
||||
case TJPF_RGB:
|
||||
case TJPF_BGR:
|
||||
case TJPF_RGBX:
|
||||
case TJPF_BGRX:
|
||||
case TJPF_XRGB:
|
||||
case TJPF_XBGR:
|
||||
case TJPF_RGBA:
|
||||
case TJPF_BGRA:
|
||||
case TJPF_ARGB:
|
||||
case TJPF_ABGR:
|
||||
cinfo->in_color_space=JCS_RGB; pixelFormat=TJPF_RGB;
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
cinfo->input_components=tjPixelSize[pixelFormat];
|
||||
jpeg_set_defaults(cinfo);
|
||||
if(jpegQual>=0)
|
||||
{
|
||||
jpeg_set_quality(cinfo, jpegQual, TRUE);
|
||||
if(jpegQual>=96) cinfo->dct_method=JDCT_ISLOW;
|
||||
else cinfo->dct_method=JDCT_FASTEST;
|
||||
}
|
||||
if(subsamp==TJSAMP_GRAY)
|
||||
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
|
||||
else
|
||||
jpeg_set_colorspace(cinfo, JCS_YCbCr);
|
||||
|
||||
cinfo->comp_info[0].h_samp_factor=tjMCUWidth[subsamp]/8;
|
||||
cinfo->comp_info[1].h_samp_factor=1;
|
||||
cinfo->comp_info[2].h_samp_factor=1;
|
||||
cinfo->comp_info[0].v_samp_factor=tjMCUHeight[subsamp]/8;
|
||||
cinfo->comp_info[1].v_samp_factor=1;
|
||||
cinfo->comp_info[2].v_samp_factor=1;
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int setDecompDefaults(struct jpeg_decompress_struct *dinfo,
|
||||
int pixelFormat)
|
||||
{
|
||||
int retval=0;
|
||||
|
||||
switch(pixelFormat)
|
||||
{
|
||||
case TJPF_GRAY:
|
||||
dinfo->out_color_space=JCS_GRAYSCALE; break;
|
||||
#if JCS_EXTENSIONS==1
|
||||
case TJPF_RGB:
|
||||
dinfo->out_color_space=JCS_EXT_RGB; break;
|
||||
case TJPF_BGR:
|
||||
dinfo->out_color_space=JCS_EXT_BGR; break;
|
||||
case TJPF_RGBX:
|
||||
dinfo->out_color_space=JCS_EXT_RGBX; break;
|
||||
case TJPF_BGRX:
|
||||
dinfo->out_color_space=JCS_EXT_BGRX; break;
|
||||
case TJPF_XRGB:
|
||||
dinfo->out_color_space=JCS_EXT_XRGB; break;
|
||||
case TJPF_XBGR:
|
||||
dinfo->out_color_space=JCS_EXT_XBGR; break;
|
||||
#if JCS_ALPHA_EXTENSIONS==1
|
||||
case TJPF_RGBA:
|
||||
dinfo->out_color_space=JCS_EXT_RGBA; break;
|
||||
case TJPF_BGRA:
|
||||
dinfo->out_color_space=JCS_EXT_BGRA; break;
|
||||
case TJPF_ARGB:
|
||||
dinfo->out_color_space=JCS_EXT_ARGB; break;
|
||||
case TJPF_ABGR:
|
||||
dinfo->out_color_space=JCS_EXT_ABGR; break;
|
||||
#endif
|
||||
#else
|
||||
case TJPF_RGB:
|
||||
case TJPF_BGR:
|
||||
case TJPF_RGBX:
|
||||
case TJPF_BGRX:
|
||||
case TJPF_XRGB:
|
||||
case TJPF_XBGR:
|
||||
case TJPF_RGBA:
|
||||
case TJPF_BGRA:
|
||||
case TJPF_ARGB:
|
||||
case TJPF_ABGR:
|
||||
dinfo->out_color_space=JCS_RGB; break;
|
||||
#endif
|
||||
default:
|
||||
_throw("Unsupported pixel format");
|
||||
}
|
||||
|
||||
bailout:
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
static int getSubsamp(j_decompress_ptr dinfo)
|
||||
{
|
||||
int retval=-1, i, k;
|
||||
for(i=0; i<NUMSUBOPT; i++)
|
||||
{
|
||||
if(dinfo->num_components==pixelsize[i])
|
||||
{
|
||||
if(dinfo->comp_info[0].h_samp_factor==tjMCUWidth[i]/8
|
||||
&& dinfo->comp_info[0].v_samp_factor==tjMCUHeight[i]/8)
|
||||
{
|
||||
int match=0;
|
||||
for(k=1; k<dinfo->num_components; k++)
|
||||
{
|
||||
if(dinfo->comp_info[k].h_samp_factor==1
|
||||
&& dinfo->comp_info[k].v_samp_factor==1)
|
||||
match++;
|
||||
}
|
||||
if(match==dinfo->num_components-1)
|
||||
{
|
||||
retval=i; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
#ifndef JCS_EXTENSIONS
|
||||
|
||||
/* Conversion functions to emulate the colorspace extensions. This allows the
|
||||
TurboJPEG wrapper to be used with libjpeg */
|
||||
|
||||
#define TORGB(PS, ROFFSET, GOFFSET, BOFFSET) { \
|
||||
int rowPad=pitch-width*PS; \
|
||||
while(height--) \
|
||||
{ \
|
||||
unsigned char *endOfRow=src+width*PS; \
|
||||
while(src<endOfRow) \
|
||||
{ \
|
||||
dst[RGB_RED]=src[ROFFSET]; \
|
||||
dst[RGB_GREEN]=src[GOFFSET]; \
|
||||
dst[RGB_BLUE]=src[BOFFSET]; \
|
||||
dst+=RGB_PIXELSIZE; src+=PS; \
|
||||
} \
|
||||
src+=rowPad; \
|
||||
} \
|
||||
}
|
||||
|
||||
static unsigned char *toRGB(unsigned char *src, int width, int pitch,
|
||||
int height, int pixelFormat, unsigned char *dst)
|
||||
{
|
||||
unsigned char *retval=src;
|
||||
switch(pixelFormat)
|
||||
{
|
||||
case TJPF_RGB:
|
||||
#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
|
||||
retval=dst; TORGB(3, 0, 1, 2);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_BGR:
|
||||
#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
|
||||
retval=dst; TORGB(3, 2, 1, 0);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_RGBX:
|
||||
case TJPF_RGBA:
|
||||
#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
|
||||
retval=dst; TORGB(4, 0, 1, 2);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_BGRX:
|
||||
case TJPF_BGRA:
|
||||
#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
|
||||
retval=dst; TORGB(4, 2, 1, 0);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_XRGB:
|
||||
case TJPF_ARGB:
|
||||
#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
|
||||
retval=dst; TORGB(4, 1, 2, 3);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_XBGR:
|
||||
case TJPF_ABGR:
|
||||
#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
|
||||
retval=dst; TORGB(4, 3, 2, 1);
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
#define FROMRGB(PS, ROFFSET, GOFFSET, BOFFSET, SETALPHA) { \
|
||||
int rowPad=pitch-width*PS; \
|
||||
while(height--) \
|
||||
{ \
|
||||
unsigned char *endOfRow=dst+width*PS; \
|
||||
while(dst<endOfRow) \
|
||||
{ \
|
||||
dst[ROFFSET]=src[RGB_RED]; \
|
||||
dst[GOFFSET]=src[RGB_GREEN]; \
|
||||
dst[BOFFSET]=src[RGB_BLUE]; \
|
||||
SETALPHA \
|
||||
dst+=PS; src+=RGB_PIXELSIZE; \
|
||||
} \
|
||||
dst+=rowPad; \
|
||||
} \
|
||||
}
|
||||
|
||||
static void fromRGB(unsigned char *src, unsigned char *dst, int width,
|
||||
int pitch, int height, int pixelFormat)
|
||||
{
|
||||
switch(pixelFormat)
|
||||
{
|
||||
case TJPF_RGB:
|
||||
#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=3
|
||||
FROMRGB(3, 0, 1, 2,);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_BGR:
|
||||
#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=3
|
||||
FROMRGB(3, 2, 1, 0,);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_RGBX:
|
||||
#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 0, 1, 2,);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_RGBA:
|
||||
#if RGB_RED!=0 || RGB_GREEN!=1 || RGB_BLUE!=2 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 0, 1, 2, dst[3]=0xFF;);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_BGRX:
|
||||
#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 2, 1, 0,);
|
||||
#endif
|
||||
break;
|
||||
case TJPF_BGRA:
|
||||
#if RGB_RED!=2 || RGB_GREEN!=1 || RGB_BLUE!=0 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 2, 1, 0, dst[3]=0xFF;); return;
|
||||
#endif
|
||||
break;
|
||||
case TJPF_XRGB:
|
||||
#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 1, 2, 3,); return;
|
||||
#endif
|
||||
break;
|
||||
case TJPF_ARGB:
|
||||
#if RGB_RED!=1 || RGB_GREEN!=2 || RGB_BLUE!=3 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 1, 2, 3, dst[0]=0xFF;); return;
|
||||
#endif
|
||||
break;
|
||||
case TJPF_XBGR:
|
||||
#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 3, 2, 1,); return;
|
||||
#endif
|
||||
break;
|
||||
case TJPF_ABGR:
|
||||
#if RGB_RED!=3 || RGB_GREEN!=2 || RGB_BLUE!=1 || RGB_PIXELSIZE!=4
|
||||
FROMRGB(4, 3, 2, 1, dst[0]=0xFF;); return;
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* General API functions */
|
||||
|
||||
DLLEXPORT char* DLLCALL tjGetErrorStr(void)
|
||||
{
|
||||
return errStr;
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT int DLLCALL tjDestroy(tjhandle handle)
|
||||
{
|
||||
getinstance(handle);
|
||||
if(setjmp(this->jerr.setjmp_buffer)) return -1;
|
||||
if(this->init&COMPRESS) jpeg_destroy_compress(cinfo);
|
||||
if(this->init&DECOMPRESS) jpeg_destroy_decompress(dinfo);
|
||||
free(this);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Compressor */
|
||||
|
||||
static boolean empty_output_buffer(j_compress_ptr cinfo)
|
||||
{
|
||||
ERREXIT(cinfo, JERR_BUFFER_SIZE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void dst_noop(j_compress_ptr cinfo)
|
||||
{
|
||||
}
|
||||
|
||||
static tjhandle _tjInitCompress(tjinstance *this)
|
||||
{
|
||||
/* This is also straight out of example.c */
|
||||
this->cinfo.err=jpeg_std_error(&this->jerr.pub);
|
||||
this->jerr.pub.error_exit=my_error_exit;
|
||||
this->jerr.pub.output_message=my_output_message;
|
||||
|
||||
if(setjmp(this->jerr.setjmp_buffer))
|
||||
{
|
||||
/* If we get here, the JPEG code has signaled an error. */
|
||||
if(this) free(this); return NULL;
|
||||
}
|
||||
|
||||
jpeg_create_compress(&this->cinfo);
|
||||
this->cinfo.dest=&this->jdst;
|
||||
this->jdst.init_destination=dst_noop;
|
||||
this->jdst.empty_output_buffer=empty_output_buffer;
|
||||
this->jdst.term_destination=dst_noop;
|
||||
|
||||
this->init|=COMPRESS;
|
||||
return (tjhandle)this;
|
||||
}
|
||||
|
||||
DLLEXPORT tjhandle DLLCALL tjInitCompress(void)
|
||||
{
|
||||
tjinstance *this=NULL;
|
||||
if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
|
||||
{
|
||||
snprintf(errStr, JMSG_LENGTH_MAX,
|
||||
"tjInitCompress(): Memory allocation failure");
|
||||
return NULL;
|
||||
}
|
||||
MEMZERO(this, sizeof(tjinstance));
|
||||
return _tjInitCompress(this);
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT unsigned long DLLCALL tjBufSize(int width, int height,
|
||||
int jpegSubsamp)
|
||||
{
|
||||
unsigned long retval=0; int mcuw, mcuh, chromasf;
|
||||
if(width<1 || height<1 || jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT)
|
||||
_throw("tjBufSize(): Invalid argument");
|
||||
|
||||
// This allows for rare corner cases in which a JPEG image can actually be
|
||||
// larger than the uncompressed input (we wouldn't mention it if it hadn't
|
||||
// happened before.)
|
||||
mcuw=tjMCUWidth[jpegSubsamp];
|
||||
mcuh=tjMCUHeight[jpegSubsamp];
|
||||
chromasf=jpegSubsamp==TJSAMP_GRAY? 0: 4*64/(mcuw*mcuh);
|
||||
retval=PAD(width, mcuw) * PAD(height, mcuh) * (2 + chromasf) + 2048;
|
||||
|
||||
bailout:
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height)
|
||||
{
|
||||
unsigned long retval=0;
|
||||
if(width<1 || height<1)
|
||||
_throw("TJBUFSIZE(): Invalid argument");
|
||||
|
||||
// This allows for rare corner cases in which a JPEG image can actually be
|
||||
// larger than the uncompressed input (we wouldn't mention it if it hadn't
|
||||
// happened before.)
|
||||
retval=PAD(width, 16) * PAD(height, 16) * 6 + 2048;
|
||||
|
||||
bailout:
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT int DLLCALL tjCompress2(tjhandle handle, unsigned char *srcBuf,
|
||||
int width, int pitch, int height, int pixelFormat, unsigned char **jpegBuf,
|
||||
unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
|
||||
{
|
||||
int i, retval=0; JSAMPROW *row_pointer=NULL;
|
||||
#ifndef JCS_EXTENSIONS
|
||||
unsigned char *rgbBuf=NULL;
|
||||
#endif
|
||||
|
||||
getinstance(handle)
|
||||
if((this->init&COMPRESS)==0)
|
||||
_throw("tjCompress2(): Instance has not been initialized for compression");
|
||||
|
||||
if(srcBuf==NULL || width<=0 || pitch<0 || height<=0 || pixelFormat<0
|
||||
|| pixelFormat>=TJ_NUMPF || jpegBuf==NULL || jpegSize==NULL
|
||||
|| jpegSubsamp<0 || jpegSubsamp>=NUMSUBOPT || jpegQual<0 || jpegQual>100)
|
||||
_throw("tjCompress2(): Invalid argument");
|
||||
|
||||
if(setjmp(this->jerr.setjmp_buffer))
|
||||
{
|
||||
/* If we get here, the JPEG code has signaled an error. */
|
||||
retval=-1;
|
||||
goto bailout;
|
||||
}
|
||||
|
||||
if(pitch==0) pitch=width*tjPixelSize[pixelFormat];
|
||||
|
||||
#ifndef JCS_EXTENSIONS
|
||||
if(pixelFormat!=TJPF_GRAY)
|
||||
{
|
||||
rgbBuf=(unsigned char *)malloc(width*height*RGB_PIXELSIZE);
|
||||
if(!rgbBuf) _throw("tjCompress2(): Memory allocation failure");
|
||||
srcBuf=toRGB(srcBuf, width, pitch, height, pixelFormat, rgbBuf);
|
||||
pitch=width*RGB_PIXELSIZE;
|
||||
}
|
||||
#endif
|
||||
|
||||
cinfo->image_width=width;
|
||||
cinfo->image_height=height;
|
||||
|
||||
if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
|
||||
else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
|
||||
else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
|
||||
|
||||
if(setCompDefaults(cinfo, pixelFormat, jpegSubsamp, jpegQual)==-1)
|
||||
return -1;
|
||||
|
||||
this->jdst.next_output_byte=*jpegBuf;
|
||||
this->jdst.free_in_buffer=tjBufSize(width, height, jpegSubsamp);
|
||||
|
||||
jpeg_start_compress(cinfo, TRUE);
|
||||
if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)*height))==NULL)
|
||||
_throw("tjCompress2(): Memory allocation failure");
|
||||
for(i=0; i<height; i++)
|
||||
{
|
||||
if(flags&TJFLAG_BOTTOMUP) row_pointer[i]=&srcBuf[(height-i-1)*pitch];
|
||||
else row_pointer[i]=&srcBuf[i*pitch];
|
||||
}
|
||||
while(cinfo->next_scanline<cinfo->image_height)
|
||||
{
|
||||
jpeg_write_scanlines(cinfo, &row_pointer[cinfo->next_scanline],
|
||||
cinfo->image_height-cinfo->next_scanline);
|
||||
}
|
||||
jpeg_finish_compress(cinfo);
|
||||
*jpegSize=tjBufSize(width, height, jpegSubsamp)
|
||||
-(unsigned long)(this->jdst.free_in_buffer);
|
||||
|
||||
bailout:
|
||||
if(cinfo->global_state>CSTATE_START) jpeg_abort_compress(cinfo);
|
||||
#ifndef JCS_EXTENSIONS
|
||||
if(rgbBuf) free(rgbBuf);
|
||||
#endif
|
||||
if(row_pointer) free(row_pointer);
|
||||
return retval;
|
||||
}
|
||||
|
||||
DLLEXPORT int DLLCALL tjCompress(tjhandle handle, unsigned char *srcBuf,
|
||||
int width, int pitch, int height, int pixelSize, unsigned char *jpegBuf,
|
||||
unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags)
|
||||
{
|
||||
int retval=0; unsigned long size;
|
||||
retval=tjCompress2(handle, srcBuf, width, pitch, height,
|
||||
getPixelFormat(pixelSize, flags), &jpegBuf, &size, jpegSubsamp, jpegQual,
|
||||
flags);
|
||||
*jpegSize=size;
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
/* Decompressor */
|
||||
|
||||
static boolean fill_input_buffer(j_decompress_ptr dinfo)
|
||||
{
|
||||
ERREXIT(dinfo, JERR_BUFFER_SIZE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void skip_input_data(j_decompress_ptr dinfo, long num_bytes)
|
||||
{
|
||||
dinfo->src->next_input_byte += (size_t) num_bytes;
|
||||
dinfo->src->bytes_in_buffer -= (size_t) num_bytes;
|
||||
}
|
||||
|
||||
static void src_noop(j_decompress_ptr dinfo)
|
||||
{
|
||||
}
|
||||
|
||||
static tjhandle _tjInitDecompress(tjinstance *this)
|
||||
{
|
||||
/* This is also straight out of example.c */
|
||||
this->dinfo.err=jpeg_std_error(&this->jerr.pub);
|
||||
this->jerr.pub.error_exit=my_error_exit;
|
||||
this->jerr.pub.output_message=my_output_message;
|
||||
|
||||
if(setjmp(this->jerr.setjmp_buffer))
|
||||
{
|
||||
/* If we get here, the JPEG code has signaled an error. */
|
||||
if(this) free(this); return NULL;
|
||||
}
|
||||
|
||||
jpeg_create_decompress(&this->dinfo);
|
||||
this->dinfo.src=&this->jsrc;
|
||||
this->jsrc.init_source=src_noop;
|
||||
this->jsrc.fill_input_buffer=fill_input_buffer;
|
||||
this->jsrc.skip_input_data=skip_input_data;
|
||||
this->jsrc.resync_to_restart=jpeg_resync_to_restart;
|
||||
this->jsrc.term_source=src_noop;
|
||||
|
||||
this->init|=DECOMPRESS;
|
||||
return (tjhandle)this;
|
||||
}
|
||||
|
||||
DLLEXPORT tjhandle DLLCALL tjInitDecompress(void)
|
||||
{
|
||||
tjinstance *this;
|
||||
if((this=(tjinstance *)malloc(sizeof(tjinstance)))==NULL)
|
||||
{
|
||||
snprintf(errStr, JMSG_LENGTH_MAX,
|
||||
"tjInitDecompress(): Memory allocation failure");
|
||||
return NULL;
|
||||
}
|
||||
MEMZERO(this, sizeof(tjinstance));
|
||||
return _tjInitDecompress(this);
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height,
|
||||
int *jpegSubsamp)
|
||||
{
|
||||
int retval=0;
|
||||
|
||||
getinstance(handle);
|
||||
if((this->init&DECOMPRESS)==0)
|
||||
_throw("tjDecompressHeader2(): Instance has not been initialized for decompression");
|
||||
|
||||
if(jpegBuf==NULL || jpegSize<=0 || width==NULL || height==NULL
|
||||
|| jpegSubsamp==NULL)
|
||||
_throw("tjDecompressHeader2(): Invalid argument");
|
||||
|
||||
if(setjmp(this->jerr.setjmp_buffer))
|
||||
{
|
||||
/* If we get here, the JPEG code has signaled an error. */
|
||||
return -1;
|
||||
}
|
||||
|
||||
this->jsrc.bytes_in_buffer=jpegSize;
|
||||
this->jsrc.next_input_byte=jpegBuf;
|
||||
jpeg_read_header(dinfo, TRUE);
|
||||
|
||||
*width=dinfo->image_width;
|
||||
*height=dinfo->image_height;
|
||||
*jpegSubsamp=getSubsamp(dinfo);
|
||||
|
||||
jpeg_abort_decompress(dinfo);
|
||||
|
||||
if(*jpegSubsamp<0)
|
||||
_throw("tjDecompressHeader2(): Could not determine subsampling type for JPEG image");
|
||||
if(*width<1 || *height<1)
|
||||
_throw("tjDecompressHeader2(): Invalid data returned in header");
|
||||
|
||||
bailout:
|
||||
return retval;
|
||||
}
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height)
|
||||
{
|
||||
int jpegSubsamp;
|
||||
return tjDecompressHeader2(handle, jpegBuf, jpegSize, width, height,
|
||||
&jpegSubsamp);
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT tjscalingfactor* DLLCALL tjGetScalingFactors(int *numscalingfactors)
|
||||
{
|
||||
if(numscalingfactors==NULL)
|
||||
{
|
||||
snprintf(errStr, JMSG_LENGTH_MAX,
|
||||
"tjGetScalingFactors(): Invalid argument");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
*numscalingfactors=NUMSF;
|
||||
return (tjscalingfactor *)sf;
|
||||
}
|
||||
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompress2(tjhandle handle, unsigned char *jpegBuf,
|
||||
unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
|
||||
int height, int pixelFormat, int flags)
|
||||
{
|
||||
int i, retval=0; JSAMPROW *row_pointer=NULL;
|
||||
int jpegwidth, jpegheight, scaledw, scaledh;
|
||||
#ifndef JCS_EXTENSIONS
|
||||
unsigned char *rgbBuf=NULL;
|
||||
unsigned char *_dstBuf=NULL; int _pitch=0;
|
||||
#endif
|
||||
|
||||
getinstance(handle);
|
||||
if((this->init&DECOMPRESS)==0)
|
||||
_throw("tjDecompress2(): Instance has not been initialized for decompression");
|
||||
|
||||
if(jpegBuf==NULL || jpegSize<=0 || dstBuf==NULL || width<0 || pitch<0
|
||||
|| height<0 || pixelFormat<0 || pixelFormat>=TJ_NUMPF)
|
||||
_throw("tjDecompress2(): Invalid argument");
|
||||
|
||||
if(flags&TJFLAG_FORCEMMX) putenv("JSIMD_FORCEMMX=1");
|
||||
else if(flags&TJFLAG_FORCESSE) putenv("JSIMD_FORCESSE=1");
|
||||
else if(flags&TJFLAG_FORCESSE2) putenv("JSIMD_FORCESSE2=1");
|
||||
|
||||
if(setjmp(this->jerr.setjmp_buffer))
|
||||
{
|
||||
/* If we get here, the JPEG code has signaled an error. */
|
||||
retval=-1;
|
||||
goto bailout;
|
||||
}
|
||||
|
||||
this->jsrc.bytes_in_buffer=jpegSize;
|
||||
this->jsrc.next_input_byte=jpegBuf;
|
||||
jpeg_read_header(dinfo, TRUE);
|
||||
if(setDecompDefaults(dinfo, pixelFormat)==-1)
|
||||
{
|
||||
retval=-1; goto bailout;
|
||||
}
|
||||
|
||||
if(flags&TJFLAG_FASTUPSAMPLE) dinfo->do_fancy_upsampling=FALSE;
|
||||
|
||||
jpegwidth=dinfo->image_width; jpegheight=dinfo->image_height;
|
||||
if(width==0) width=jpegwidth;
|
||||
if(height==0) height=jpegheight;
|
||||
for(i=0; i<NUMSF; i++)
|
||||
{
|
||||
scaledw=TJSCALED(jpegwidth, sf[i]);
|
||||
scaledh=TJSCALED(jpegheight, sf[i]);
|
||||
if(scaledw<=width && scaledh<=height)
|
||||
break;
|
||||
}
|
||||
if(scaledw>width || scaledh>height)
|
||||
_throw("tjDecompress2(): Could not scale down to desired image dimensions");
|
||||
width=scaledw; height=scaledh;
|
||||
dinfo->scale_num=sf[i].num;
|
||||
dinfo->scale_denom=sf[i].denom;
|
||||
|
||||
jpeg_start_decompress(dinfo);
|
||||
if(pitch==0) pitch=dinfo->output_width*tjPixelSize[pixelFormat];
|
||||
|
||||
#ifndef JCS_EXTENSIONS
|
||||
if(pixelFormat!=TJPF_GRAY &&
|
||||
(RGB_RED!=tjRedOffset[pixelFormat] ||
|
||||
RGB_GREEN!=tjGreenOffset[pixelFormat] ||
|
||||
RGB_BLUE!=tjBlueOffset[pixelFormat] ||
|
||||
RGB_PIXELSIZE!=tjPixelSize[pixelFormat]))
|
||||
{
|
||||
rgbBuf=(unsigned char *)malloc(width*height*3);
|
||||
if(!rgbBuf) _throw("tjDecompress2(): Memory allocation failure");
|
||||
_pitch=pitch; pitch=width*3;
|
||||
_dstBuf=dstBuf; dstBuf=rgbBuf;
|
||||
}
|
||||
#endif
|
||||
|
||||
if((row_pointer=(JSAMPROW *)malloc(sizeof(JSAMPROW)
|
||||
*dinfo->output_height))==NULL)
|
||||
_throw("tjDecompress2(): Memory allocation failure");
|
||||
for(i=0; i<(int)dinfo->output_height; i++)
|
||||
{
|
||||
if(flags&TJFLAG_BOTTOMUP)
|
||||
row_pointer[i]=&dstBuf[(dinfo->output_height-i-1)*pitch];
|
||||
else row_pointer[i]=&dstBuf[i*pitch];
|
||||
}
|
||||
while(dinfo->output_scanline<dinfo->output_height)
|
||||
{
|
||||
jpeg_read_scanlines(dinfo, &row_pointer[dinfo->output_scanline],
|
||||
dinfo->output_height-dinfo->output_scanline);
|
||||
}
|
||||
jpeg_finish_decompress(dinfo);
|
||||
|
||||
#ifndef JCS_EXTENSIONS
|
||||
fromRGB(rgbBuf, _dstBuf, width, _pitch, height, pixelFormat);
|
||||
#endif
|
||||
|
||||
bailout:
|
||||
if(dinfo->global_state>DSTATE_START) jpeg_abort_decompress(dinfo);
|
||||
#ifndef JCS_EXTENSIONS
|
||||
if(rgbBuf) free(rgbBuf);
|
||||
#endif
|
||||
if(row_pointer) free(row_pointer);
|
||||
return retval;
|
||||
}
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompress(tjhandle handle, unsigned char *jpegBuf,
|
||||
unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch,
|
||||
int height, int pixelSize, int flags)
|
||||
{
|
||||
return tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, width, pitch,
|
||||
height, getPixelFormat(pixelSize, flags), flags);
|
||||
}
|
||||
@ -0,0 +1,529 @@
|
||||
/*
|
||||
* Copyright (C)2009-2012 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __TURBOJPEG_H__
|
||||
#define __TURBOJPEG_H__
|
||||
|
||||
#if defined(_WIN32) && defined(DLLDEFINE)
|
||||
#define DLLEXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define DLLEXPORT
|
||||
#endif
|
||||
#define DLLCALL
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup TurboJPEG Lite
|
||||
* TurboJPEG API. This API provides an interface for generating and decoding
|
||||
* JPEG images in memory.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* The number of chrominance subsampling options
|
||||
*/
|
||||
#define TJ_NUMSAMP 5
|
||||
|
||||
/**
|
||||
* Chrominance subsampling options.
|
||||
* When an image is converted from the RGB to the YCbCr colorspace as part of
|
||||
* the JPEG compression process, some of the Cb and Cr (chrominance) components
|
||||
* can be discarded or averaged together to produce a smaller image with little
|
||||
* perceptible loss of image clarity (the human eye is more sensitive to small
|
||||
* changes in brightness than small changes in color.) This is called
|
||||
* "chrominance subsampling".
|
||||
*/
|
||||
enum TJSAMP
|
||||
{
|
||||
/**
|
||||
* 4:4:4 chrominance subsampling (no chrominance subsampling). The JPEG or
|
||||
* YUV image will contain one chrominance component for every pixel in the
|
||||
* source image.
|
||||
*/
|
||||
TJSAMP_444=0,
|
||||
/**
|
||||
* 4:2:2 chrominance subsampling. The JPEG or YUV image will contain one
|
||||
* chrominance component for every 2x1 block of pixels in the source image.
|
||||
*/
|
||||
TJSAMP_422,
|
||||
/**
|
||||
* 4:2:0 chrominance subsampling. The JPEG or YUV image will contain one
|
||||
* chrominance component for every 2x2 block of pixels in the source image.
|
||||
*/
|
||||
TJSAMP_420,
|
||||
/**
|
||||
* Grayscale. The JPEG or YUV image will contain no chrominance components.
|
||||
*/
|
||||
TJSAMP_GRAY,
|
||||
/**
|
||||
* 4:4:0 chrominance subsampling. The JPEG or YUV image will contain one
|
||||
* chrominance component for every 1x2 block of pixels in the source image.
|
||||
*/
|
||||
TJSAMP_440
|
||||
};
|
||||
|
||||
/**
|
||||
* MCU block width (in pixels) for a given level of chrominance subsampling.
|
||||
* MCU block sizes:
|
||||
* - 8x8 for no subsampling or grayscale
|
||||
* - 16x8 for 4:2:2
|
||||
* - 8x16 for 4:4:0
|
||||
* - 16x16 for 4:2:0
|
||||
*/
|
||||
static const int tjMCUWidth[TJ_NUMSAMP] = {8, 16, 16, 8, 8};
|
||||
|
||||
/**
|
||||
* MCU block height (in pixels) for a given level of chrominance subsampling.
|
||||
* MCU block sizes:
|
||||
* - 8x8 for no subsampling or grayscale
|
||||
* - 16x8 for 4:2:2
|
||||
* - 8x16 for 4:4:0
|
||||
* - 16x16 for 4:2:0
|
||||
*/
|
||||
static const int tjMCUHeight[TJ_NUMSAMP] = {8, 8, 16, 8, 16};
|
||||
|
||||
|
||||
/**
|
||||
* The number of pixel formats
|
||||
*/
|
||||
#define TJ_NUMPF 11
|
||||
|
||||
/**
|
||||
* Pixel formats
|
||||
*/
|
||||
enum TJPF
|
||||
{
|
||||
/**
|
||||
* RGB pixel format. The red, green, and blue components in the image are
|
||||
* stored in 3-byte pixels in the order R, G, B from lowest to highest byte
|
||||
* address within each pixel.
|
||||
*/
|
||||
TJPF_RGB=0,
|
||||
/**
|
||||
* BGR pixel format. The red, green, and blue components in the image are
|
||||
* stored in 3-byte pixels in the order B, G, R from lowest to highest byte
|
||||
* address within each pixel.
|
||||
*/
|
||||
TJPF_BGR,
|
||||
/**
|
||||
* RGBX pixel format. The red, green, and blue components in the image are
|
||||
* stored in 4-byte pixels in the order R, G, B from lowest to highest byte
|
||||
* address within each pixel. The X component is ignored when compressing
|
||||
* and undefined when decompressing.
|
||||
*/
|
||||
TJPF_RGBX,
|
||||
/**
|
||||
* BGRX pixel format. The red, green, and blue components in the image are
|
||||
* stored in 4-byte pixels in the order B, G, R from lowest to highest byte
|
||||
* address within each pixel. The X component is ignored when compressing
|
||||
* and undefined when decompressing.
|
||||
*/
|
||||
TJPF_BGRX,
|
||||
/**
|
||||
* XBGR pixel format. The red, green, and blue components in the image are
|
||||
* stored in 4-byte pixels in the order R, G, B from highest to lowest byte
|
||||
* address within each pixel. The X component is ignored when compressing
|
||||
* and undefined when decompressing.
|
||||
*/
|
||||
TJPF_XBGR,
|
||||
/**
|
||||
* XRGB pixel format. The red, green, and blue components in the image are
|
||||
* stored in 4-byte pixels in the order B, G, R from highest to lowest byte
|
||||
* address within each pixel. The X component is ignored when compressing
|
||||
* and undefined when decompressing.
|
||||
*/
|
||||
TJPF_XRGB,
|
||||
/**
|
||||
* Grayscale pixel format. Each 1-byte pixel represents a luminance
|
||||
* (brightness) level from 0 to 255.
|
||||
*/
|
||||
TJPF_GRAY,
|
||||
/**
|
||||
* RGBA pixel format. This is the same as @ref TJPF_RGBX, except that when
|
||||
* decompressing, the X component is guaranteed to be 0xFF, which can be
|
||||
* interpreted as an opaque alpha channel.
|
||||
*/
|
||||
TJPF_RGBA,
|
||||
/**
|
||||
* BGRA pixel format. This is the same as @ref TJPF_BGRX, except that when
|
||||
* decompressing, the X component is guaranteed to be 0xFF, which can be
|
||||
* interpreted as an opaque alpha channel.
|
||||
*/
|
||||
TJPF_BGRA,
|
||||
/**
|
||||
* ABGR pixel format. This is the same as @ref TJPF_XBGR, except that when
|
||||
* decompressing, the X component is guaranteed to be 0xFF, which can be
|
||||
* interpreted as an opaque alpha channel.
|
||||
*/
|
||||
TJPF_ABGR,
|
||||
/**
|
||||
* ARGB pixel format. This is the same as @ref TJPF_XRGB, except that when
|
||||
* decompressing, the X component is guaranteed to be 0xFF, which can be
|
||||
* interpreted as an opaque alpha channel.
|
||||
*/
|
||||
TJPF_ARGB
|
||||
};
|
||||
|
||||
/**
|
||||
* Red offset (in bytes) for a given pixel format. This specifies the number
|
||||
* of bytes that the red component is offset from the start of the pixel. For
|
||||
* instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
|
||||
* then the red component will be <tt>pixel[tjRedOffset[TJ_BGRX]]</tt>.
|
||||
*/
|
||||
static const int tjRedOffset[TJ_NUMPF] = {0, 2, 0, 2, 3, 1, 0, 0, 2, 3, 1};
|
||||
/**
|
||||
* Green offset (in bytes) for a given pixel format. This specifies the number
|
||||
* of bytes that the green component is offset from the start of the pixel.
|
||||
* For instance, if a pixel of format TJ_BGRX is stored in
|
||||
* <tt>char pixel[]</tt>, then the green component will be
|
||||
* <tt>pixel[tjGreenOffset[TJ_BGRX]]</tt>.
|
||||
*/
|
||||
static const int tjGreenOffset[TJ_NUMPF] = {1, 1, 1, 1, 2, 2, 0, 1, 1, 2, 2};
|
||||
/**
|
||||
* Blue offset (in bytes) for a given pixel format. This specifies the number
|
||||
* of bytes that the Blue component is offset from the start of the pixel. For
|
||||
* instance, if a pixel of format TJ_BGRX is stored in <tt>char pixel[]</tt>,
|
||||
* then the blue component will be <tt>pixel[tjBlueOffset[TJ_BGRX]]</tt>.
|
||||
*/
|
||||
static const int tjBlueOffset[TJ_NUMPF] = {2, 0, 2, 0, 1, 3, 0, 2, 0, 1, 3};
|
||||
|
||||
/**
|
||||
* Pixel size (in bytes) for a given pixel format.
|
||||
*/
|
||||
static const int tjPixelSize[TJ_NUMPF] = {3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4};
|
||||
|
||||
|
||||
/**
|
||||
* The uncompressed source/destination image is stored in bottom-up (Windows,
|
||||
* OpenGL) order, not top-down (X11) order.
|
||||
*/
|
||||
#define TJFLAG_BOTTOMUP 2
|
||||
/**
|
||||
* Turn off CPU auto-detection and force TurboJPEG to use MMX code (IPP and
|
||||
* 32-bit libjpeg-turbo versions only.)
|
||||
*/
|
||||
#define TJFLAG_FORCEMMX 8
|
||||
/**
|
||||
* Turn off CPU auto-detection and force TurboJPEG to use SSE code (32-bit IPP
|
||||
* and 32-bit libjpeg-turbo versions only)
|
||||
*/
|
||||
#define TJFLAG_FORCESSE 16
|
||||
/**
|
||||
* Turn off CPU auto-detection and force TurboJPEG to use SSE2 code (32-bit IPP
|
||||
* and 32-bit libjpeg-turbo versions only)
|
||||
*/
|
||||
#define TJFLAG_FORCESSE2 32
|
||||
/**
|
||||
* Turn off CPU auto-detection and force TurboJPEG to use SSE3 code (64-bit IPP
|
||||
* version only)
|
||||
*/
|
||||
#define TJFLAG_FORCESSE3 128
|
||||
/**
|
||||
* Use fast, inaccurate chrominance upsampling routines in the JPEG
|
||||
* decompressor (libjpeg and libjpeg-turbo versions only)
|
||||
*/
|
||||
#define TJFLAG_FASTUPSAMPLE 256
|
||||
|
||||
|
||||
/**
|
||||
* Scaling factor
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
/**
|
||||
* Numerator
|
||||
*/
|
||||
int num;
|
||||
/**
|
||||
* Denominator
|
||||
*/
|
||||
int denom;
|
||||
} tjscalingfactor;
|
||||
|
||||
|
||||
/**
|
||||
* TurboJPEG instance handle
|
||||
*/
|
||||
typedef void* tjhandle;
|
||||
|
||||
|
||||
/**
|
||||
* Pad the given width to the nearest 32-bit boundary
|
||||
*/
|
||||
#define TJPAD(width) (((width)+3)&(~3))
|
||||
|
||||
/**
|
||||
* Compute the scaled value of <tt>dimension</tt> using the given scaling
|
||||
* factor. This macro performs the integer equivalent of <tt>ceil(dimension *
|
||||
* scalingFactor)</tt>.
|
||||
*/
|
||||
#define TJSCALED(dimension, scalingFactor) ((dimension * scalingFactor.num \
|
||||
+ scalingFactor.denom - 1) / scalingFactor.denom)
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* Create a TurboJPEG compressor instance.
|
||||
*
|
||||
* @return a handle to the newly-created instance, or NULL if an error
|
||||
* occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT tjhandle DLLCALL tjInitCompress(void);
|
||||
|
||||
|
||||
/**
|
||||
* Compress an RGB or grayscale image into a JPEG image.
|
||||
*
|
||||
* @param handle a handle to a TurboJPEG compressor or transformer instance
|
||||
* @param srcBuf pointer to an image buffer containing RGB or grayscale pixels
|
||||
* to be compressed
|
||||
* @param width width (in pixels) of the source image
|
||||
* @param pitch bytes per line of the source image. Normally, this should be
|
||||
* <tt>width * #tjPixelSize[pixelFormat]</tt> if the image is unpadded,
|
||||
* or <tt>#TJPAD(width * #tjPixelSize[pixelFormat])</tt> if each line of
|
||||
* the image is padded to the nearest 32-bit boundary, as is the case
|
||||
* for Windows bitmaps. You can also be clever and use this parameter
|
||||
* to skip lines, etc. Setting this parameter to 0 is the equivalent of
|
||||
* setting it to <tt>width * #tjPixelSize[pixelFormat]</tt>.
|
||||
* @param height height (in pixels) of the source image
|
||||
* @param pixelFormat pixel format of the source image (see @ref TJPF
|
||||
* "Pixel formats".)
|
||||
* @param jpegBuf address of a pointer to an image buffer that will receive the
|
||||
* JPEG image. TurboJPEG has the ability to reallocate the JPEG buffer
|
||||
* to accommodate the size of the JPEG image. Thus, you can choose to:
|
||||
* -# pre-allocate the JPEG buffer with an arbitrary size using
|
||||
* #tjAlloc() and let TurboJPEG grow the buffer as needed,
|
||||
* -# set <tt>*jpegBuf</tt> to NULL to tell TurboJPEG to allocate the
|
||||
* buffer for you, or
|
||||
* -# pre-allocate the buffer to a "worst case" size determined by
|
||||
* calling #tjBufSize(). This should ensure that the buffer never has
|
||||
* to be re-allocated (setting #TJFLAG_NOREALLOC guarantees this.)
|
||||
* .
|
||||
* If you choose option 1, <tt>*jpegSize</tt> should be set to the
|
||||
* size of your pre-allocated buffer. In any case, unless you have
|
||||
* set #TJFLAG_NOREALLOC, you should always check <tt>*jpegBuf</tt> upon
|
||||
* return from this function, as it may have changed.
|
||||
* @param jpegSize pointer to an unsigned long variable that holds the size of
|
||||
* the JPEG image buffer. If <tt>*jpegBuf</tt> points to a
|
||||
* pre-allocated buffer, then <tt>*jpegSize</tt> should be set to the
|
||||
* size of the buffer. Upon return, <tt>*jpegSize</tt> will contain the
|
||||
* size of the JPEG image (in bytes.)
|
||||
* @param jpegSubsamp the level of chrominance subsampling to be used when
|
||||
* generating the JPEG image (see @ref TJSAMP
|
||||
* "Chrominance subsampling options".)
|
||||
* @param jpegQual the image quality of the generated JPEG image (1 = worst,
|
||||
100 = best)
|
||||
* @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
|
||||
* "flags".
|
||||
*
|
||||
* @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT int DLLCALL tjCompress2(tjhandle handle, unsigned char *srcBuf,
|
||||
int width, int pitch, int height, int pixelFormat, unsigned char **jpegBuf,
|
||||
unsigned long *jpegSize, int jpegSubsamp, int jpegQual, int flags);
|
||||
|
||||
|
||||
/**
|
||||
* The maximum size of the buffer (in bytes) required to hold a JPEG image with
|
||||
* the given parameters. The number of bytes returned by this function is
|
||||
* larger than the size of the uncompressed source image. The reason for this
|
||||
* is that the JPEG format uses 16-bit coefficients, and it is thus possible
|
||||
* for a very high-quality JPEG image with very high frequency content to
|
||||
* expand rather than compress when converted to the JPEG format. Such images
|
||||
* represent a very rare corner case, but since there is no way to predict the
|
||||
* size of a JPEG image prior to compression, the corner case has to be
|
||||
* handled.
|
||||
*
|
||||
* @param width width of the image (in pixels)
|
||||
* @param height height of the image (in pixels)
|
||||
* @param jpegSubsamp the level of chrominance subsampling to be used when
|
||||
* generating the JPEG image (see @ref TJSAMP
|
||||
* "Chrominance subsampling options".)
|
||||
*
|
||||
* @return the maximum size of the buffer (in bytes) required to hold the
|
||||
* image, or -1 if the arguments are out of bounds.
|
||||
*/
|
||||
DLLEXPORT unsigned long DLLCALL tjBufSize(int width, int height,
|
||||
int jpegSubsamp);
|
||||
|
||||
|
||||
/**
|
||||
* Create a TurboJPEG decompressor instance.
|
||||
*
|
||||
* @return a handle to the newly-created instance, or NULL if an error
|
||||
* occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT tjhandle DLLCALL tjInitDecompress(void);
|
||||
|
||||
|
||||
/**
|
||||
* Retrieve information about a JPEG image without decompressing it.
|
||||
*
|
||||
* @param handle a handle to a TurboJPEG decompressor or transformer instance
|
||||
* @param jpegBuf pointer to a buffer containing a JPEG image
|
||||
* @param jpegSize size of the JPEG image (in bytes)
|
||||
* @param width pointer to an integer variable that will receive the width (in
|
||||
* pixels) of the JPEG image
|
||||
* @param height pointer to an integer variable that will receive the height
|
||||
* (in pixels) of the JPEG image
|
||||
* @param jpegSubsamp pointer to an integer variable that will receive the
|
||||
* level of chrominance subsampling used when compressing the JPEG image
|
||||
* (see @ref TJSAMP "Chrominance subsampling options".)
|
||||
*
|
||||
* @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT int DLLCALL tjDecompressHeader2(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height,
|
||||
int *jpegSubsamp);
|
||||
|
||||
|
||||
/**
|
||||
* Returns a list of fractional scaling factors that the JPEG decompressor in
|
||||
* this implementation of TurboJPEG supports.
|
||||
*
|
||||
* @param numscalingfactors pointer to an integer variable that will receive
|
||||
* the number of elements in the list
|
||||
*
|
||||
* @return a pointer to a list of fractional scaling factors, or NULL if an
|
||||
* error is encountered (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT tjscalingfactor* DLLCALL tjGetScalingFactors(int *numscalingfactors);
|
||||
|
||||
|
||||
/**
|
||||
* Decompress a JPEG image to an RGB or grayscale image.
|
||||
*
|
||||
* @param handle a handle to a TurboJPEG decompressor or transformer instance
|
||||
* @param jpegBuf pointer to a buffer containing the JPEG image to decompress
|
||||
* @param jpegSize size of the JPEG image (in bytes)
|
||||
* @param dstBuf pointer to an image buffer that will receive the decompressed
|
||||
* image. This buffer should normally be <tt>pitch * scaledHeight</tt>
|
||||
* bytes in size, where <tt>scaledHeight</tt> can be determined by
|
||||
* calling #TJSCALED() with the JPEG image height and one of the scaling
|
||||
* factors returned by #tjGetScalingFactors(). The dstBuf pointer may
|
||||
* also be used to decompress into a specific region of a larger buffer.
|
||||
* @param width desired width (in pixels) of the destination image. If this is
|
||||
* smaller than the width of the JPEG image being decompressed, then
|
||||
* TurboJPEG will use scaling in the JPEG decompressor to generate the
|
||||
* largest possible image that will fit within the desired width. If
|
||||
* width is set to 0, then only the height will be considered when
|
||||
* determining the scaled image size.
|
||||
* @param pitch bytes per line of the destination image. Normally, this is
|
||||
* <tt>scaledWidth * #tjPixelSize[pixelFormat]</tt> if the decompressed
|
||||
* image is unpadded, else <tt>#TJPAD(scaledWidth *
|
||||
* #tjPixelSize[pixelFormat])</tt> if each line of the decompressed
|
||||
* image is padded to the nearest 32-bit boundary, as is the case for
|
||||
* Windows bitmaps. (NOTE: <tt>scaledWidth</tt> can be determined by
|
||||
* calling #TJSCALED() with the JPEG image width and one of the scaling
|
||||
* factors returned by #tjGetScalingFactors().) You can also be clever
|
||||
* and use the pitch parameter to skip lines, etc. Setting this
|
||||
* parameter to 0 is the equivalent of setting it to <tt>scaledWidth
|
||||
* * #tjPixelSize[pixelFormat]</tt>.
|
||||
* @param height desired height (in pixels) of the destination image. If this
|
||||
* is smaller than the height of the JPEG image being decompressed, then
|
||||
* TurboJPEG will use scaling in the JPEG decompressor to generate the
|
||||
* largest possible image that will fit within the desired height. If
|
||||
* height is set to 0, then only the width will be considered when
|
||||
* determining the scaled image size.
|
||||
* @param pixelFormat pixel format of the destination image (see @ref
|
||||
* TJPF "Pixel formats".)
|
||||
* @param flags the bitwise OR of one or more of the @ref TJFLAG_BOTTOMUP
|
||||
* "flags".
|
||||
*
|
||||
* @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT int DLLCALL tjDecompress2(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, unsigned char *dstBuf,
|
||||
int width, int pitch, int height, int pixelFormat, int flags);
|
||||
|
||||
|
||||
/**
|
||||
* Destroy a TurboJPEG compressor, decompressor, or transformer instance.
|
||||
*
|
||||
* @param handle a handle to a TurboJPEG compressor, decompressor or
|
||||
* transformer instance
|
||||
*
|
||||
* @return 0 if successful, or -1 if an error occurred (see #tjGetErrorStr().)
|
||||
*/
|
||||
DLLEXPORT int DLLCALL tjDestroy(tjhandle handle);
|
||||
|
||||
|
||||
/**
|
||||
* Returns a descriptive error message explaining why the last command failed.
|
||||
*
|
||||
* @return a descriptive error message explaining why the last command failed.
|
||||
*/
|
||||
DLLEXPORT char* DLLCALL tjGetErrorStr(void);
|
||||
|
||||
|
||||
/* Backward compatibility functions and macros (nothing to see here) */
|
||||
#define NUMSUBOPT TJ_NUMSAMP
|
||||
#define TJ_444 TJSAMP_444
|
||||
#define TJ_422 TJSAMP_422
|
||||
#define TJ_420 TJSAMP_420
|
||||
#define TJ_411 TJSAMP_420
|
||||
#define TJ_GRAYSCALE TJSAMP_GRAY
|
||||
|
||||
#define TJ_BGR 1
|
||||
#define TJ_BOTTOMUP TJFLAG_BOTTOMUP
|
||||
#define TJ_FORCEMMX TJFLAG_FORCEMMX
|
||||
#define TJ_FORCESSE TJFLAG_FORCESSE
|
||||
#define TJ_FORCESSE2 TJFLAG_FORCESSE2
|
||||
#define TJ_ALPHAFIRST 64
|
||||
#define TJ_FORCESSE3 TJFLAG_FORCESSE3
|
||||
#define TJ_FASTUPSAMPLE TJFLAG_FASTUPSAMPLE
|
||||
|
||||
DLLEXPORT unsigned long DLLCALL TJBUFSIZE(int width, int height);
|
||||
|
||||
DLLEXPORT int DLLCALL tjCompress(tjhandle handle, unsigned char *srcBuf,
|
||||
int width, int pitch, int height, int pixelSize, unsigned char *dstBuf,
|
||||
unsigned long *compressedSize, int jpegSubsamp, int jpegQual, int flags);
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompressHeader(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height);
|
||||
|
||||
DLLEXPORT int DLLCALL tjDecompress(tjhandle handle,
|
||||
unsigned char *jpegBuf, unsigned long jpegSize, unsigned char *dstBuf,
|
||||
int width, int pitch, int height, int pixelSize, int flags);
|
||||
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,389 @@
|
||||
/* Copyright (C)2004 Landmark Graphics Corporation
|
||||
* Copyright (C)2005 Sun Microsystems, Inc.
|
||||
* Copyright (C)2010, 2012 D. R. Commander
|
||||
*
|
||||
* This library is free software and may be redistributed and/or modified under
|
||||
* the terms of the wxWindows Library License, Version 3.1 or (at your option)
|
||||
* any later version. The full license is in the LICENSE.txt file included
|
||||
* with this distribution.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* wxWindows Library License for more details.
|
||||
*/
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <io.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include "./tjutil.h"
|
||||
#include "./bmp.h"
|
||||
|
||||
#define byteswap(i) ( \
|
||||
(((i) & 0xff000000) >> 24) | \
|
||||
(((i) & 0x00ff0000) >> 8) | \
|
||||
(((i) & 0x0000ff00) << 8) | \
|
||||
(((i) & 0x000000ff) << 24) )
|
||||
|
||||
#define byteswap16(i) ( \
|
||||
(((i) & 0xff00) >> 8) | \
|
||||
(((i) & 0x00ff) << 8) )
|
||||
|
||||
static __inline int littleendian(void)
|
||||
{
|
||||
unsigned int value=1;
|
||||
unsigned char *ptr=(unsigned char *)(&value);
|
||||
if(ptr[0]==1 && ptr[3]==0) return 1;
|
||||
else return 0;
|
||||
}
|
||||
|
||||
#ifndef BI_BITFIELDS
|
||||
#define BI_BITFIELDS 3L
|
||||
#endif
|
||||
#ifndef BI_RGB
|
||||
#define BI_RGB 0L
|
||||
#endif
|
||||
|
||||
#define BMPHDRSIZE 54
|
||||
typedef struct _bmphdr
|
||||
{
|
||||
unsigned short bfType;
|
||||
unsigned int bfSize;
|
||||
unsigned short bfReserved1, bfReserved2;
|
||||
unsigned int bfOffBits;
|
||||
|
||||
unsigned int biSize;
|
||||
int biWidth, biHeight;
|
||||
unsigned short biPlanes, biBitCount;
|
||||
unsigned int biCompression, biSizeImage;
|
||||
int biXPelsPerMeter, biYPelsPerMeter;
|
||||
unsigned int biClrUsed, biClrImportant;
|
||||
} bmphdr;
|
||||
|
||||
static const char *__bmperr="No error";
|
||||
|
||||
static const int ps[BMPPIXELFORMATS]={3, 4, 3, 4, 4, 4};
|
||||
static const int roffset[BMPPIXELFORMATS]={0, 0, 2, 2, 3, 1};
|
||||
static const int goffset[BMPPIXELFORMATS]={1, 1, 1, 1, 2, 2};
|
||||
static const int boffset[BMPPIXELFORMATS]={2, 2, 0, 0, 1, 3};
|
||||
|
||||
#define _throw(m) {__bmperr=m; retcode=-1; goto finally;}
|
||||
#define _unix(f) {if((f)==-1) _throw(strerror(errno));}
|
||||
#define _catch(f) {if((f)==-1) {retcode=-1; goto finally;}}
|
||||
|
||||
#define readme(fd, addr, size) \
|
||||
if((bytesread=read(fd, addr, (size)))==-1) _throw(strerror(errno)); \
|
||||
if(bytesread!=(size)) _throw("Read error");
|
||||
|
||||
void pixelconvert(unsigned char *srcbuf, enum BMPPIXELFORMAT srcformat,
|
||||
int srcpitch, unsigned char *dstbuf, enum BMPPIXELFORMAT dstformat, int dstpitch,
|
||||
int w, int h, int flip)
|
||||
{
|
||||
unsigned char *srcptr, *srcptr0, *dstptr, *dstptr0;
|
||||
int i, j;
|
||||
|
||||
srcptr=flip? &srcbuf[srcpitch*(h-1)]:srcbuf;
|
||||
for(j=0, dstptr=dstbuf; j<h; j++,
|
||||
srcptr+=flip? -srcpitch:srcpitch, dstptr+=dstpitch)
|
||||
{
|
||||
for(i=0, srcptr0=srcptr, dstptr0=dstptr; i<w; i++,
|
||||
srcptr0+=ps[srcformat], dstptr0+=ps[dstformat])
|
||||
{
|
||||
dstptr0[roffset[dstformat]]=srcptr0[roffset[srcformat]];
|
||||
dstptr0[goffset[dstformat]]=srcptr0[goffset[srcformat]];
|
||||
dstptr0[boffset[dstformat]]=srcptr0[boffset[srcformat]];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int loadppm(int *fd, unsigned char **buf, int *w, int *h,
|
||||
enum BMPPIXELFORMAT f, int align, int dstbottomup, int ascii)
|
||||
{
|
||||
FILE *fs=NULL; int retcode=0, scalefactor, dstpitch;
|
||||
unsigned char *tempbuf=NULL; char temps[255], temps2[255];
|
||||
int numread=0, totalread=0, pixel[3], i, j;
|
||||
|
||||
if((fs=fdopen(*fd, "r"))==NULL) _throw(strerror(errno));
|
||||
|
||||
do
|
||||
{
|
||||
if(!fgets(temps, 255, fs)) _throw("Read error");
|
||||
if(strlen(temps)==0 || temps[0]=='\n') continue;
|
||||
if(sscanf(temps, "%s", temps2)==1 && temps2[1]=='#') continue;
|
||||
switch(totalread)
|
||||
{
|
||||
case 0:
|
||||
if((numread=sscanf(temps, "%d %d %d", w, h, &scalefactor))==EOF)
|
||||
_throw("Read error");
|
||||
break;
|
||||
case 1:
|
||||
if((numread=sscanf(temps, "%d %d", h, &scalefactor))==EOF)
|
||||
_throw("Read error");
|
||||
break;
|
||||
case 2:
|
||||
if((numread=sscanf(temps, "%d", &scalefactor))==EOF)
|
||||
_throw("Read error");
|
||||
break;
|
||||
}
|
||||
totalread+=numread;
|
||||
} while(totalread<3);
|
||||
if((*w)<1 || (*h)<1 || scalefactor<1) _throw("Corrupt PPM header");
|
||||
|
||||
dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));
|
||||
if((*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)
|
||||
_throw("Memory allocation error");
|
||||
if(ascii)
|
||||
{
|
||||
for(j=0; j<*h; j++)
|
||||
{
|
||||
for(i=0; i<*w; i++)
|
||||
{
|
||||
if(fscanf(fs, "%d%d%d", &pixel[0], &pixel[1], &pixel[2])!=3)
|
||||
_throw("Read error");
|
||||
(*buf)[j*dstpitch+i*ps[f]+roffset[f]]=(unsigned char)(pixel[0]*255/scalefactor);
|
||||
(*buf)[j*dstpitch+i*ps[f]+goffset[f]]=(unsigned char)(pixel[1]*255/scalefactor);
|
||||
(*buf)[j*dstpitch+i*ps[f]+boffset[f]]=(unsigned char)(pixel[2]*255/scalefactor);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(scalefactor!=255)
|
||||
_throw("Binary PPMs must have 8-bit components");
|
||||
if((tempbuf=(unsigned char *)malloc((*w)*(*h)*3))==NULL)
|
||||
_throw("Memory allocation error");
|
||||
if(fread(tempbuf, (*w)*(*h)*3, 1, fs)!=1) _throw("Read error");
|
||||
pixelconvert(tempbuf, BMP_RGB, (*w)*3, *buf, f, dstpitch, *w, *h, dstbottomup);
|
||||
}
|
||||
|
||||
finally:
|
||||
if(fs) {fclose(fs); *fd=-1;}
|
||||
if(tempbuf) free(tempbuf);
|
||||
return retcode;
|
||||
}
|
||||
|
||||
|
||||
int loadbmp(char *filename, unsigned char **buf, int *w, int *h,
|
||||
enum BMPPIXELFORMAT f, int align, int dstbottomup)
|
||||
{
|
||||
int fd=-1, bytesread, srcpitch, srcbottomup=1, srcps, dstpitch,
|
||||
retcode=0;
|
||||
unsigned char *tempbuf=NULL;
|
||||
bmphdr bh; int flags=O_RDONLY;
|
||||
|
||||
dstbottomup=dstbottomup? 1:0;
|
||||
#ifdef _WIN32
|
||||
flags|=O_BINARY;
|
||||
#endif
|
||||
if(!filename || !buf || !w || !h || f<0 || f>BMPPIXELFORMATS-1 || align<1)
|
||||
_throw("invalid argument to loadbmp()");
|
||||
if((align&(align-1))!=0)
|
||||
_throw("Alignment must be a power of 2");
|
||||
_unix(fd=open(filename, flags));
|
||||
|
||||
readme(fd, &bh.bfType, sizeof(unsigned short));
|
||||
if(!littleendian()) bh.bfType=byteswap16(bh.bfType);
|
||||
|
||||
if(bh.bfType==0x3650)
|
||||
{
|
||||
_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 0));
|
||||
goto finally;
|
||||
}
|
||||
if(bh.bfType==0x3350)
|
||||
{
|
||||
_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 1));
|
||||
goto finally;
|
||||
}
|
||||
|
||||
readme(fd, &bh.bfSize, sizeof(unsigned int));
|
||||
readme(fd, &bh.bfReserved1, sizeof(unsigned short));
|
||||
readme(fd, &bh.bfReserved2, sizeof(unsigned short));
|
||||
readme(fd, &bh.bfOffBits, sizeof(unsigned int));
|
||||
readme(fd, &bh.biSize, sizeof(unsigned int));
|
||||
readme(fd, &bh.biWidth, sizeof(int));
|
||||
readme(fd, &bh.biHeight, sizeof(int));
|
||||
readme(fd, &bh.biPlanes, sizeof(unsigned short));
|
||||
readme(fd, &bh.biBitCount, sizeof(unsigned short));
|
||||
readme(fd, &bh.biCompression, sizeof(unsigned int));
|
||||
readme(fd, &bh.biSizeImage, sizeof(unsigned int));
|
||||
readme(fd, &bh.biXPelsPerMeter, sizeof(int));
|
||||
readme(fd, &bh.biYPelsPerMeter, sizeof(int));
|
||||
readme(fd, &bh.biClrUsed, sizeof(unsigned int));
|
||||
readme(fd, &bh.biClrImportant, sizeof(unsigned int));
|
||||
|
||||
if(!littleendian())
|
||||
{
|
||||
bh.bfSize=byteswap(bh.bfSize);
|
||||
bh.bfOffBits=byteswap(bh.bfOffBits);
|
||||
bh.biSize=byteswap(bh.biSize);
|
||||
bh.biWidth=byteswap(bh.biWidth);
|
||||
bh.biHeight=byteswap(bh.biHeight);
|
||||
bh.biPlanes=byteswap16(bh.biPlanes);
|
||||
bh.biBitCount=byteswap16(bh.biBitCount);
|
||||
bh.biCompression=byteswap(bh.biCompression);
|
||||
bh.biSizeImage=byteswap(bh.biSizeImage);
|
||||
bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
|
||||
bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
|
||||
bh.biClrUsed=byteswap(bh.biClrUsed);
|
||||
bh.biClrImportant=byteswap(bh.biClrImportant);
|
||||
}
|
||||
|
||||
if(bh.bfType!=0x4d42 || bh.bfOffBits<BMPHDRSIZE
|
||||
|| bh.biWidth<1 || bh.biHeight==0)
|
||||
_throw("Corrupt bitmap header");
|
||||
if((bh.biBitCount!=24 && bh.biBitCount!=32) || bh.biCompression!=BI_RGB)
|
||||
_throw("Only uncompessed RGB bitmaps are supported");
|
||||
|
||||
*w=bh.biWidth; *h=bh.biHeight; srcps=bh.biBitCount/8;
|
||||
if(*h<0) {*h=-(*h); srcbottomup=0;}
|
||||
srcpitch=(((*w)*srcps)+3)&(~3);
|
||||
dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));
|
||||
|
||||
if(srcpitch*(*h)+bh.bfOffBits!=bh.bfSize) _throw("Corrupt bitmap header");
|
||||
if((tempbuf=(unsigned char *)malloc(srcpitch*(*h)))==NULL
|
||||
|| (*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)
|
||||
_throw("Memory allocation error");
|
||||
if(lseek(fd, (long)bh.bfOffBits, SEEK_SET)!=(long)bh.bfOffBits)
|
||||
_throw(strerror(errno));
|
||||
_unix(bytesread=read(fd, tempbuf, srcpitch*(*h)));
|
||||
if(bytesread!=srcpitch*(*h)) _throw("Read error");
|
||||
|
||||
pixelconvert(tempbuf, BMP_BGR, srcpitch, *buf, f, dstpitch, *w, *h,
|
||||
srcbottomup!=dstbottomup);
|
||||
|
||||
finally:
|
||||
if(tempbuf) free(tempbuf);
|
||||
if(fd!=-1) close(fd);
|
||||
return retcode;
|
||||
}
|
||||
|
||||
#define writeme(fd, addr, size) \
|
||||
if((byteswritten=write(fd, addr, (size)))==-1) _throw(strerror(errno)); \
|
||||
if(byteswritten!=(size)) _throw("Write error");
|
||||
|
||||
int saveppm(char *filename, unsigned char *buf, int w, int h,
|
||||
enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)
|
||||
{
|
||||
FILE *fs=NULL; int retcode=0;
|
||||
unsigned char *tempbuf=NULL;
|
||||
|
||||
if((fs=fopen(filename, "wb"))==NULL) _throw(strerror(errno));
|
||||
if(fprintf(fs, "P6\n")<1) _throw("Write error");
|
||||
if(fprintf(fs, "%d %d\n", w, h)<1) _throw("Write error");
|
||||
if(fprintf(fs, "255\n")<1) _throw("Write error");
|
||||
|
||||
if((tempbuf=(unsigned char *)malloc(w*h*3))==NULL)
|
||||
_throw("Memory allocation error");
|
||||
|
||||
pixelconvert(buf, f, srcpitch, tempbuf, BMP_RGB, w*3, w, h,
|
||||
srcbottomup);
|
||||
|
||||
if((fwrite(tempbuf, w*h*3, 1, fs))!=1) _throw("Write error");
|
||||
|
||||
finally:
|
||||
if(tempbuf) free(tempbuf);
|
||||
if(fs) fclose(fs);
|
||||
return retcode;
|
||||
}
|
||||
|
||||
int savebmp(char *filename, unsigned char *buf, int w, int h,
|
||||
enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)
|
||||
{
|
||||
int fd=-1, byteswritten, dstpitch, retcode=0;
|
||||
int flags=O_RDWR|O_CREAT|O_TRUNC;
|
||||
unsigned char *tempbuf=NULL; char *temp;
|
||||
bmphdr bh; int mode;
|
||||
|
||||
#ifdef _WIN32
|
||||
flags|=O_BINARY; mode=_S_IREAD|_S_IWRITE;
|
||||
#else
|
||||
mode=S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
|
||||
#endif
|
||||
if(!filename || !buf || w<1 || h<1 || f<0 || f>BMPPIXELFORMATS-1 || srcpitch<0)
|
||||
_throw("bad argument to savebmp()");
|
||||
|
||||
if(srcpitch==0) srcpitch=w*ps[f];
|
||||
|
||||
if((temp=strrchr(filename, '.'))!=NULL)
|
||||
{
|
||||
if(!strcasecmp(temp, ".ppm"))
|
||||
return saveppm(filename, buf, w, h, f, srcpitch, srcbottomup);
|
||||
}
|
||||
|
||||
_unix(fd=open(filename, flags, mode));
|
||||
dstpitch=((w*3)+3)&(~3);
|
||||
|
||||
bh.bfType=0x4d42;
|
||||
bh.bfSize=BMPHDRSIZE+dstpitch*h;
|
||||
bh.bfReserved1=0; bh.bfReserved2=0;
|
||||
bh.bfOffBits=BMPHDRSIZE;
|
||||
bh.biSize=40;
|
||||
bh.biWidth=w; bh.biHeight=h;
|
||||
bh.biPlanes=0; bh.biBitCount=24;
|
||||
bh.biCompression=BI_RGB; bh.biSizeImage=0;
|
||||
bh.biXPelsPerMeter=0; bh.biYPelsPerMeter=0;
|
||||
bh.biClrUsed=0; bh.biClrImportant=0;
|
||||
|
||||
if(!littleendian())
|
||||
{
|
||||
bh.bfType=byteswap16(bh.bfType);
|
||||
bh.bfSize=byteswap(bh.bfSize);
|
||||
bh.bfOffBits=byteswap(bh.bfOffBits);
|
||||
bh.biSize=byteswap(bh.biSize);
|
||||
bh.biWidth=byteswap(bh.biWidth);
|
||||
bh.biHeight=byteswap(bh.biHeight);
|
||||
bh.biPlanes=byteswap16(bh.biPlanes);
|
||||
bh.biBitCount=byteswap16(bh.biBitCount);
|
||||
bh.biCompression=byteswap(bh.biCompression);
|
||||
bh.biSizeImage=byteswap(bh.biSizeImage);
|
||||
bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
|
||||
bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
|
||||
bh.biClrUsed=byteswap(bh.biClrUsed);
|
||||
bh.biClrImportant=byteswap(bh.biClrImportant);
|
||||
}
|
||||
|
||||
writeme(fd, &bh.bfType, sizeof(unsigned short));
|
||||
writeme(fd, &bh.bfSize, sizeof(unsigned int));
|
||||
writeme(fd, &bh.bfReserved1, sizeof(unsigned short));
|
||||
writeme(fd, &bh.bfReserved2, sizeof(unsigned short));
|
||||
writeme(fd, &bh.bfOffBits, sizeof(unsigned int));
|
||||
writeme(fd, &bh.biSize, sizeof(unsigned int));
|
||||
writeme(fd, &bh.biWidth, sizeof(int));
|
||||
writeme(fd, &bh.biHeight, sizeof(int));
|
||||
writeme(fd, &bh.biPlanes, sizeof(unsigned short));
|
||||
writeme(fd, &bh.biBitCount, sizeof(unsigned short));
|
||||
writeme(fd, &bh.biCompression, sizeof(unsigned int));
|
||||
writeme(fd, &bh.biSizeImage, sizeof(unsigned int));
|
||||
writeme(fd, &bh.biXPelsPerMeter, sizeof(int));
|
||||
writeme(fd, &bh.biYPelsPerMeter, sizeof(int));
|
||||
writeme(fd, &bh.biClrUsed, sizeof(unsigned int));
|
||||
writeme(fd, &bh.biClrImportant, sizeof(unsigned int));
|
||||
|
||||
if((tempbuf=(unsigned char *)malloc(dstpitch*h))==NULL)
|
||||
_throw("Memory allocation error");
|
||||
|
||||
pixelconvert(buf, f, srcpitch, tempbuf, BMP_BGR, dstpitch, w, h,
|
||||
!srcbottomup);
|
||||
|
||||
if((byteswritten=write(fd, tempbuf, dstpitch*h))!=dstpitch*h)
|
||||
_throw(strerror(errno));
|
||||
|
||||
finally:
|
||||
if(tempbuf) free(tempbuf);
|
||||
if(fd!=-1) close(fd);
|
||||
return retcode;
|
||||
}
|
||||
|
||||
const char *bmpgeterr(void)
|
||||
{
|
||||
return __bmperr;
|
||||
}
|
||||
@ -0,0 +1,49 @@
|
||||
/* Copyright (C)2004 Landmark Graphics Corporation
|
||||
* Copyright (C)2005 Sun Microsystems, Inc.
|
||||
* Copyright (C)2011 D. R. Commander
|
||||
*
|
||||
* This library is free software and may be redistributed and/or modified under
|
||||
* the terms of the wxWindows Library License, Version 3.1 or (at your option)
|
||||
* any later version. The full license is in the LICENSE.txt file included
|
||||
* with this distribution.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* wxWindows Library License for more details.
|
||||
*/
|
||||
|
||||
// This provides rudimentary facilities for loading and saving true color
|
||||
// BMP and PPM files
|
||||
|
||||
#ifndef __BMP_H__
|
||||
#define __BMP_H__
|
||||
|
||||
#define BMPPIXELFORMATS 6
|
||||
enum BMPPIXELFORMAT {BMP_RGB=0, BMP_RGBX, BMP_BGR, BMP_BGRX, BMP_XBGR, BMP_XRGB};
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// This will load a Windows bitmap from a file and return a buffer with the
|
||||
// specified pixel format, scanline alignment, and orientation. The width and
|
||||
// height are returned in w and h.
|
||||
|
||||
int loadbmp(char *filename, unsigned char **buf, int *w, int *h,
|
||||
enum BMPPIXELFORMAT f, int align, int dstbottomup);
|
||||
|
||||
// This will save a buffer with the specified pixel format, pitch, orientation,
|
||||
// width, and height as a 24-bit Windows bitmap or PPM (the filename determines
|
||||
// which format to use)
|
||||
|
||||
int savebmp(char *filename, unsigned char *buf, int w, int h,
|
||||
enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup);
|
||||
|
||||
const char *bmpgeterr(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,658 @@
|
||||
/*
|
||||
* Copyright (C)2009-2012 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <errno.h>
|
||||
#include "./bmp.h"
|
||||
#include "./tjutil.h"
|
||||
#include "./turbojpeg.h"
|
||||
|
||||
|
||||
#define _throw(op, err) { \
|
||||
printf("ERROR in line %d while %s:\n%s\n", __LINE__, op, err); \
|
||||
retval=-1; goto bailout;}
|
||||
#define _throwunix(m) _throw(m, strerror(errno))
|
||||
#define _throwtj(m) _throw(m, tjGetErrorStr())
|
||||
#define _throwbmp(m) _throw(m, bmpgeterr())
|
||||
|
||||
int flags=0, decomponly=0, quiet=0, dotile=0, pf=TJPF_BGR;
|
||||
char *ext="ppm";
|
||||
const char *pixFormatStr[TJ_NUMPF]=
|
||||
{
|
||||
"RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "GRAY"
|
||||
};
|
||||
const int bmpPF[TJ_NUMPF]=
|
||||
{
|
||||
BMP_RGB, BMP_BGR, BMP_RGBX, BMP_BGRX, BMP_XBGR, BMP_XRGB, -1
|
||||
};
|
||||
const char *subNameLong[TJ_NUMSAMP]=
|
||||
{
|
||||
"4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0"
|
||||
};
|
||||
const char *subName[NUMSUBOPT]={"444", "422", "420", "GRAY", "440"};
|
||||
tjscalingfactor *scalingfactors=NULL, sf={1, 1}; int nsf=0;
|
||||
double benchtime=5.0;
|
||||
|
||||
|
||||
char *sigfig(double val, int figs, char *buf, int len)
|
||||
{
|
||||
char format[80];
|
||||
int digitsafterdecimal=figs-(int)ceil(log10(fabs(val)));
|
||||
if(digitsafterdecimal<1) snprintf(format, 80, "%%.0f");
|
||||
else snprintf(format, 80, "%%.%df", digitsafterdecimal);
|
||||
snprintf(buf, len, format, val);
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
/* Decompression test */
|
||||
int decomptest(unsigned char *srcbuf, unsigned char **jpegbuf,
|
||||
unsigned long *jpegsize, unsigned char *dstbuf, int w, int h,
|
||||
int subsamp, int jpegqual, char *filename, int tilew, int tileh)
|
||||
{
|
||||
char tempstr[1024], sizestr[20]="\0", qualstr[6]="\0", *ptr;
|
||||
FILE *file=NULL; tjhandle handle=NULL;
|
||||
int row, col, i, dstbufalloc=0, retval=0;
|
||||
double start, elapsed;
|
||||
int ps=tjPixelSize[pf];
|
||||
int bufsize;
|
||||
int scaledw=TJSCALED(w, sf);
|
||||
int scaledh=TJSCALED(h, sf);
|
||||
int pitch=scaledw*ps;
|
||||
int ntilesw=(w+tilew-1)/tilew, ntilesh=(h+tileh-1)/tileh;
|
||||
unsigned char *dstptr, *dstptr2;
|
||||
|
||||
if(jpegqual>0)
|
||||
{
|
||||
snprintf(qualstr, 6, "_Q%d", jpegqual);
|
||||
qualstr[5]=0;
|
||||
}
|
||||
|
||||
if((handle=tjInitDecompress())==NULL)
|
||||
_throwtj("executing tjInitDecompress()");
|
||||
|
||||
bufsize=pitch*scaledh;
|
||||
if(dstbuf==NULL)
|
||||
{
|
||||
if((dstbuf=(unsigned char *)malloc(bufsize)) == NULL)
|
||||
_throwunix("allocating image buffer");
|
||||
dstbufalloc=1;
|
||||
}
|
||||
/* Set the destination buffer to gray so we know whether the decompressor
|
||||
attempted to write to it */
|
||||
memset(dstbuf, 127, bufsize);
|
||||
|
||||
/* Execute once to preload cache */
|
||||
if(tjDecompress2(handle, jpegbuf[0], jpegsize[0], dstbuf, scaledw,
|
||||
pitch, scaledh, pf, flags)==-1)
|
||||
_throwtj("executing tjDecompress2()");
|
||||
|
||||
/* Benchmark */
|
||||
for(i=0, start=gettime(); (elapsed=gettime()-start)<benchtime; i++)
|
||||
{
|
||||
int tile=0;
|
||||
for(row=0, dstptr=dstbuf; row<ntilesh; row++, dstptr+=pitch*tileh)
|
||||
{
|
||||
for(col=0, dstptr2=dstptr; col<ntilesw; col++, tile++, dstptr2+=ps*tilew)
|
||||
{
|
||||
int width=dotile? min(tilew, w-col*tilew):scaledw;
|
||||
int height=dotile? min(tileh, h-row*tileh):scaledh;
|
||||
if(tjDecompress2(handle, jpegbuf[tile], jpegsize[tile], dstptr2, width,
|
||||
pitch, height, pf, flags)==-1)
|
||||
_throwtj("executing tjDecompress2()");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(tjDestroy(handle)==-1) _throwtj("executing tjDestroy()");
|
||||
handle=NULL;
|
||||
|
||||
if(quiet)
|
||||
{
|
||||
printf("%s\n",
|
||||
sigfig((double)(w*h)/1000000.*(double)i/elapsed, 4, tempstr, 1024));
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("D--> Frame rate: %f fps\n", (double)i/elapsed);
|
||||
printf(" Dest. throughput: %f Megapixels/sec\n",
|
||||
(double)(w*h)/1000000.*(double)i/elapsed);
|
||||
}
|
||||
if(sf.num!=1 || sf.denom!=1)
|
||||
snprintf(sizestr, 20, "%d_%d", sf.num, sf.denom);
|
||||
else if(tilew!=w || tileh!=h)
|
||||
snprintf(sizestr, 20, "%dx%d", tilew, tileh);
|
||||
else snprintf(sizestr, 20, "full");
|
||||
if(decomponly)
|
||||
snprintf(tempstr, 1024, "%s_%s.%s", filename, sizestr, ext);
|
||||
else
|
||||
snprintf(tempstr, 1024, "%s_%s%s_%s.%s", filename, subName[subsamp],
|
||||
qualstr, sizestr, ext);
|
||||
if(savebmp(tempstr, dstbuf, scaledw, scaledh, bmpPF[pf], pitch,
|
||||
(flags&TJFLAG_BOTTOMUP)!=0)==-1)
|
||||
_throwbmp("saving bitmap");
|
||||
ptr=strrchr(tempstr, '.');
|
||||
snprintf(ptr, 1024-(ptr-tempstr), "-err.%s", ext);
|
||||
if(srcbuf && sf.num==1 && sf.denom==1)
|
||||
{
|
||||
if(!quiet) printf("Compression error written to %s.\n", tempstr);
|
||||
if(subsamp==TJ_GRAYSCALE)
|
||||
{
|
||||
int index, index2;
|
||||
for(row=0, index=0; row<h; row++, index+=pitch)
|
||||
{
|
||||
for(col=0, index2=index; col<w; col++, index2+=ps)
|
||||
{
|
||||
int rindex=index2+tjRedOffset[pf];
|
||||
int gindex=index2+tjGreenOffset[pf];
|
||||
int bindex=index2+tjBlueOffset[pf];
|
||||
int y=(int)((double)srcbuf[rindex]*0.299
|
||||
+ (double)srcbuf[gindex]*0.587
|
||||
+ (double)srcbuf[bindex]*0.114 + 0.5);
|
||||
if(y>255) y=255; if(y<0) y=0;
|
||||
dstbuf[rindex]=abs(dstbuf[rindex]-y);
|
||||
dstbuf[gindex]=abs(dstbuf[gindex]-y);
|
||||
dstbuf[bindex]=abs(dstbuf[bindex]-y);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(row=0; row<h; row++)
|
||||
for(col=0; col<w*ps; col++)
|
||||
dstbuf[pitch*row+col]
|
||||
=abs(dstbuf[pitch*row+col]-srcbuf[pitch*row+col]);
|
||||
}
|
||||
if(savebmp(tempstr, dstbuf, w, h, bmpPF[pf], pitch,
|
||||
(flags&TJFLAG_BOTTOMUP)!=0)==-1)
|
||||
_throwbmp("saving bitmap");
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(file) {fclose(file); file=NULL;}
|
||||
if(handle) {tjDestroy(handle); handle=NULL;}
|
||||
if(dstbuf && dstbufalloc) {free(dstbuf); dstbuf=NULL;}
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
void dotest(unsigned char *srcbuf, int w, int h, int subsamp, int jpegqual,
|
||||
char *filename)
|
||||
{
|
||||
char tempstr[1024], tempstr2[80];
|
||||
FILE *file=NULL; tjhandle handle=NULL;
|
||||
unsigned char **jpegbuf=NULL, *tmpbuf=NULL, *srcptr, *srcptr2;
|
||||
double start, elapsed;
|
||||
int totaljpegsize=0, row, col, i, tilew=w, tileh=h, retval=0;
|
||||
unsigned long *jpegsize=NULL;
|
||||
int ps=tjPixelSize[pf], ntilesw=1, ntilesh=1, pitch=w*ps;
|
||||
|
||||
if((tmpbuf=(unsigned char *)malloc(pitch*h)) == NULL)
|
||||
_throwunix("allocating temporary image buffer");
|
||||
|
||||
if(!quiet)
|
||||
printf(">>>>> %s (%s) <--> JPEG %s Q%d <<<<<\n", pixFormatStr[pf],
|
||||
(flags&TJFLAG_BOTTOMUP)? "Bottom-up":"Top-down", subNameLong[subsamp],
|
||||
jpegqual);
|
||||
|
||||
for(tilew=dotile? 8:w, tileh=dotile? 8:h; ; tilew*=2, tileh*=2)
|
||||
{
|
||||
if(tilew>w) tilew=w; if(tileh>h) tileh=h;
|
||||
ntilesw=(w+tilew-1)/tilew; ntilesh=(h+tileh-1)/tileh;
|
||||
|
||||
if((jpegbuf=(unsigned char **)malloc(sizeof(unsigned char *)
|
||||
*ntilesw*ntilesh))==NULL)
|
||||
_throwunix("allocating JPEG tile array");
|
||||
memset(jpegbuf, 0, sizeof(unsigned char *)*ntilesw*ntilesh);
|
||||
if((jpegsize=(unsigned long *)malloc(sizeof(unsigned long)
|
||||
*ntilesw*ntilesh))==NULL)
|
||||
_throwunix("allocating JPEG size array");
|
||||
memset(jpegsize, 0, sizeof(unsigned long)*ntilesw*ntilesh);
|
||||
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
if((jpegbuf[i]=(unsigned char *)malloc(tjBufSize(tilew, tileh,
|
||||
subsamp)))==NULL)
|
||||
_throwunix("allocating JPEG tiles");
|
||||
}
|
||||
|
||||
/* Compression test */
|
||||
if(quiet==1)
|
||||
printf("%s\t%s\t%s\t%d\t", pixFormatStr[pf],
|
||||
(flags&TJFLAG_BOTTOMUP)? "BU":"TD", subNameLong[subsamp], jpegqual);
|
||||
for(i=0; i<h; i++)
|
||||
memcpy(&tmpbuf[pitch*i], &srcbuf[w*ps*i], w*ps);
|
||||
if((handle=tjInitCompress())==NULL)
|
||||
_throwtj("executing tjInitCompress()");
|
||||
|
||||
/* Execute once to preload cache */
|
||||
if(tjCompress2(handle, srcbuf, tilew, pitch, tileh, pf, &jpegbuf[0],
|
||||
&jpegsize[0], subsamp, jpegqual, flags)==-1)
|
||||
_throwtj("executing tjCompress2()");
|
||||
|
||||
/* Benchmark */
|
||||
for(i=0, start=gettime(); (elapsed=gettime()-start)<benchtime; i++)
|
||||
{
|
||||
int tile=0;
|
||||
totaljpegsize=0;
|
||||
for(row=0, srcptr=srcbuf; row<ntilesh; row++, srcptr+=pitch*tileh)
|
||||
{
|
||||
for(col=0, srcptr2=srcptr; col<ntilesw; col++, tile++,
|
||||
srcptr2+=ps*tilew)
|
||||
{
|
||||
int width=min(tilew, w-col*tilew);
|
||||
int height=min(tileh, h-row*tileh);
|
||||
if(tjCompress2(handle, srcptr2, width, pitch, height, pf,
|
||||
&jpegbuf[tile], &jpegsize[tile], subsamp, jpegqual, flags)==-1)
|
||||
_throwtj("executing tjCompress()2");
|
||||
totaljpegsize+=jpegsize[tile];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(tjDestroy(handle)==-1) _throwtj("executing tjDestroy()");
|
||||
handle=NULL;
|
||||
|
||||
if(quiet==1) printf("%-4d %-4d\t", tilew, tileh);
|
||||
if(quiet)
|
||||
{
|
||||
printf("%s%c%s%c",
|
||||
sigfig((double)(w*h)/1000000.*(double)i/elapsed, 4, tempstr, 1024),
|
||||
quiet==2? '\n':'\t',
|
||||
sigfig((double)(w*h*ps)/(double)totaljpegsize, 4, tempstr2, 80),
|
||||
quiet==2? '\n':'\t');
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n%s size: %d x %d\n", dotile? "Tile":"Image", tilew,
|
||||
tileh);
|
||||
printf("C--> Frame rate: %f fps\n", (double)i/elapsed);
|
||||
printf(" Output image size: %d bytes\n", totaljpegsize);
|
||||
printf(" Compression ratio: %f:1\n",
|
||||
(double)(w*h*ps)/(double)totaljpegsize);
|
||||
printf(" Source throughput: %f Megapixels/sec\n",
|
||||
(double)(w*h)/1000000.*(double)i/elapsed);
|
||||
printf(" Output bit stream: %f Megabits/sec\n",
|
||||
(double)totaljpegsize*8./1000000.*(double)i/elapsed);
|
||||
}
|
||||
if(tilew==w && tileh==h)
|
||||
{
|
||||
snprintf(tempstr, 1024, "%s_%s_Q%d.jpg", filename, subName[subsamp],
|
||||
jpegqual);
|
||||
if((file=fopen(tempstr, "wb"))==NULL)
|
||||
_throwunix("opening reference image");
|
||||
if(fwrite(jpegbuf[0], jpegsize[0], 1, file)!=1)
|
||||
_throwunix("writing reference image");
|
||||
fclose(file); file=NULL;
|
||||
if(!quiet) printf("Reference image written to %s\n", tempstr);
|
||||
}
|
||||
|
||||
/* Decompression test */
|
||||
if(decomptest(srcbuf, jpegbuf, jpegsize, tmpbuf, w, h, subsamp, jpegqual,
|
||||
filename, tilew, tileh)==-1)
|
||||
goto bailout;
|
||||
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
if(jpegbuf[i]) free(jpegbuf[i]); jpegbuf[i]=NULL;
|
||||
}
|
||||
free(jpegbuf); jpegbuf=NULL;
|
||||
free(jpegsize); jpegsize=NULL;
|
||||
|
||||
if(tilew==w && tileh==h) break;
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(file) {fclose(file); file=NULL;}
|
||||
if(jpegbuf)
|
||||
{
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
if(jpegbuf[i]) free(jpegbuf[i]); jpegbuf[i]=NULL;
|
||||
}
|
||||
free(jpegbuf); jpegbuf=NULL;
|
||||
}
|
||||
if(jpegsize) {free(jpegsize); jpegsize=NULL;}
|
||||
if(tmpbuf) {free(tmpbuf); tmpbuf=NULL;}
|
||||
if(handle) {tjDestroy(handle); handle=NULL;}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void dodecomptest(char *filename)
|
||||
{
|
||||
FILE *file=NULL; tjhandle handle=NULL;
|
||||
unsigned char **jpegbuf=NULL, *srcbuf=NULL;
|
||||
unsigned long *jpegsize=NULL, srcsize;
|
||||
int w=0, h=0, subsamp=-1, _w, _h, _tilew, _tileh, _subsamp;
|
||||
char *temp=NULL;
|
||||
int i, tilew, tileh, ntilesw=1, ntilesh=1, retval=0;
|
||||
|
||||
if((file=fopen(filename, "rb"))==NULL)
|
||||
_throwunix("opening file");
|
||||
if(fseek(file, 0, SEEK_END)<0 || (srcsize=ftell(file))<0)
|
||||
_throwunix("determining file size");
|
||||
if((srcbuf=(unsigned char *)malloc(srcsize))==NULL)
|
||||
_throwunix("allocating memory");
|
||||
if(fseek(file, 0, SEEK_SET)<0)
|
||||
_throwunix("setting file position");
|
||||
if(fread(srcbuf, srcsize, 1, file)<1)
|
||||
_throwunix("reading JPEG data");
|
||||
fclose(file); file=NULL;
|
||||
|
||||
temp=strrchr(filename, '.');
|
||||
if(temp!=NULL) *temp='\0';
|
||||
|
||||
if((handle=tjInitDecompress())==NULL)
|
||||
_throwtj("executing tjInitDecompress()");
|
||||
if(tjDecompressHeader2(handle, srcbuf, srcsize, &w, &h, &subsamp)==-1)
|
||||
_throwtj("executing tjDecompressHeader2()");
|
||||
|
||||
if(quiet==1)
|
||||
{
|
||||
printf("All performance values in Mpixels/sec\n\n");
|
||||
printf("Bitmap\tBitmap\tJPEG\t%s %s \tXform\tComp\tDecomp\n",
|
||||
dotile? "Tile ":"Image", dotile? "Tile ":"Image");
|
||||
printf("Format\tOrder\tSubsamp\tWidth Height\tPerf \tRatio\tPerf\n\n");
|
||||
}
|
||||
else if(!quiet)
|
||||
{
|
||||
printf(">>>>> JPEG %s --> %s (%s) <<<<<\n", subNameLong[subsamp],
|
||||
pixFormatStr[pf], (flags&TJFLAG_BOTTOMUP)? "Bottom-up":"Top-down");
|
||||
}
|
||||
|
||||
for(tilew=dotile? 16:w, tileh=dotile? 16:h; ; tilew*=2, tileh*=2)
|
||||
{
|
||||
if(tilew>w) tilew=w; if(tileh>h) tileh=h;
|
||||
ntilesw=(w+tilew-1)/tilew; ntilesh=(h+tileh-1)/tileh;
|
||||
|
||||
if((jpegbuf=(unsigned char **)malloc(sizeof(unsigned char *)
|
||||
*ntilesw*ntilesh))==NULL)
|
||||
_throwunix("allocating JPEG tile array");
|
||||
memset(jpegbuf, 0, sizeof(unsigned char *)*ntilesw*ntilesh);
|
||||
if((jpegsize=(unsigned long *)malloc(sizeof(unsigned long)
|
||||
*ntilesw*ntilesh))==NULL)
|
||||
_throwunix("allocating JPEG size array");
|
||||
memset(jpegsize, 0, sizeof(unsigned long)*ntilesw*ntilesh);
|
||||
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
if((jpegbuf[i]=(unsigned char *)malloc(tjBufSize(tilew, tileh,
|
||||
subsamp)))==NULL)
|
||||
_throwunix("allocating JPEG tiles");
|
||||
}
|
||||
|
||||
_w=w; _h=h; _tilew=tilew; _tileh=tileh;
|
||||
if(!quiet)
|
||||
{
|
||||
printf("\n%s size: %d x %d", dotile? "Tile":"Image", _tilew,
|
||||
_tileh);
|
||||
if(sf.num!=1 || sf.denom!=1)
|
||||
printf(" --> %d x %d", TJSCALED(_w, sf), TJSCALED(_h, sf));
|
||||
printf("\n");
|
||||
}
|
||||
else if(quiet==1)
|
||||
{
|
||||
printf("%s\t%s\t%s\t", pixFormatStr[pf],
|
||||
(flags&TJFLAG_BOTTOMUP)? "BU":"TD", subNameLong[subsamp]);
|
||||
printf("%-4d %-4d\t", tilew, tileh);
|
||||
}
|
||||
|
||||
_subsamp=subsamp;
|
||||
if(quiet==1) printf("N/A\tN/A\t");
|
||||
jpegsize[0]=srcsize;
|
||||
memcpy(jpegbuf[0], srcbuf, srcsize);
|
||||
|
||||
if(w==tilew) _tilew=_w;
|
||||
if(h==tileh) _tileh=_h;
|
||||
if(decomptest(NULL, jpegbuf, jpegsize, NULL, _w, _h, _subsamp, 0,
|
||||
filename, _tilew, _tileh)==-1)
|
||||
goto bailout;
|
||||
else if(quiet==1) printf("N/A\n");
|
||||
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
free(jpegbuf[i]); jpegbuf[i]=NULL;
|
||||
}
|
||||
free(jpegbuf); jpegbuf=NULL;
|
||||
if(jpegsize) {free(jpegsize); jpegsize=NULL;}
|
||||
|
||||
if(tilew==w && tileh==h) break;
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(file) {fclose(file); file=NULL;}
|
||||
if(jpegbuf)
|
||||
{
|
||||
for(i=0; i<ntilesw*ntilesh; i++)
|
||||
{
|
||||
if(jpegbuf[i]) free(jpegbuf[i]); jpegbuf[i]=NULL;
|
||||
}
|
||||
free(jpegbuf); jpegbuf=NULL;
|
||||
}
|
||||
if(jpegsize) {free(jpegsize); jpegsize=NULL;}
|
||||
if(srcbuf) {free(srcbuf); srcbuf=NULL;}
|
||||
if(handle) {tjDestroy(handle); handle=NULL;}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void usage(char *progname)
|
||||
{
|
||||
int i;
|
||||
printf("USAGE: %s\n", progname);
|
||||
printf(" <Inputfile (BMP|PPM)> <%% Quality> [options]\n\n");
|
||||
printf(" %s\n", progname);
|
||||
printf(" <Inputfile (JPG)> [options]\n\n");
|
||||
printf("Options:\n\n");
|
||||
printf("-bmp = Generate output images in Windows Bitmap format (default=PPM)\n");
|
||||
printf("-bottomup = Test bottom-up compression/decompression\n");
|
||||
printf("-tile = Test performance of the codec when the image is encoded as separate\n");
|
||||
printf(" tiles of varying sizes.\n");
|
||||
printf("-forcemmx, -forcesse, -forcesse2, -forcesse3 =\n");
|
||||
printf(" Force MMX, SSE, SSE2, or SSE3 code paths in the underlying codec\n");
|
||||
printf("-rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb =\n");
|
||||
printf(" Test the specified color conversion path in the codec (default: BGR)\n");
|
||||
printf("-fastupsample = Use fast, inaccurate upsampling code to perform 4:2:2 and 4:2:0\n");
|
||||
printf(" YUV decoding\n");
|
||||
printf("-quiet = Output results in tabular rather than verbose format\n");
|
||||
printf("-scale M/N = scale down the width/height of the decompressed JPEG image by a\n");
|
||||
printf(" factor of M/N (M/N = ");
|
||||
for(i=0; i<nsf; i++)
|
||||
{
|
||||
printf("%d/%d", scalingfactors[i].num, scalingfactors[i].denom);
|
||||
if(nsf==2 && i!=nsf-1) printf(" or ");
|
||||
else if(nsf>2)
|
||||
{
|
||||
if(i!=nsf-1) printf(", ");
|
||||
if(i==nsf-2) printf("or ");
|
||||
}
|
||||
}
|
||||
printf(")\n");
|
||||
printf("-benchtime <t> = Run each benchmark for at least <t> seconds (default = 5.0)\n\n");
|
||||
printf("NOTE: If the quality is specified as a range (e.g. 90-100), a separate\n");
|
||||
printf("test will be performed for all quality values in the range.\n\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
unsigned char *srcbuf=NULL; int w, h, i, j;
|
||||
int minqual=-1, maxqual=-1; char *temp;
|
||||
int minarg=2; int retval=0;
|
||||
|
||||
if((scalingfactors=tjGetScalingFactors(&nsf))==NULL || nsf==0)
|
||||
_throwtj("executing tjGetScalingFactors()");
|
||||
|
||||
if(argc<minarg) usage(argv[0]);
|
||||
|
||||
temp=strrchr(argv[1], '.');
|
||||
if(temp!=NULL)
|
||||
{
|
||||
if(!strcasecmp(temp, ".bmp")) ext="bmp";
|
||||
if(!strcasecmp(temp, ".jpg") || !strcasecmp(temp, ".jpeg")) decomponly=1;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
|
||||
if(!decomponly)
|
||||
{
|
||||
minarg=3;
|
||||
if(argc<minarg) usage(argv[0]);
|
||||
if((minqual=atoi(argv[2]))<1 || minqual>100)
|
||||
{
|
||||
puts("ERROR: Quality must be between 1 and 100.");
|
||||
exit(1);
|
||||
}
|
||||
if((temp=strchr(argv[2], '-'))!=NULL && strlen(temp)>1
|
||||
&& sscanf(&temp[1], "%d", &maxqual)==1 && maxqual>minqual && maxqual>=1
|
||||
&& maxqual<=100) {}
|
||||
else maxqual=minqual;
|
||||
}
|
||||
|
||||
if(argc>minarg)
|
||||
{
|
||||
for(i=minarg; i<argc; i++)
|
||||
{
|
||||
if(!strcasecmp(argv[i], "-tile"))
|
||||
{
|
||||
dotile=1;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-forcesse3"))
|
||||
{
|
||||
printf("Forcing SSE3 code\n\n");
|
||||
flags|=TJFLAG_FORCESSE3;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-forcesse2"))
|
||||
{
|
||||
printf("Forcing SSE2 code\n\n");
|
||||
flags|=TJFLAG_FORCESSE2;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-forcesse"))
|
||||
{
|
||||
printf("Forcing SSE code\n\n");
|
||||
flags|=TJFLAG_FORCESSE;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-forcemmx"))
|
||||
{
|
||||
printf("Forcing MMX code\n\n");
|
||||
flags|=TJFLAG_FORCEMMX;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-fastupsample"))
|
||||
{
|
||||
printf("Using fast upsampling code\n\n");
|
||||
flags|=TJFLAG_FASTUPSAMPLE;
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-rgb")) pf=TJPF_RGB;
|
||||
if(!strcasecmp(argv[i], "-rgbx")) pf=TJPF_RGBX;
|
||||
if(!strcasecmp(argv[i], "-bgr")) pf=TJPF_BGR;
|
||||
if(!strcasecmp(argv[i], "-bgrx")) pf=TJPF_BGRX;
|
||||
if(!strcasecmp(argv[i], "-xbgr")) pf=TJPF_XBGR;
|
||||
if(!strcasecmp(argv[i], "-xrgb")) pf=TJPF_XRGB;
|
||||
if(!strcasecmp(argv[i], "-bottomup")) flags|=TJFLAG_BOTTOMUP;
|
||||
if(!strcasecmp(argv[i], "-quiet")) quiet=1;
|
||||
if(!strcasecmp(argv[i], "-qq")) quiet=2;
|
||||
if(!strcasecmp(argv[i], "-scale") && i<argc-1)
|
||||
{
|
||||
int temp1=0, temp2=0, match=0;
|
||||
if(sscanf(argv[++i], "%d/%d", &temp1, &temp2)==2)
|
||||
{
|
||||
for(j=0; j<nsf; j++)
|
||||
{
|
||||
if(temp1==scalingfactors[j].num && temp2==scalingfactors[j].denom)
|
||||
{
|
||||
sf=scalingfactors[j];
|
||||
match=1; break;
|
||||
}
|
||||
}
|
||||
if(!match) usage(argv[0]);
|
||||
}
|
||||
else usage(argv[0]);
|
||||
}
|
||||
if(!strcasecmp(argv[i], "-benchtime") && i<argc-1)
|
||||
{
|
||||
double temp=atof(argv[++i]);
|
||||
if(temp>0.0) benchtime=temp;
|
||||
else usage(argv[0]);
|
||||
}
|
||||
if(!strcmp(argv[i], "-?")) usage(argv[0]);
|
||||
if(!strcasecmp(argv[i], "-bmp")) ext="bmp";
|
||||
}
|
||||
}
|
||||
|
||||
if((sf.num!=1 || sf.denom!=1) && dotile)
|
||||
{
|
||||
printf("Disabling tiled compression/decompression tests, because those tests do not\n");
|
||||
printf("work when scaled decompression is enabled.\n");
|
||||
dotile=0;
|
||||
}
|
||||
|
||||
if(!decomponly)
|
||||
{
|
||||
if(loadbmp(argv[1], &srcbuf, &w, &h, bmpPF[pf], 1,
|
||||
(flags&TJFLAG_BOTTOMUP)!=0)==-1)
|
||||
_throwbmp("loading bitmap");
|
||||
temp=strrchr(argv[1], '.');
|
||||
if(temp!=NULL) *temp='\0';
|
||||
}
|
||||
|
||||
if(quiet==1 && !decomponly)
|
||||
{
|
||||
printf("All performance values in Mpixels/sec\n\n");
|
||||
printf("Bitmap\tBitmap\tJPEG\tJPEG\t%s %s \tComp\tComp\tDecomp\n",
|
||||
dotile? "Tile ":"Image", dotile? "Tile ":"Image");
|
||||
printf("Format\tOrder\tSubsamp\tQual\tWidth Height\tPerf \tRatio\tPerf\n\n");
|
||||
}
|
||||
|
||||
if(decomponly)
|
||||
{
|
||||
dodecomptest(argv[1]);
|
||||
printf("\n");
|
||||
goto bailout;
|
||||
}
|
||||
for(i=maxqual; i>=minqual; i--)
|
||||
dotest(srcbuf, w, h, TJ_GRAYSCALE, i, argv[1]);
|
||||
printf("\n");
|
||||
for(i=maxqual; i>=minqual; i--)
|
||||
dotest(srcbuf, w, h, TJ_420, i, argv[1]);
|
||||
printf("\n");
|
||||
for(i=maxqual; i>=minqual; i--)
|
||||
dotest(srcbuf, w, h, TJ_422, i, argv[1]);
|
||||
printf("\n");
|
||||
for(i=maxqual; i>=minqual; i--)
|
||||
dotest(srcbuf, w, h, TJ_444, i, argv[1]);
|
||||
printf("\n");
|
||||
|
||||
bailout:
|
||||
if(srcbuf) free(srcbuf);
|
||||
return retval;
|
||||
}
|
||||
@ -0,0 +1,461 @@
|
||||
/*
|
||||
* Copyright (C)2009-2012 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This program tests the various code paths in the TurboJPEG C Wrapper
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include "./tjutil.h"
|
||||
#include "./turbojpeg.h"
|
||||
#ifdef _WIN32
|
||||
#include <time.h>
|
||||
#define random() rand()
|
||||
#endif
|
||||
|
||||
|
||||
#define _throwtj() {printf("TurboJPEG ERROR:\n%s\n", tjGetErrorStr()); \
|
||||
bailout();}
|
||||
#define _tj(f) {if((f)==-1) _throwtj();}
|
||||
#define _throw(m) {printf("ERROR: %s\n", m); bailout();}
|
||||
|
||||
const char *subNameLong[TJ_NUMSAMP]=
|
||||
{
|
||||
"4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0"
|
||||
};
|
||||
const char *subName[TJ_NUMSAMP]={"444", "422", "420", "GRAY", "440"};
|
||||
|
||||
const char *pixFormatStr[TJ_NUMPF]=
|
||||
{
|
||||
"RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
|
||||
"RGBA", "BGRA", "ABGR", "ARGB"
|
||||
};
|
||||
|
||||
const int alphaOffset[TJ_NUMPF] = {-1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0};
|
||||
|
||||
const int _3byteFormats[]={TJPF_RGB, TJPF_BGR};
|
||||
const int _4byteFormats[]={TJPF_RGBX, TJPF_BGRX, TJPF_XBGR, TJPF_XRGB};
|
||||
const int _onlyGray[]={TJPF_GRAY};
|
||||
const int _onlyRGB[]={TJPF_RGB};
|
||||
|
||||
int exitStatus=0;
|
||||
#define bailout() {exitStatus=-1; goto bailout;}
|
||||
|
||||
|
||||
void initBuf(unsigned char *buf, int w, int h, int pf, int flags)
|
||||
{
|
||||
int roffset=tjRedOffset[pf];
|
||||
int goffset=tjGreenOffset[pf];
|
||||
int boffset=tjBlueOffset[pf];
|
||||
int ps=tjPixelSize[pf];
|
||||
int index, row, col, halfway=16;
|
||||
|
||||
memset(buf, 0, w*h*ps);
|
||||
if(pf==TJPF_GRAY)
|
||||
{
|
||||
for(row=0; row<h; row++)
|
||||
{
|
||||
for(col=0; col<w; col++)
|
||||
{
|
||||
if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
|
||||
else index=row*w+col;
|
||||
if(((row/8)+(col/8))%2==0) buf[index]=(row<halfway)? 255:0;
|
||||
else buf[index]=(row<halfway)? 76:226;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(row=0; row<h; row++)
|
||||
{
|
||||
for(col=0; col<w; col++)
|
||||
{
|
||||
if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
|
||||
else index=row*w+col;
|
||||
if(((row/8)+(col/8))%2==0)
|
||||
{
|
||||
if(row<halfway)
|
||||
{
|
||||
buf[index*ps+roffset]=255;
|
||||
buf[index*ps+goffset]=255;
|
||||
buf[index*ps+boffset]=255;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
buf[index*ps+roffset]=255;
|
||||
if(row>=halfway) buf[index*ps+goffset]=255;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#define checkval(v, cv) { \
|
||||
if(v<cv-1 || v>cv+1) { \
|
||||
printf("\nComp. %s at %d,%d should be %d, not %d\n", \
|
||||
#v, row, col, cv, v); \
|
||||
retval=0; exitStatus=-1; goto bailout; \
|
||||
}}
|
||||
|
||||
#define checkval0(v) { \
|
||||
if(v>1) { \
|
||||
printf("\nComp. %s at %d,%d should be 0, not %d\n", #v, row, col, v); \
|
||||
retval=0; exitStatus=-1; goto bailout; \
|
||||
}}
|
||||
|
||||
#define checkval255(v) { \
|
||||
if(v<254) { \
|
||||
printf("\nComp. %s at %d,%d should be 255, not %d\n", #v, row, col, v); \
|
||||
retval=0; exitStatus=-1; goto bailout; \
|
||||
}}
|
||||
|
||||
|
||||
int checkBuf(unsigned char *buf, int w, int h, int pf, int subsamp,
|
||||
tjscalingfactor sf, int flags)
|
||||
{
|
||||
int roffset=tjRedOffset[pf];
|
||||
int goffset=tjGreenOffset[pf];
|
||||
int boffset=tjBlueOffset[pf];
|
||||
int aoffset=alphaOffset[pf];
|
||||
int ps=tjPixelSize[pf];
|
||||
int index, row, col, retval=1;
|
||||
int halfway=16*sf.num/sf.denom;
|
||||
int blocksize=8*sf.num/sf.denom;
|
||||
|
||||
for(row=0; row<h; row++)
|
||||
{
|
||||
for(col=0; col<w; col++)
|
||||
{
|
||||
unsigned char r, g, b, a;
|
||||
if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
|
||||
else index=row*w+col;
|
||||
r=buf[index*ps+roffset];
|
||||
g=buf[index*ps+goffset];
|
||||
b=buf[index*ps+boffset];
|
||||
a=aoffset>=0? buf[index*ps+aoffset]:0xFF;
|
||||
if(((row/blocksize)+(col/blocksize))%2==0)
|
||||
{
|
||||
if(row<halfway)
|
||||
{
|
||||
checkval255(r); checkval255(g); checkval255(b);
|
||||
}
|
||||
else
|
||||
{
|
||||
checkval0(r); checkval0(g); checkval0(b);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(subsamp==TJSAMP_GRAY)
|
||||
{
|
||||
if(row<halfway)
|
||||
{
|
||||
checkval(r, 76); checkval(g, 76); checkval(b, 76);
|
||||
}
|
||||
else
|
||||
{
|
||||
checkval(r, 226); checkval(g, 226); checkval(b, 226);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(row<halfway)
|
||||
{
|
||||
checkval255(r); checkval0(g); checkval0(b);
|
||||
}
|
||||
else
|
||||
{
|
||||
checkval255(r); checkval255(g); checkval0(b);
|
||||
}
|
||||
}
|
||||
}
|
||||
checkval255(a);
|
||||
}
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(retval==0)
|
||||
{
|
||||
printf("\n");
|
||||
for(row=0; row<h; row++)
|
||||
{
|
||||
for(col=0; col<w; col++)
|
||||
{
|
||||
printf("%.3d/%.3d/%.3d ", buf[(row*w+col)*ps+roffset],
|
||||
buf[(row*w+col)*ps+goffset], buf[(row*w+col)*ps+boffset]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
void writeJPEG(unsigned char *jpegBuf, unsigned long jpegSize, char *filename)
|
||||
{
|
||||
FILE *file=fopen(filename, "wb");
|
||||
if(!file || fwrite(jpegBuf, jpegSize, 1, file)!=1)
|
||||
{
|
||||
printf("ERROR: Could not write to %s.\n%s\n", filename, strerror(errno));
|
||||
bailout();
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(file) fclose(file);
|
||||
}
|
||||
|
||||
|
||||
void compTest(tjhandle handle, unsigned char **dstBuf,
|
||||
unsigned long *dstSize, int w, int h, int pf, char *basename,
|
||||
int subsamp, int jpegQual, int flags)
|
||||
{
|
||||
char tempStr[1024]; unsigned char *srcBuf=NULL;
|
||||
double t;
|
||||
|
||||
printf("%s %s -> %s Q%d ... ", pixFormatStr[pf],
|
||||
(flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ", subNameLong[subsamp],
|
||||
jpegQual);
|
||||
|
||||
if((srcBuf=(unsigned char *)malloc(w*h*tjPixelSize[pf]))==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
initBuf(srcBuf, w, h, pf, flags);
|
||||
if(*dstBuf && *dstSize>0) memset(*dstBuf, 0, *dstSize);
|
||||
|
||||
t=gettime();
|
||||
*dstSize=tjBufSize(w, h, subsamp);
|
||||
_tj(tjCompress2(handle, srcBuf, w, 0, h, pf, dstBuf, dstSize, subsamp,
|
||||
jpegQual, flags));
|
||||
t=gettime()-t;
|
||||
|
||||
snprintf(tempStr, 1024, "%s_enc_%s_%s_%s_Q%d.jpg", basename,
|
||||
pixFormatStr[pf], (flags&TJFLAG_BOTTOMUP)? "BU":"TD", subName[subsamp],
|
||||
jpegQual);
|
||||
writeJPEG(*dstBuf, *dstSize, tempStr);
|
||||
printf("Done.");
|
||||
printf(" %f ms\n Result in %s\n", t*1000., tempStr);
|
||||
|
||||
bailout:
|
||||
if(srcBuf) free(srcBuf);
|
||||
}
|
||||
|
||||
|
||||
void _decompTest(tjhandle handle, unsigned char *jpegBuf,
|
||||
unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
|
||||
int flags, tjscalingfactor sf)
|
||||
{
|
||||
unsigned char *dstBuf=NULL;
|
||||
int _hdrw=0, _hdrh=0, _hdrsubsamp=-1; double t;
|
||||
int scaledWidth=TJSCALED(w, sf);
|
||||
int scaledHeight=TJSCALED(h, sf);
|
||||
unsigned long dstSize=0;
|
||||
|
||||
printf("JPEG -> %s %s ", pixFormatStr[pf],
|
||||
(flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ");
|
||||
if(sf.num!=1 || sf.denom!=1)
|
||||
printf("%d/%d ... ", sf.num, sf.denom);
|
||||
else printf("... ");
|
||||
|
||||
_tj(tjDecompressHeader2(handle, jpegBuf, jpegSize, &_hdrw, &_hdrh,
|
||||
&_hdrsubsamp));
|
||||
if(_hdrw!=w || _hdrh!=h || _hdrsubsamp!=subsamp)
|
||||
_throw("Incorrect JPEG header");
|
||||
|
||||
dstSize=scaledWidth*scaledHeight*tjPixelSize[pf];
|
||||
if((dstBuf=(unsigned char *)malloc(dstSize))==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
memset(dstBuf, 0, dstSize);
|
||||
|
||||
t=gettime();
|
||||
_tj(tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, scaledWidth, 0,
|
||||
scaledHeight, pf, flags));
|
||||
t=gettime()-t;
|
||||
|
||||
if(checkBuf(dstBuf, scaledWidth, scaledHeight, pf, subsamp, sf, flags))
|
||||
printf("Passed.");
|
||||
else printf("FAILED!");
|
||||
printf(" %f ms\n", t*1000.);
|
||||
|
||||
bailout:
|
||||
if(dstBuf) free(dstBuf);
|
||||
}
|
||||
|
||||
|
||||
void decompTest(tjhandle handle, unsigned char *jpegBuf,
|
||||
unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
|
||||
int flags)
|
||||
{
|
||||
int i, n=0;
|
||||
tjscalingfactor *sf=tjGetScalingFactors(&n), sf1={1, 1};
|
||||
if(!sf || !n) _throwtj();
|
||||
|
||||
if((subsamp==TJSAMP_444 || subsamp==TJSAMP_GRAY))
|
||||
{
|
||||
for(i=0; i<n; i++)
|
||||
_decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
|
||||
flags, sf[i]);
|
||||
}
|
||||
else
|
||||
_decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp, flags,
|
||||
sf1);
|
||||
|
||||
bailout:
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
|
||||
void doTest(int w, int h, const int *formats, int nformats, int subsamp,
|
||||
char *basename)
|
||||
{
|
||||
tjhandle chandle=NULL, dhandle=NULL;
|
||||
unsigned char *dstBuf=NULL;
|
||||
unsigned long size=0; int pfi, pf, i;
|
||||
|
||||
size=tjBufSize(w, h, subsamp);
|
||||
if((dstBuf=(unsigned char *)malloc(size))==NULL)
|
||||
_throw("Memory allocation failure.");
|
||||
|
||||
if((chandle=tjInitCompress())==NULL || (dhandle=tjInitDecompress())==NULL)
|
||||
_throwtj();
|
||||
|
||||
for(pfi=0; pfi<nformats; pfi++)
|
||||
{
|
||||
for(i=0; i<2; i++)
|
||||
{
|
||||
int flags=0;
|
||||
if(subsamp==TJSAMP_422 || subsamp==TJSAMP_420 || subsamp==TJSAMP_440)
|
||||
flags|=TJFLAG_FASTUPSAMPLE;
|
||||
if(i==1) flags|=TJFLAG_BOTTOMUP;
|
||||
pf=formats[pfi];
|
||||
compTest(chandle, &dstBuf, &size, w, h, pf, basename, subsamp, 100,
|
||||
flags);
|
||||
decompTest(dhandle, dstBuf, size, w, h, pf, basename, subsamp,
|
||||
flags);
|
||||
if(pf>=TJPF_RGBX && pf<=TJPF_XRGB)
|
||||
decompTest(dhandle, dstBuf, size, w, h, pf+(TJPF_RGBA-TJPF_RGBX),
|
||||
basename, subsamp, flags);
|
||||
}
|
||||
}
|
||||
|
||||
bailout:
|
||||
if(chandle) tjDestroy(chandle);
|
||||
if(dhandle) tjDestroy(dhandle);
|
||||
|
||||
if(dstBuf) free(dstBuf);
|
||||
}
|
||||
|
||||
|
||||
void bufSizeTest(void)
|
||||
{
|
||||
int w, h, i, subsamp;
|
||||
unsigned char *srcBuf=NULL, *jpegBuf=NULL;
|
||||
tjhandle handle=NULL;
|
||||
unsigned long jpegSize=0;
|
||||
|
||||
if((handle=tjInitCompress())==NULL) _throwtj();
|
||||
|
||||
printf("Buffer size regression test\n");
|
||||
for(subsamp=0; subsamp<TJ_NUMSAMP; subsamp++)
|
||||
{
|
||||
for(w=1; w<48; w++)
|
||||
{
|
||||
int maxh=(w==1)? 2048:48;
|
||||
for(h=1; h<maxh; h++)
|
||||
{
|
||||
if(h%100==0) printf("%.4d x %.4d\b\b\b\b\b\b\b\b\b\b\b", w, h);
|
||||
if((srcBuf=(unsigned char *)malloc(w*h*4))==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
if((jpegBuf=(unsigned char *)malloc(tjBufSize(w, h, subsamp)))
|
||||
==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
jpegSize=tjBufSize(w, h, subsamp);
|
||||
|
||||
for(i=0; i<w*h*4; i++)
|
||||
{
|
||||
if(random()<RAND_MAX/2) srcBuf[i]=0;
|
||||
else srcBuf[i]=255;
|
||||
}
|
||||
|
||||
_tj(tjCompress2(handle, srcBuf, w, 0, h, TJPF_BGRX, &jpegBuf,
|
||||
&jpegSize, subsamp, 100, 0));
|
||||
free(srcBuf); srcBuf=NULL;
|
||||
free(jpegBuf); jpegBuf=NULL;
|
||||
|
||||
if((srcBuf=(unsigned char *)malloc(h*w*4))==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
if((jpegBuf=(unsigned char *)malloc(tjBufSize(h, w, subsamp)))
|
||||
==NULL)
|
||||
_throw("Memory allocation failure");
|
||||
jpegSize=tjBufSize(h, w, subsamp);
|
||||
|
||||
for(i=0; i<h*w*4; i++)
|
||||
{
|
||||
if(random()<RAND_MAX/2) srcBuf[i]=0;
|
||||
else srcBuf[i]=255;
|
||||
}
|
||||
|
||||
_tj(tjCompress2(handle, srcBuf, h, 0, w, TJPF_BGRX, &jpegBuf,
|
||||
&jpegSize, subsamp, 100, 0));
|
||||
free(srcBuf); srcBuf=NULL;
|
||||
free(jpegBuf); jpegBuf=NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("Done. \n");
|
||||
|
||||
bailout:
|
||||
if(srcBuf) free(srcBuf);
|
||||
if(jpegBuf) free(jpegBuf);
|
||||
if(handle) tjDestroy(handle);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
#ifdef _WIN32
|
||||
srand((unsigned int)time(NULL));
|
||||
#endif
|
||||
doTest(35, 39, _3byteFormats, 2, TJSAMP_444, "test");
|
||||
doTest(39, 41, _4byteFormats, 4, TJSAMP_444, "test");
|
||||
doTest(41, 35, _3byteFormats, 2, TJSAMP_422, "test");
|
||||
doTest(35, 39, _4byteFormats, 4, TJSAMP_422, "test");
|
||||
doTest(39, 41, _3byteFormats, 2, TJSAMP_420, "test");
|
||||
doTest(41, 35, _4byteFormats, 4, TJSAMP_420, "test");
|
||||
doTest(35, 39, _3byteFormats, 2, TJSAMP_440, "test");
|
||||
doTest(39, 41, _4byteFormats, 4, TJSAMP_440, "test");
|
||||
doTest(35, 39, _onlyGray, 1, TJSAMP_GRAY, "test");
|
||||
doTest(39, 41, _3byteFormats, 2, TJSAMP_GRAY, "test");
|
||||
doTest(41, 35, _4byteFormats, 4, TJSAMP_GRAY, "test");
|
||||
bufSizeTest();
|
||||
|
||||
return exitStatus;
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (C)2011 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
static double getfreq(void)
|
||||
{
|
||||
LARGE_INTEGER freq;
|
||||
if(!QueryPerformanceFrequency(&freq)) return 0.0;
|
||||
return (double)freq.QuadPart;
|
||||
}
|
||||
|
||||
static double f=-1.0;
|
||||
|
||||
double gettime(void)
|
||||
{
|
||||
LARGE_INTEGER t;
|
||||
if(f<0.0) f=getfreq();
|
||||
if(f==0.0) return (double)GetTickCount()/1000.;
|
||||
else
|
||||
{
|
||||
QueryPerformanceCounter(&t);
|
||||
return (double)t.QuadPart/f;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
double gettime(void)
|
||||
{
|
||||
struct timeval tv;
|
||||
if(gettimeofday(&tv, NULL)<0) return 0.0;
|
||||
else return (double)tv.tv_sec+((double)tv.tv_usec/1000000.);
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright (C)2011 D. R. Commander. All Rights Reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from this
|
||||
* software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#ifndef __MINGW32__
|
||||
#include <stdio.h>
|
||||
#define snprintf(str, n, format, ...) \
|
||||
_snprintf_s(str, n, _TRUNCATE, format, __VA_ARGS__)
|
||||
#endif
|
||||
#define strcasecmp stricmp
|
||||
#define strncasecmp strnicmp
|
||||
#endif
|
||||
|
||||
#ifndef min
|
||||
#define min(a,b) ((a)<(b)?(a):(b))
|
||||
#endif
|
||||
|
||||
#ifndef max
|
||||
#define max(a,b) ((a)>(b)?(a):(b))
|
||||
#endif
|
||||
|
||||
extern double gettime(void);
|
||||
Loading…
Reference in New Issue