/media/libjpeg/jmorecfg.h

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