home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / jpeg / jmorecfg.h < prev    next >
C/C++ Source or Header  |  2002-06-04  |  14KB  |  398 lines
  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. */
  133.  
  134. #ifdef HAVE_UNSIGNED_CHAR
  135. typedef unsigned char UINT8;
  136. #else /* not HAVE_UNSIGNED_CHAR */
  137. #ifdef CHAR_IS_UNSIGNED
  138. typedef char UINT8;
  139. #else /* not CHAR_IS_UNSIGNED */
  140. typedef short UINT8;
  141. #endif /* CHAR_IS_UNSIGNED */
  142. #endif /* HAVE_UNSIGNED_CHAR */
  143.  
  144. /* UINT16 must hold at least the values 0..65535. */
  145.  
  146. #ifdef HAVE_UNSIGNED_SHORT
  147. typedef unsigned short UINT16;
  148. #else /* not HAVE_UNSIGNED_SHORT */
  149. typedef unsigned int UINT16;
  150. #endif /* HAVE_UNSIGNED_SHORT */
  151.  
  152. /* INT16 must hold at least the values -32768..32767. */
  153.  
  154. #ifndef XMD_H            /* X11/xmd.h correctly defines INT16 */
  155. typedef short INT16;
  156. #endif
  157.  
  158. /* INT32 must hold at least signed 32-bit values. */
  159.  
  160. /*
  161.     VZ: due to the horrible mess resulting in INT32 being defined in windows.h
  162.         for some compilers but not for the other ones, I have globally replace
  163.         INT32 with JPEG_INT32 in libjpeg code to avoid the eight level ifdef
  164.         which used to be here. The problem is that, of course, now we'll have
  165.         conflicts when upgrading to the next libjpeg release -- however
  166.         considering their frequency (1 in the last 5 years) it seems that
  167.         it is not too high a price to pay for the clean compilation with all
  168.         versions of mingw32 and cygwin
  169.  */
  170. typedef long JPEG_INT32;
  171.  
  172. /* Datatype used for image dimensions.  The JPEG standard only supports
  173.  * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
  174.  * "unsigned int" is sufficient on all machines.  However, if you need to
  175.  * handle larger images and you don't mind deviating from the spec, you
  176.  * can change this datatype.
  177.  */
  178.  
  179. typedef unsigned int JDIMENSION;
  180.  
  181. #define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
  182.  
  183.  
  184. /* These macros are used in all function definitions and extern declarations.
  185.  * You could modify them if you need to change function linkage conventions;
  186.  * in particular, you'll need to do that to make the library a Windows DLL.
  187.  * Another application is to make all functions global for use with debuggers
  188.  * or code profilers that require it.
  189.  */
  190.  
  191. #if defined(__VISAGECPP__)
  192. #define JPEG_CALLING_CONV _Optlink
  193. #else /* !Visual Age C++ */
  194. #define JPEG_CALLING_CONV
  195. #endif
  196.  
  197. /* We can't declare a static function as extern "C" as we need to do in C++
  198.  * programs, so suppress static in METHODDEF when using C++.
  199.  */
  200. #if defined(__cplusplus)
  201. #define JPEG_METHOD_LINKAGE
  202. #else /* !__cplusplus */
  203. #define JPEG_METHOD_LINKAGE static
  204. #endif
  205.  
  206. /* a function called through method pointers: */
  207. #define METHODDEF(type)        JPEG_METHOD_LINKAGE type JPEG_CALLING_CONV
  208. /* a function used only in its module: */
  209. #define LOCAL(type)        static type JPEG_CALLING_CONV
  210. /* a function referenced thru EXTERNs: */
  211. #define GLOBAL(type)        type
  212. /* a reference to a GLOBAL function: */
  213. #define EXTERN(type)        extern type JPEG_CALLING_CONV
  214.  
  215. /* This macro is used to declare a "method", that is, a function pointer.
  216.  * We want to supply prototype parameters if the compiler can cope.
  217.  * Note that the arglist parameter must be parenthesized!
  218.  * Again, you can customize this if you need special linkage keywords.
  219.  */
  220.  
  221. #if defined(__VISAGECPP__) /* need this for /common/imagjpeg.obj but not loclly */
  222. #ifdef HAVE_PROTOTYPES
  223. #define JMETHOD(type,methodname,arglist)  type (_Optlink *methodname) arglist
  224. #else
  225. #define JMETHOD(type,methodname,arglist)  type (_Optlink *methodname) ()
  226. #endif
  227.  
  228. #else
  229.  
  230. #ifdef HAVE_PROTOTYPES
  231. #define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
  232. #else
  233. #define JMETHOD(type,methodname,arglist)  type (*methodname) ()
  234. #endif
  235.  
  236. #endif
  237.  
  238. /* Here is the pseudo-keyword for declaring pointers that must be "far"
  239.  * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
  240.  * by just saying "FAR *" where such a pointer is needed.  In a few places
  241.  * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
  242.  */
  243.  
  244. #ifdef NEED_FAR_POINTERS
  245. #define FAR  far
  246. #else
  247. #ifndef FAR
  248. #define FAR
  249. #endif
  250. #endif
  251.  
  252.  
  253. /*
  254.  * On a few systems, type boolean and/or its values FALSE, TRUE may appear
  255.  * in standard header files.  Or you may have conflicts with application-
  256.  * specific header files that you want to include together with these files.
  257.  * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
  258.  */
  259.  
  260. #ifndef HAVE_BOOLEAN
  261. typedef int boolean;
  262. #endif
  263. #ifndef FALSE            /* in case these macros already exist */
  264. #define FALSE    0        /* values of boolean */
  265. #endif
  266. #ifndef TRUE
  267. #define TRUE    1
  268. #endif
  269.  
  270.  
  271. /*
  272.  * The remaining options affect code selection within the JPEG library,
  273.  * but they don't need to be visible to most applications using the library.
  274.  * To minimize application namespace pollution, the symbols won't be
  275.  * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
  276.  */
  277.  
  278. #ifdef JPEG_INTERNALS
  279. #define JPEG_INTERNAL_OPTIONS
  280. #endif
  281.  
  282. #ifdef JPEG_INTERNAL_OPTIONS
  283.  
  284.  
  285. /*
  286.  * These defines indicate whether to include various optional functions.
  287.  * Undefining some of these symbols will produce a smaller but less capable
  288.  * library.  Note that you can leave certain source files out of the
  289.  * compilation/linking process if you've #undef'd the corresponding symbols.
  290.  * (You may HAVE to do that if your compiler doesn't like null source files.)
  291.  */
  292.  
  293. /* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
  294.  
  295. /* Capability options common to encoder and decoder: */
  296.  
  297. #define DCT_ISLOW_SUPPORTED    /* slow but accurate integer algorithm */
  298. #define DCT_IFAST_SUPPORTED    /* faster, less accurate integer method */
  299. #define DCT_FLOAT_SUPPORTED    /* floating-point: accurate, fast on fast HW */
  300.  
  301. /* Encoder capability options: */
  302.  
  303. #undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
  304. #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
  305. #define C_PROGRESSIVE_SUPPORTED        /* Progressive JPEG? (Requires MULTISCAN)*/
  306. #define ENTROPY_OPT_SUPPORTED        /* Optimization of entropy coding parms? */
  307. /* Note: if you selected 12-bit data precision, it is dangerous to turn off
  308.  * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
  309.  * precision, so jchuff.c normally uses entropy optimization to compute
  310.  * usable tables for higher precision.  If you don't want to do optimization,
  311.  * you'll have to supply different default Huffman tables.
  312.  * The exact same statements apply for progressive JPEG: the default tables
  313.  * don't work for progressive mode.  (This may get fixed, however.)
  314.  */
  315. #define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
  316.  
  317. /* Decoder capability options: */
  318.  
  319. #undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
  320. #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
  321. #define D_PROGRESSIVE_SUPPORTED        /* Progressive JPEG? (Requires MULTISCAN)*/
  322. #define SAVE_MARKERS_SUPPORTED        /* jpeg_save_markers() needed? */
  323. #define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
  324. #define IDCT_SCALING_SUPPORTED        /* Output rescaling via IDCT? */
  325. #undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
  326. #define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
  327. #define QUANT_1PASS_SUPPORTED        /* 1-pass color quantization? */
  328. #define QUANT_2PASS_SUPPORTED        /* 2-pass color quantization? */
  329.  
  330. /* more capability options later, no doubt */
  331.  
  332.  
  333. /*
  334.  * Ordering of RGB data in scanlines passed to or from the application.
  335.  * If your application wants to deal with data in the order B,G,R, just
  336.  * change these macros.  You can also deal with formats such as R,G,B,X
  337.  * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
  338.  * the offsets will also change the order in which colormap data is organized.
  339.  * RESTRICTIONS:
  340.  * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
  341.  * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
  342.  *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
  343.  * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
  344.  *    is not 3 (they don't understand about dummy color components!).  So you
  345.  *    can't use color quantization if you change that value.
  346.  */
  347.  
  348. #define RGB_RED        0    /* Offset of Red in an RGB scanline element */
  349. #define RGB_GREEN    1    /* Offset of Green */
  350. #define RGB_BLUE    2    /* Offset of Blue */
  351. #define RGB_PIXELSIZE    3    /* JSAMPLEs per RGB scanline element */
  352.  
  353.  
  354. /* Definitions for speed-related optimizations. */
  355.  
  356.  
  357. /* If your compiler supports inline functions, define INLINE
  358.  * as the inline keyword; otherwise define it as empty.
  359.  */
  360.  
  361. #ifndef INLINE
  362. #ifdef __GNUC__            /* for instance, GNU C knows about inline */
  363. #define INLINE __inline__
  364. #endif
  365. #ifndef INLINE
  366. #define INLINE            /* default is to define it as empty */
  367. #endif
  368. #endif
  369.  
  370.  
  371. /* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
  372.  * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
  373.  * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
  374.  */
  375.  
  376. #ifndef MULTIPLIER
  377. #define MULTIPLIER  int        /* type for fastest integer multiply */
  378. #endif
  379.  
  380.  
  381. /* FAST_FLOAT should be either float or double, whichever is done faster
  382.  * by your compiler.  (Note that this type is only used in the floating point
  383.  * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
  384.  * Typically, float is faster in ANSI C compilers, while double is faster in
  385.  * pre-ANSI compilers (because they insist on converting to double anyway).
  386.  * The code below therefore chooses float if we have ANSI-style prototypes.
  387.  */
  388.  
  389. #ifndef FAST_FLOAT
  390. #ifdef HAVE_PROTOTYPES
  391. #define FAST_FLOAT  float
  392. #else
  393. #define FAST_FLOAT  double
  394. #endif
  395. #endif
  396.  
  397. #endif /* JPEG_INTERNAL_OPTIONS */
  398.