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 59typedef unsigned char JSAMPLE; 60#define GETJSAMPLE(value) ((int) (value)) 61 62#else /* not HAVE_UNSIGNED_CHAR */ 63 64typedef 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 84typedef 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 99typedef 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 110typedef unsigned char JOCTET; 111#define GETJOCTET(value) (value) 112 113#else /* not HAVE_UNSIGNED_CHAR */ 114 115typedef 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. */ 133#ifndef __WINE_BASETSD_H 134 135#ifdef HAVE_UNSIGNED_CHAR 136typedef unsigned char UINT8; 137#else /* not HAVE_UNSIGNED_CHAR */ 138#ifdef CHAR_IS_UNSIGNED 139typedef char UINT8; 140#else /* not CHAR_IS_UNSIGNED */ 141typedef 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 148typedef unsigned short UINT16; 149#else /* not HAVE_UNSIGNED_SHORT */ 150typedef 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 */ 156typedef short INT16; 157#endif 158 159#endif /* __WINE_BASETSD_H */ 160 161/* INT32 must hold at least signed 32-bit values. */ 162 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 */ 173typedef long JPEG_INT32; 174 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 182typedef 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 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 209/* a function called through method pointers: */ 210#define METHODDEF(type) JPEG_METHOD_LINKAGE type JPEG_CALLING_CONV 211/* a function used only in its module: */ 212#define LOCAL(type) static type JPEG_CALLING_CONV 213/* a function referenced thru EXTERNs: */ 214#define GLOBAL(type) type 215/* a reference to a GLOBAL function: */ 216#define EXTERN(type) extern type JPEG_CALLING_CONV 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 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 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 239#endif 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 250#ifndef FAR 251#define FAR 252#endif 253#endif 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 263#if 0 264#ifndef HAVE_BOOLEAN 265typedef int boolean; 266#endif 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 283typedef int wxjpeg_boolean; 284#define HAVE_WXJPEG_BOOLEAN 285 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 */ 421