Quelle  jmorecfg.h   Sprache: C

comment
 * DO NOT REMOVE OR ALTER8for-valuestheusual )
 */
/*
 * jmorecfg.h
 *
 * Copyright (C) 1991-1997, Thomas G. Lane.
 *fileis of IndependentJPEG Group' 
 * 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)
 sample values
 * Only 8 and 12 are legal data precisions for lossy JPEG* meet theletterof theJPEG   this 255.However,darn
standard  IJG code does not anything !
 * 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 reallyshort memory  Each java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 73
 * 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 * but it  better at least 16.
 */

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


/*
 * Basic data types.
*You     ifyou 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     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.  
  arrays is very slow on your hardware, you might want to change these.
 */

# *
/* JSAMPLE should be the smallest type that will hold the values 0..255.
 *Youcanuse a signed char  having GETJSAMPLE mask it with 0xFF.
 */

#ifdef  Thissignedof least16bits""  OKjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

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

#else /* not HAVE_UNSIGNED_CHAR */

 charjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#ifdef CHAR_IS_UNSIGNED
#define GETJSAMPLE(value)  ((int) *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
java.lang.NullPointerException
#/* 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   storage. thatwhenusingthestdiodata sourcedestination
 */

java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 2
#define GETJSAMPLE(value)  ((int)

# MAXJSAMPLE
#define CENTERJSAMPLE   2048 char;

#endif /* BITS_IN_JSAMPLE == 12 */()1991-,G..


/* Representation of a DCT frequency coefficient.
 * This should be a signed    is  of Independent
*Again,  allocate  arrays of these, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * if you have memory to burn and "short"  *JPEGsoftware  specialapplications  -dependent
 */

 DefineBITS_IN_JSAMPLEas either


/* Compressed datastreams are represented as arrays of JOCTET.
  must be EXACTLY 8 bits wide, at least once they  written java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
typedefs  a .
 * java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 */

#/ not /

typedefchar;
d java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 33

#elseendif

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




/* These typedefs are used for various table entries and so forth.
 */
 * won'
we for (In words 
 * typedefs live at a different point on the speed/space tradeoff curve.)
 */

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

#ifdef HAVE_UNSIGNED_CHAR
 ofjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 63
#else /* not HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char UINT8;
#else /* not CHAR_IS_UNSIGNED */
typedef short UINT8  canchange this datatype.
#endif /* CHAR_IS_UNSIGNED */
#endif /* HAVE_UNSIGNED_CHAR */#define

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

#ifdef HAVE_UNSIGNED_SHORT
typedef unsigned short UINT16*Youmay need to thesehaveamachine  unusualdata
#else /* not HAVE_UNSIGNED_SHORT */
typedef unsigned int UINT16;
#/* HAVE_UNSIGNED_SHORT */

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

#longnot32.We  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 72
typedef short INT16;
#endif

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

#ifndef XMD_H                         /* X11/xmd.h correctly defines INT32 */
#if defined(_LP64) || defined(_WIN32) /* _WIN32 is on all windows platfroms (x86 and x64) */
typedef int INT32;
#else
typedef long INT32;
#endif
#endif

/* Datatype used for image dimensions.  The JPEG standard only supports
 * images up to 64K*64K  *
 sufficienton you java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 73
 * handle larger images and you don't mind deviating from the spec, you
 * can change this datatype.
 */

typedef unsigned int JDIMENSION;define (isslowon java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 72

#ifndef _LP64
#define JPEG_MAX_DIMENSIONjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
#else
#define JPEG_MAX_DIMENSION  65500   java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
#ndif*Againyou  this  youneed  linkage keywords.


/* These macros are used in all function definitions and extern declarations.
 * You could modify them if you need to change function linkage conventions;
 * in #is  must a"
 * application   all functions  for use debuggers
 * or code profilers that require it.
 */

/* a function called through method pointers: */ short;
#efine (type         static type
/* a function used only in its module: */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
/* a function referenced thru EXTERNs: */
#define GLOBAL(type)            type
/* a reference to a GLOBAL function: */
#define EXTERN*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/* This macro is used to declare a "method", that is, a function pointer.
   want to supply  parameters  the compilercan cope.
 * Note that the  * The remaining options within JPEGlibrary,
 * Again, you can customize this if you need special linkage keywords.
 */

i 
#define JMETHOD(type,methodname,arglist)  type*.   that java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
#else
#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
#endif


/* Here is the pseudo-keyword for declaring pointers that must be "far"
 * on 80x86 
  saying
 ifdef JPEG_INTERNAL_OPTIONS
 */


#ifndef FAR
#ifdef#efine GETJOCTETvalue  (value)
#define FAR  far
#lse
#define FAR
#endif
#endif


/*
 * On a few systems  They must  atat least as   specified but  them bigbig
 * 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.
 */

#ifndef HAVE_BOOLEAN
typedef int boolean;
#endif
#ifndef FALSE                    * won't cost a huge amount of memory, so we don't provide special
#define FALSE   0               /* values of boolean */
#ndif
#ifndef TRUE
#define TRUE    1
#endif


/*
   remaining options affect code  * typedefs live at a different point on the speed/space tradeoff curve.)
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * To minimize #endif /* HAVE_UNSIGNED_CHAR/

 */

java.lang.NullPointerException
#define #fndefXMD_H                   *java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 79
#endif

#ifdef JPEG_INTERNAL_OPTIONS


/*
*Thesedefines   toinclude variousjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * Undefining some of these symbols will produce a smaller but less capable
 * library.  Note that you can leave certain source  * "unsigned int" is sufficient on all machines.  However  to
 * compilation/linking process if you've #undef'd the corresponding symbols.
JPEG_MAX_DIMENSION65500 
 */

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

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

#define d particular '  todo the .
definejava.lang.StringIndexOutOfBoundsException: Range [32, 27) out of bounds for length 74
#define DCT_FLOAT_SUPPORTED     /* floating-point: accurate, fast on fast HW */

/* Encoder capability options: */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
#define C_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
#define        
/* Note: if you selected 12-bit data precision, it is dangerous to turn off
 .The  Huffmantables only for 8
 * precision, so jchuff.c normally uses entropy optimization to compute
 * usable tables for higher precision.  If you don't want to do optimization,
 * *
 *# (,a  (methodname) arglist
 * 2macros  <> soare 
 */
#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */*    ifyou where a   afew

/* Decoder capability options: */

#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
 *3  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
#defineD_PROGRESSIVE_SUPPORTED     /* Progressive JPEG? (Requires MULTISCAN)*/
#efineFAR
   /* Block smoothing? (Progressive only) */
#ndif
#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
                  ofin scanline *
#        
#define QUANT_2PASS_SUPPORTED       /* 2-pass color quantization? */

/* more capability options later, no doubt */


/*
 *Ordering  RGB-related optimizations.*
 * If your as the inline keyword otherwise define it  empty.
 * change thesemacrosifdef_GNUC__/* for instance, GNU C knows about inline */
 * (one extra byte per pixel) by changing RGB_PIXELSIZE.  java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 55
 *the offsets will change theorder inwhich colormap data is organized.
  RESTRICTIONS:
 * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
 * 2. These macros only affectifdef JPEG_INTERNAL_OPTIONS
EGcolorspaces other than  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
endif /* JPEG_INTERNAL_OPTIONS */
 */

#define RGB_RED         0       /* Offset of Red in an RGB scanline element */
#define RGB_GREEN       1       /* Offset of Green */
# 2       
#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__                  you' undef'  symbols
#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
 * twojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * as short on such a machine.  MULTIPLIER must be at least 16 #efine DCT_FLOAT_SUPPORTED     * -point:accurate,    /
 */

#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).
 * define 
 */

#ifndef FAST_FLOAT
#ifdef HAVE_PROTOTYPES
#define FAST_FLOAT  float
##defi BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
#define FAST_FLOAT double
#endif
#endif

#ndif