[wxWidgets.git] / src / jpeg / jmorecfg.h

/*
 * jmorecfg.h
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file contains additional configuration options that customize the
 * JPEG software for special applications or support machine-dependent
 * optimizations.  Most users will not need to touch this file.
 */


/*
 * Define BITS_IN_JSAMPLE as either
 *   8   for 8-bit sample values (the usual setting)
 *   12  for 12-bit sample values
 * Only 8 and 12 are legal data precisions for lossy JPEG according to the
 * JPEG standard, and the IJG code does not support anything else!
 * We do not support run-time selection of data precision, sorry.
 */

#define BITS_IN_JSAMPLE  8	/* use 8 or 12 */


/*
 * Maximum number of components (color channels) allowed in JPEG image.
 * To meet the letter of the JPEG spec, set this to 255.  However, darn
 * few applications need more than 4 channels (maybe 5 for CMYK + alpha
 * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
 * really short on memory.  (Each allowed component costs a hundred or so
 * bytes of storage, whether actually used in an image or not.)
 */

#define MAX_COMPONENTS  10	/* maximum number of image components */


/*
 * Basic data types.
 * You may need to change these if you have a machine with unusual data
 * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
 * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
 * but it had better be at least 16.
 */

/* Representation of a single sample (pixel element value).
 * We frequently allocate large arrays of these, so it's important to keep
 * them small.  But if you have memory to burn and access to char or short
 * arrays is very slow on your hardware, you might want to change these.
 */

#if BITS_IN_JSAMPLE == 8
/* JSAMPLE should be the smallest type that will hold the values 0..255.
 * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
 */

#ifdef HAVE_UNSIGNED_CHAR

typedef unsigned char JSAMPLE;
#define GETJSAMPLE(value)  ((int) (value))

#else /* not HAVE_UNSIGNED_CHAR */

typedef char JSAMPLE;
#ifdef CHAR_IS_UNSIGNED
#define GETJSAMPLE(value)  ((int) (value))
#else
#define GETJSAMPLE(value)  ((int) (value) & 0xFF)
#endif /* CHAR_IS_UNSIGNED */

#endif /* HAVE_UNSIGNED_CHAR */

#define MAXJSAMPLE	255
#define CENTERJSAMPLE	128

#endif /* BITS_IN_JSAMPLE == 8 */


#if BITS_IN_JSAMPLE == 12
/* JSAMPLE should be the smallest type that will hold the values 0..4095.
 * On nearly all machines "short" will do nicely.
 */

typedef short JSAMPLE;
#define GETJSAMPLE(value)  ((int) (value))

#define MAXJSAMPLE	4095
#define CENTERJSAMPLE	2048

#endif /* BITS_IN_JSAMPLE == 12 */


/* Representation of a DCT frequency coefficient.
 * This should be a signed value of at least 16 bits; "short" is usually OK.
 * Again, we allocate large arrays of these, but you can change to int
 * if you have memory to burn and "short" is really slow.
 */

typedef short JCOEF;


/* Compressed datastreams are represented as arrays of JOCTET.
 * These must be EXACTLY 8 bits wide, at least once they are written to
 * external storage.  Note that when using the stdio data source/destination
 * managers, this is also the data type passed to fread/fwrite.
 */

#ifdef HAVE_UNSIGNED_CHAR

typedef unsigned char JOCTET;
#define GETJOCTET(value)  (value)

#else /* not HAVE_UNSIGNED_CHAR */

typedef char JOCTET;
#ifdef CHAR_IS_UNSIGNED
#define GETJOCTET(value)  (value)
#else
#define GETJOCTET(value)  ((value) & 0xFF)
#endif /* CHAR_IS_UNSIGNED */

#endif /* HAVE_UNSIGNED_CHAR */


/* These typedefs are used for various table entries and so forth.
 * They must be at least as wide as specified; but making them too big
 * won't cost a huge amount of memory, so we don't provide special
 * extraction code like we did for JSAMPLE.  (In other words, these
 * typedefs live at a different point on the speed/space tradeoff curve.)
 */

/* UINT8 must hold at least the values 0..255. */
#ifndef __WINE_BASETSD_H

#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char UINT8;
#else /* not HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char UINT8;
#else /* not CHAR_IS_UNSIGNED */
typedef short UINT8;
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */

/* UINT16 must hold at least the values 0..65535. */

#ifdef HAVE_UNSIGNED_SHORT
typedef unsigned short UINT16;
#else /* not HAVE_UNSIGNED_SHORT */
typedef unsigned int UINT16;
#endif /* HAVE_UNSIGNED_SHORT */

/* INT16 must hold at least the values -32768..32767. */

#ifndef XMD_H			/* X11/xmd.h correctly defines INT16 */
typedef short INT16;
#endif

#endif /* __WINE_BASETSD_H */

/* INT32 must hold at least signed 32-bit values. */

/*
    VZ: due to the horrible mess resulting in INT32 being defined in windows.h
        for some compilers but not for the other ones, I have globally replace
        INT32 with JPEG_INT32 in libjpeg code to avoid the eight level ifdef
        which used to be here. The problem is that, of course, now we'll have
        conflicts when upgrading to the next libjpeg release -- however
        considering their frequency (1 in the last 5 years) it seems that
        it is not too high a price to pay for the clean compilation with all
        versions of mingw32 and cygwin
 */
typedef long JPEG_INT32;

/* Datatype used for image dimensions.  The JPEG standard only supports
 * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
 * "unsigned int" is sufficient on all machines.  However, if you need to
 * handle larger images and you don't mind deviating from the spec, you
 * can change this datatype.
 */

typedef unsigned int JDIMENSION;

#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */


/* These macros are used in all function definitions and extern declarations.
 * You could modify them if you need to change function linkage conventions;
 * in particular, you'll need to do that to make the library a Windows DLL.
 * Another application is to make all functions global for use with debuggers
 * or code profilers that require it.
 */

#if defined(__VISAGECPP__)
#define JPEG_CALLING_CONV _Optlink
#else /* !Visual Age C++ */
#define JPEG_CALLING_CONV
#endif

/* We can't declare a static function as extern "C" as we need to do in C++
 * programs, so suppress static in METHODDEF when using C++.
 */
#if defined(__cplusplus)
#define JPEG_METHOD_LINKAGE
#else /* !__cplusplus */
#define JPEG_METHOD_LINKAGE static
#endif

/* a function called through method pointers: */
#define METHODDEF(type)		JPEG_METHOD_LINKAGE type JPEG_CALLING_CONV
/* a function used only in its module: */
#define LOCAL(type)		static type JPEG_CALLING_CONV
/* a function referenced thru EXTERNs: */
#define GLOBAL(type)		type
/* a reference to a GLOBAL function: */
#define EXTERN(type)		extern type JPEG_CALLING_CONV

/* This macro is used to declare a "method", that is, a function pointer.
 * We want to supply prototype parameters if the compiler can cope.
 * Note that the arglist parameter must be parenthesized!
 * Again, you can customize this if you need special linkage keywords.
 */

#if defined(__VISAGECPP__) /* need this for /common/imagjpeg.obj but not loclly */
#ifdef HAVE_PROTOTYPES
#define JMETHOD(type,methodname,arglist)  type (_Optlink *methodname) arglist
#else
#define JMETHOD(type,methodname,arglist)  type (_Optlink *methodname) ()
#endif

#else

#ifdef HAVE_PROTOTYPES
#define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
#else
#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
#endif

#endif

/* Here is the pseudo-keyword for declaring pointers that must be "far"
 * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
 * by just saying "FAR *" where such a pointer is needed.  In a few places
 * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
 */

#ifdef NEED_FAR_POINTERS
#define FAR  far
#else
#ifndef FAR
#define FAR
#endif
#endif


/*
 * On a few systems, type boolean and/or its values FALSE, TRUE may appear
 * in standard header files.  Or you may have conflicts with application-
 * specific header files that you want to include together with these files.
 * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
 */

#if 0
#ifndef HAVE_BOOLEAN
typedef int boolean;
#endif
#endif

/*
 * Notes about boolean above:
 *
 * The main conflict we see is with the Windows headers of some compilers that
 * have a different definition of boolean. Therefore boolean has been replaced
 * with wxjpeg_boolean throughout the jpeg sources. The alternative would have
 * been to make the definition here the same as the Windows definition. It's
 * not enough to just define HAVE_BOOLEAN when using the jpeg library, the
 * definition of boolean must match when the jpeg library is compiled too.
 *
 * System jepg libs won't have this type, of course, so to use test
 * HAVE_WXJPEG_BOOLEAN and fall back to boolean when not defined.
 */

typedef int wxjpeg_boolean;
#define HAVE_WXJPEG_BOOLEAN

#ifndef FALSE			/* in case these macros already exist */
#define FALSE	0		/* values of boolean */
#endif
#ifndef TRUE
#define TRUE	1
#endif


/*
 * The remaining options affect code selection within the JPEG library,
 * but they don't need to be visible to most applications using the library.
 * To minimize application namespace pollution, the symbols won't be
 * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
 */

#ifdef JPEG_INTERNALS
#define JPEG_INTERNAL_OPTIONS
#endif

#ifdef JPEG_INTERNAL_OPTIONS


/*
 * These defines indicate whether to include various optional functions.
 * Undefining some of these symbols will produce a smaller but less capable
 * library.  Note that you can leave certain source files out of the
 * compilation/linking process if you've #undef'd the corresponding symbols.
 * (You may HAVE to do that if your compiler doesn't like null source files.)
 */

/* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */

/* Capability options common to encoder and decoder: */

#define DCT_ISLOW_SUPPORTED	/* slow but accurate integer algorithm */
#define DCT_IFAST_SUPPORTED	/* faster, less accurate integer method */
#define DCT_FLOAT_SUPPORTED	/* floating-point: accurate, fast on fast HW */

/* Encoder capability options: */

#undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
#define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */
/* Note: if you selected 12-bit data precision, it is dangerous to turn off
 * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
 * precision, so jchuff.c normally uses entropy optimization to compute
 * usable tables for higher precision.  If you don't want to do optimization,
 * you'll have to supply different default Huffman tables.
 * The exact same statements apply for progressive JPEG: the default tables
 * don't work for progressive mode.  (This may get fixed, however.)
 */
#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */

/* Decoder capability options: */

#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
#define D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
#define SAVE_MARKERS_SUPPORTED	    /* jpeg_save_markers() needed? */
#define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
#define IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? */
#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
#define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
#define QUANT_1PASS_SUPPORTED	    /* 1-pass color quantization? */
#define QUANT_2PASS_SUPPORTED	    /* 2-pass color quantization? */

/* more capability options later, no doubt */


/*
 * Ordering of RGB data in scanlines passed to or from the application.
 * If your application wants to deal with data in the order B,G,R, just
 * change these macros.  You can also deal with formats such as R,G,B,X
 * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
 * the offsets will also change the order in which colormap data is organized.
 * RESTRICTIONS:
 * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
 * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
 *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
 * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
 *    is not 3 (they don't understand about dummy color components!).  So you
 *    can't use color quantization if you change that value.
 */

#define RGB_RED		0	/* Offset of Red in an RGB scanline element */
#define RGB_GREEN	1	/* Offset of Green */
#define RGB_BLUE	2	/* Offset of Blue */
#define RGB_PIXELSIZE	3	/* JSAMPLEs per RGB scanline element */


/* Definitions for speed-related optimizations. */


/* If your compiler supports inline functions, define INLINE
 * as the inline keyword; otherwise define it as empty.
 */

#ifndef INLINE
#ifdef __GNUC__			/* for instance, GNU C knows about inline */
#define INLINE __inline__
#endif
#ifndef INLINE
#define INLINE			/* default is to define it as empty */
#endif
#endif


/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
 * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
 * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
 */

#ifndef MULTIPLIER
#define MULTIPLIER  int		/* type for fastest integer multiply */
#endif


/* FAST_FLOAT should be either float or double, whichever is done faster
 * by your compiler.  (Note that this type is only used in the floating point
 * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
 * Typically, float is faster in ANSI C compilers, while double is faster in
 * pre-ANSI compilers (because they insist on converting to double anyway).
 * The code below therefore chooses float if we have ANSI-style prototypes.
 */

#ifndef FAST_FLOAT
#ifdef HAVE_PROTOTYPES
#define FAST_FLOAT  float
#else
#define FAST_FLOAT  double
#endif
#endif

#endif /* JPEG_INTERNAL_OPTIONS */
Commit	Line	Data
e1929140 RR	1	/*
	2	* jmorecfg.h
	3	*
	4	* Copyright (C) 1991-1997, Thomas G. Lane.
	5	* This file is part of the Independent JPEG Group's software.
	6	* For conditions of distribution and use, see the accompanying README file.
	7	*
	8	* This file contains additional configuration options that customize the
	9	* JPEG software for special applications or support machine-dependent
	10	* optimizations. Most users will not need to touch this file.
	11	*/
	12
	13
	14	/*
	15	* Define BITS_IN_JSAMPLE as either
	16	* 8 for 8-bit sample values (the usual setting)
	17	* 12 for 12-bit sample values
	18	* Only 8 and 12 are legal data precisions for lossy JPEG according to the
	19	* JPEG standard, and the IJG code does not support anything else!
	20	* We do not support run-time selection of data precision, sorry.
	21	*/
	22
	23	#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */
	24
	25
	26	/*
	27	* Maximum number of components (color channels) allowed in JPEG image.
	28	* To meet the letter of the JPEG spec, set this to 255. However, darn
	29	* few applications need more than 4 channels (maybe 5 for CMYK + alpha
	30	* mask). We recommend 10 as a reasonable compromise; use 4 if you are
	31	* really short on memory. (Each allowed component costs a hundred or so
	32	* bytes of storage, whether actually used in an image or not.)
	33	*/
	34
	35	#define MAX_COMPONENTS 10 /* maximum number of image components */
	36
	37
	38	/*
	39	* Basic data types.
	40	* You may need to change these if you have a machine with unusual data
	41	* type sizes; for example, "char" not 8 bits, "short" not 16 bits,
	42	* or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
	43	* but it had better be at least 16.
	44	*/
	45
	46	/* Representation of a single sample (pixel element value).
	47	* We frequently allocate large arrays of these, so it's important to keep
	48	* them small. But if you have memory to burn and access to char or short
	49	* arrays is very slow on your hardware, you might want to change these.
	50	*/
	51
	52	#if BITS_IN_JSAMPLE == 8
	53	/* JSAMPLE should be the smallest type that will hold the values 0..255.
	54	* You can use a signed char by having GETJSAMPLE mask it with 0xFF.
	55	*/
	56
	57	#ifdef HAVE_UNSIGNED_CHAR
	58
	59	typedef unsigned char JSAMPLE;
	60	#define GETJSAMPLE(value) ((int) (value))
	61
	62	#else /* not HAVE_UNSIGNED_CHAR */
	63
	64	typedef char JSAMPLE;
65	#ifdef CHAR_IS_UNSIGNED
66	#define GETJSAMPLE(value) ((int) (value))
67	#else
68	#define GETJSAMPLE(value) ((int) (value) & 0xFF)
69	#endif /* CHAR_IS_UNSIGNED */
70
71	#endif /* HAVE_UNSIGNED_CHAR */
72
73	#define MAXJSAMPLE 255
74	#define CENTERJSAMPLE 128
75
76	#endif /* BITS_IN_JSAMPLE == 8 */
77
78
79	#if BITS_IN_JSAMPLE == 12
80	/* JSAMPLE should be the smallest type that will hold the values 0..4095.
81	* On nearly all machines "short" will do nicely.
82	*/
83
84	typedef short JSAMPLE;
85	#define GETJSAMPLE(value) ((int) (value))
86
87	#define MAXJSAMPLE 4095
88	#define CENTERJSAMPLE 2048
89
90	#endif /* BITS_IN_JSAMPLE == 12 */
91
92
93	/* Representation of a DCT frequency coefficient.
94	* This should be a signed value of at least 16 bits; "short" is usually OK.
95	* Again, we allocate large arrays of these, but you can change to int
96	* if you have memory to burn and "short" is really slow.
97	*/
98
99	typedef short JCOEF;
100
101
102	/* Compressed datastreams are represented as arrays of JOCTET.
103	* These must be EXACTLY 8 bits wide, at least once they are written to
104	* external storage. Note that when using the stdio data source/destination
105	* managers, this is also the data type passed to fread/fwrite.
106	*/
107
108	#ifdef HAVE_UNSIGNED_CHAR
109
110	typedef unsigned char JOCTET;
111	#define GETJOCTET(value) (value)
112
113	#else /* not HAVE_UNSIGNED_CHAR */
114
115	typedef char JOCTET;
116	#ifdef CHAR_IS_UNSIGNED
117	#define GETJOCTET(value) (value)
118	#else
119	#define GETJOCTET(value) ((value) & 0xFF)
120	#endif /* CHAR_IS_UNSIGNED */
121
122	#endif /* HAVE_UNSIGNED_CHAR */
123
124
125	/* These typedefs are used for various table entries and so forth.
126	* They must be at least as wide as specified; but making them too big
127	* won't cost a huge amount of memory, so we don't provide special
128	* extraction code like we did for JSAMPLE. (In other words, these
129	* typedefs live at a different point on the speed/space tradeoff curve.)
130	*/
131
132	/* UINT8 must hold at least the values 0..255. */
5283098e	133	#ifndef __WINE_BASETSD_H
e1929140 RR	134
	135	#ifdef HAVE_UNSIGNED_CHAR
	136	typedef unsigned char UINT8;
	137	#else /* not HAVE_UNSIGNED_CHAR */
	138	#ifdef CHAR_IS_UNSIGNED
	139	typedef char UINT8;
	140	#else /* not CHAR_IS_UNSIGNED */
	141	typedef short UINT8;
	142	#endif /* CHAR_IS_UNSIGNED */
	143	#endif /* HAVE_UNSIGNED_CHAR */
	144
	145	/* UINT16 must hold at least the values 0..65535. */
	146
	147	#ifdef HAVE_UNSIGNED_SHORT
	148	typedef unsigned short UINT16;
	149	#else /* not HAVE_UNSIGNED_SHORT */
	150	typedef unsigned int UINT16;
	151	#endif /* HAVE_UNSIGNED_SHORT */
	152
	153	/* INT16 must hold at least the values -32768..32767. */
	154
	155	#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
	156	typedef short INT16;
	157	#endif
	158
5283098e JS	159	#endif /* __WINE_BASETSD_H */
5283098e JS	160
e1929140 RR	161	/* INT32 must hold at least signed 32-bit values. */
e1929140 RR	162
39c2d6bd VZ	163	/*
	164	VZ: due to the horrible mess resulting in INT32 being defined in windows.h
	165	for some compilers but not for the other ones, I have globally replace
	166	INT32 with JPEG_INT32 in libjpeg code to avoid the eight level ifdef
	167	which used to be here. The problem is that, of course, now we'll have
	168	conflicts when upgrading to the next libjpeg release -- however
	169	considering their frequency (1 in the last 5 years) it seems that
	170	it is not too high a price to pay for the clean compilation with all
	171	versions of mingw32 and cygwin
	172	*/
	173	typedef long JPEG_INT32;
ae128b35	174
e1929140 RR	175	/* Datatype used for image dimensions. The JPEG standard only supports
	176	* images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
	177	* "unsigned int" is sufficient on all machines. However, if you need to
	178	* handle larger images and you don't mind deviating from the spec, you
	179	* can change this datatype.
	180	*/
	181
	182	typedef unsigned int JDIMENSION;
	183
	184	#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
	185
	186
	187	/* These macros are used in all function definitions and extern declarations.
	188	* You could modify them if you need to change function linkage conventions;
	189	* in particular, you'll need to do that to make the library a Windows DLL.
	190	* Another application is to make all functions global for use with debuggers
	191	* or code profilers that require it.
	192	*/
	193
d7c42914 VZ	194	#if defined(__VISAGECPP__)
	195	#define JPEG_CALLING_CONV _Optlink
	196	#else /* !Visual Age C++ */
	197	#define JPEG_CALLING_CONV
	198	#endif
	199
	200	/* We can't declare a static function as extern "C" as we need to do in C++
	201	* programs, so suppress static in METHODDEF when using C++.
	202	*/
	203	#if defined(__cplusplus)
	204	#define JPEG_METHOD_LINKAGE
	205	#else /* !__cplusplus */
	206	#define JPEG_METHOD_LINKAGE static
	207	#endif
	208
e1929140	209	/* a function called through method pointers: */
d7c42914	210	#define METHODDEF(type) JPEG_METHOD_LINKAGE type JPEG_CALLING_CONV
e1929140	211	/* a function used only in its module: */
d7c42914	212	#define LOCAL(type) static type JPEG_CALLING_CONV
e1929140 RR	213	/* a function referenced thru EXTERNs: */
	214	#define GLOBAL(type) type
	215	/* a reference to a GLOBAL function: */
d7c42914	216	#define EXTERN(type) extern type JPEG_CALLING_CONV
e1929140 RR	217
	218	/* This macro is used to declare a "method", that is, a function pointer.
	219	* We want to supply prototype parameters if the compiler can cope.
	220	* Note that the arglist parameter must be parenthesized!
	221	* Again, you can customize this if you need special linkage keywords.
	222	*/
	223
413098d0 DW	224	#if defined(__VISAGECPP__) /* need this for /common/imagjpeg.obj but not loclly */
	225	#ifdef HAVE_PROTOTYPES
	226	#define JMETHOD(type,methodname,arglist) type (_Optlink *methodname) arglist
	227	#else
	228	#define JMETHOD(type,methodname,arglist) type (_Optlink *methodname) ()
	229	#endif
	230
	231	#else
	232
e1929140 RR	233	#ifdef HAVE_PROTOTYPES
	234	#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
	235	#else
	236	#define JMETHOD(type,methodname,arglist) type (*methodname) ()
	237	#endif
	238
413098d0	239	#endif
e1929140 RR	240
	241	/* Here is the pseudo-keyword for declaring pointers that must be "far"
	242	* on 80x86 machines. Most of the specialized coding for 80x86 is handled
	243	* by just saying "FAR *" where such a pointer is needed. In a few places
	244	* explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
	245	*/
	246
	247	#ifdef NEED_FAR_POINTERS
	248	#define FAR far
	249	#else
9c824f29	250	#ifndef FAR
e1929140 RR	251	#define FAR
e1929140 RR	252	#endif
9c824f29	253	#endif
e1929140 RR	254
	255
	256	/*
	257	* On a few systems, type boolean and/or its values FALSE, TRUE may appear
	258	* in standard header files. Or you may have conflicts with application-
	259	* specific header files that you want to include together with these files.
	260	* Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
	261	*/
	262
e604ac79	263	#if 0
e1929140 RR	264	#ifndef HAVE_BOOLEAN
	265	typedef int boolean;
	266	#endif
e604ac79 MW	267	#endif
	268
	269	/*
	270	* Notes about boolean above:
	271	*
	272	* The main conflict we see is with the Windows headers of some compilers that
	273	* have a different definition of boolean. Therefore boolean has been replaced
	274	* with wxjpeg_boolean throughout the jpeg sources. The alternative would have
	275	* been to make the definition here the same as the Windows definition. It's
	276	* not enough to just define HAVE_BOOLEAN when using the jpeg library, the
	277	* definition of boolean must match when the jpeg library is compiled too.
	278	*
	279	* System jepg libs won't have this type, of course, so to use test
	280	* HAVE_WXJPEG_BOOLEAN and fall back to boolean when not defined.
	281	*/
	282
	283	typedef int wxjpeg_boolean;
	284	#define HAVE_WXJPEG_BOOLEAN
	285
e1929140 RR	286	#ifndef FALSE /* in case these macros already exist */
	287	#define FALSE 0 /* values of boolean */
	288	#endif
	289	#ifndef TRUE
	290	#define TRUE 1
	291	#endif
	292
	293
	294	/*
	295	* The remaining options affect code selection within the JPEG library,
	296	* but they don't need to be visible to most applications using the library.
	297	* To minimize application namespace pollution, the symbols won't be
	298	* defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
	299	*/
	300
	301	#ifdef JPEG_INTERNALS
	302	#define JPEG_INTERNAL_OPTIONS
	303	#endif
	304
	305	#ifdef JPEG_INTERNAL_OPTIONS
	306
	307
	308	/*
	309	* These defines indicate whether to include various optional functions.
	310	* Undefining some of these symbols will produce a smaller but less capable
	311	* library. Note that you can leave certain source files out of the
	312	* compilation/linking process if you've #undef'd the corresponding symbols.
	313	* (You may HAVE to do that if your compiler doesn't like null source files.)
	314	*/
	315
	316	/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */
	317
	318	/* Capability options common to encoder and decoder: */
	319
	320	#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */
	321	#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */
	322	#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */
	323
	324	/* Encoder capability options: */
	325
	326	#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
	327	#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
	328	#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
	329	#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
	330	/* Note: if you selected 12-bit data precision, it is dangerous to turn off
	331	* ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
	332	* precision, so jchuff.c normally uses entropy optimization to compute
	333	* usable tables for higher precision. If you don't want to do optimization,
	334	* you'll have to supply different default Huffman tables.
	335	* The exact same statements apply for progressive JPEG: the default tables
	336	* don't work for progressive mode. (This may get fixed, however.)
	337	*/
	338	#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
	339
	340	/* Decoder capability options: */
	341
	342	#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
	343	#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
	344	#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
	345	#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
	346	#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
	347	#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
	348	#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
	349	#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
350	#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
351	#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
352
353	/* more capability options later, no doubt */
354
355
356	/*
357	* Ordering of RGB data in scanlines passed to or from the application.
358	* If your application wants to deal with data in the order B,G,R, just
359	* change these macros. You can also deal with formats such as R,G,B,X
360	* (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing
361	* the offsets will also change the order in which colormap data is organized.
362	* RESTRICTIONS:
363	* 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
364	* 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
365	* useful if you are using JPEG color spaces other than YCbCr or grayscale.
366	* 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
367	* is not 3 (they don't understand about dummy color components!). So you
368	* can't use color quantization if you change that value.
369	*/
370
371	#define RGB_RED 0 /* Offset of Red in an RGB scanline element */
372	#define RGB_GREEN 1 /* Offset of Green */
373	#define RGB_BLUE 2 /* Offset of Blue */
374	#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
375
376
377	/* Definitions for speed-related optimizations. */
378
379
380	/* If your compiler supports inline functions, define INLINE
381	* as the inline keyword; otherwise define it as empty.
382	*/
383
384	#ifndef INLINE
385	#ifdef __GNUC__ /* for instance, GNU C knows about inline */
386	#define INLINE __inline__
387	#endif
388	#ifndef INLINE
389	#define INLINE /* default is to define it as empty */
390	#endif
391	#endif
392
393
394	/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
395	* two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
396	* as short on such a machine. MULTIPLIER must be at least 16 bits wide.
397	*/
398
399	#ifndef MULTIPLIER
400	#define MULTIPLIER int /* type for fastest integer multiply */
401	#endif
402
403
404	/* FAST_FLOAT should be either float or double, whichever is done faster
405	* by your compiler. (Note that this type is only used in the floating point
406	* DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
407	* Typically, float is faster in ANSI C compilers, while double is faster in
408	* pre-ANSI compilers (because they insist on converting to double anyway).
409	* The code below therefore chooses float if we have ANSI-style prototypes.
410	*/
411
412	#ifndef FAST_FLOAT
413	#ifdef HAVE_PROTOTYPES
414	#define FAST_FLOAT float
415	#else
416	#define FAST_FLOAT double
417	#endif
418	#endif
419
420	#endif /* JPEG_INTERNAL_OPTIONS */