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 #if !defined(XMD_H) && !defined(VXWORKS)			/* X11/xmd.h correctly defines INT32 */

   161 typedef long INT32;

   162 #endif

   163 

   164 /* Datatype used for image dimensions.  The JPEG standard only supports

   165  * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore

   166  * "unsigned int" is sufficient on all machines.  However, if you need to

   167  * handle larger images and you don't mind deviating from the spec, you

   168  * can change this datatype.

   169  */

   170 

   171 typedef unsigned int JDIMENSION;

   172 

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

   174 

   175 

   176 /* These macros are used in all function definitions and extern declarations.

   177  * You could modify them if you need to change function linkage conventions;

   178  * in particular, you'll need to do that to make the library a Windows DLL.

   179  * Another application is to make all functions global for use with debuggers

   180  * or code profilers that require it.

   181  */

   182 

   183 /* a function called through method pointers: */

   184 #define METHODDEF(type)		static type

   185 /* a function used only in its module: */

   186 #if defined(VXWORKS) && defined(LOCAL)

   187 # undef LOCAL

   188 #endif

   189 #define LOCAL(type)		static type

   190 /* a function referenced thru EXTERNs: */

   191 #define GLOBAL(type)		type

   192 /* a reference to a GLOBAL function: */

   193 #define EXTERN(type)		extern type

   194 

   195 

   196 /* This macro is used to declare a "method", that is, a function pointer.

   197  * We want to supply prototype parameters if the compiler can cope.

   198  * Note that the arglist parameter must be parenthesized!

   199  * Again, you can customize this if you need special linkage keywords.

   200  */

   201 

   202 #ifdef HAVE_PROTOTYPES

   203 #define JMETHOD(type,methodname,arglist)  type (*methodname) arglist

   204 #else

   205 #define JMETHOD(type,methodname,arglist)  type (*methodname) ()

   206 #endif

   207 

   208 

   209 /* Here is the pseudo-keyword for declaring pointers that must be "far"

   210  * on 80x86 machines.  Most of the specialized coding for 80x86 is handled

   211  * by just saying "FAR *" where such a pointer is needed.  In a few places

   212  * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.

   213  */

   214 

   215 #ifdef NEED_FAR_POINTERS

   216 #define FAR  far

   217 #else

   218 #define FAR

   219 #endif

   220 

   221 

   222 /*

   223  * On a few systems, type boolean and/or its values FALSE, TRUE may appear

   224  * in standard header files.  Or you may have conflicts with application-

   225  * specific header files that you want to include together with these files.

   226  * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.

   227  */

   228 

   229 #ifndef HAVE_BOOLEAN

   230 typedef int boolean;

   231 #endif

   232 #ifndef FALSE			/* in case these macros already exist */

   233 #define FALSE	0		/* values of boolean */

   234 #endif

   235 #ifndef TRUE

   236 #define TRUE	1

   237 #endif

   238 

   239 

   240 /*

   241  * The remaining options affect code selection within the JPEG library,

   242  * but they don't need to be visible to most applications using the library.

   243  * To minimize application namespace pollution, the symbols won't be

   244  * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.

   245  */

   246 

   247 #ifdef JPEG_INTERNALS

   248 #define JPEG_INTERNAL_OPTIONS

   249 #endif

   250 

   251 #ifdef JPEG_INTERNAL_OPTIONS

   252 

   253 

   254 /*

   255  * These defines indicate whether to include various optional functions.

   256  * Undefining some of these symbols will produce a smaller but less capable

   257  * library.  Note that you can leave certain source files out of the

   258  * compilation/linking process if you've #undef'd the corresponding symbols.

   259  * (You may HAVE to do that if your compiler doesn't like null source files.)

   260  */

   261 

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

   263 

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

   265 

   266 #define DCT_ISLOW_SUPPORTED	/* slow but accurate integer algorithm */

   267 #define DCT_IFAST_SUPPORTED	/* faster, less accurate integer method */

   268 #define DCT_FLOAT_SUPPORTED	/* floating-point: accurate, fast on fast HW */

   269 

   270 /* Encoder capability options: */

   271 

   272 #undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */

   273 #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */

   274 #define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/

   275 #define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */

   276 /* Note: if you selected 12-bit data precision, it is dangerous to turn off

   277  * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit

   278  * precision, so jchuff.c normally uses entropy optimization to compute

   279  * usable tables for higher precision.  If you don't want to do optimization,

   280  * you'll have to supply different default Huffman tables.

   281  * The exact same statements apply for progressive JPEG: the default tables

   282  * don't work for progressive mode.  (This may get fixed, however.)

   283  */

   284 #define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */

   285 

   286 /* Decoder capability options: */

   287 

   288 #undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */

   289 #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */

   290 #define D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/

   291 #define SAVE_MARKERS_SUPPORTED	    /* jpeg_save_markers() needed? */

   292 #define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */

   293 #define IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? */

   294 #undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */

   295 #define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */

   296 #define QUANT_1PASS_SUPPORTED	    /* 1-pass color quantization? */

   297 #define QUANT_2PASS_SUPPORTED	    /* 2-pass color quantization? */

   298 

   299 /* more capability options later, no doubt */

   300 

   301 

   302 /*

   303  * Ordering of RGB data in scanlines passed to or from the application.

   304  * If your application wants to deal with data in the order B,G,R, just

   305  * change these macros.  You can also deal with formats such as R,G,B,X

   306  * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing

   307  * the offsets will also change the order in which colormap data is organized.

   308  * RESTRICTIONS:

   309  * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.

   310  * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not

   311  *    useful if you are using JPEG color spaces other than YCbCr or grayscale.

   312  * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE

   313  *    is not 3 (they don't understand about dummy color components!).  So you

   314  *    can't use color quantization if you change that value.

   315  */

   316 

   317 #define RGB_RED		0	/* Offset of Red in an RGB scanline element */

   318 #define RGB_GREEN	1	/* Offset of Green */

   319 #define RGB_BLUE	2	/* Offset of Blue */

   320 #define RGB_PIXELSIZE	3	/* JSAMPLEs per RGB scanline element */

   321 

   322 

   323 /* Definitions for speed-related optimizations. */

   324 

   325 

   326 /* If your compiler supports inline functions, define INLINE

   327  * as the inline keyword; otherwise define it as empty.

   328  */

   329 

   330 #ifndef INLINE

   331 #ifdef __GNUC__			/* for instance, GNU C knows about inline */

   332 #define INLINE __inline__

   333 #endif

   334 #ifndef INLINE

   335 #define INLINE			/* default is to define it as empty */

   336 #endif

   337 #endif

   338 

   339 

   340 /* On some machines (notably 68000 series) "int" is 32 bits, but multiplying

   341  * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER

   342  * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.

   343  */

   344 

   345 #ifndef MULTIPLIER

   346 #define MULTIPLIER  int		/* type for fastest integer multiply */

   347 #endif

   348 

   349 

   350 /* FAST_FLOAT should be either float or double, whichever is done faster

   351  * by your compiler.  (Note that this type is only used in the floating point

   352  * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)

   353  * Typically, float is faster in ANSI C compilers, while double is faster in

   354  * pre-ANSI compilers (because they insist on converting to double anyway).

   355  * The code below therefore chooses float if we have ANSI-style prototypes.

   356  */

   357 

   358 #ifndef FAST_FLOAT

   359 #ifdef HAVE_PROTOTYPES

   360 #define FAST_FLOAT  float

   361 #else

   362 #define FAST_FLOAT  double

   363 #endif

   364 #endif

   365 

   366 #endif /* JPEG_INTERNAL_OPTIONS */