windows-nt-4.0/private/wangview/xfilexr/include/jpeg.h

#ifndef _JPEG_H_INCLUDED_
#define _JPEG_H_INCLUDED_

#define STDERR stderr

#undef JDEBUG

#include <stdio.h>

#ifndef _TYPES_PUB_INCLUDED
#include "types.pub"
#endif

#ifndef _IAERROR_PUB_INCLUDED_
#include "iaerror.pub"
#endif

#ifdef __GNUC__
#include "ansiprot.h"   /* to get memset */
#endif


IP_RCSINFO(jpeg_h_RCSInfo, "$RCSfile: jpeg.h,v $; $Revision:   1.0  $")
/* $Date:   12 Jun 1996 05:47:16  $ */

/* Now include IJG include file which in turn includes everything else */

/************** Now include JINCLUDE.H ***********************/
/*
 * jinclude.h
 *
 * Copyright (C) 1991, 1992, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This is the central file that's #include'd by all the JPEG .c files.
 * Its purpose is to provide a single place to fix any problems with
 * including the wrong system include files.
 * You can edit these declarations if you use a system with nonstandard
 * system include files.
 */


/*
 * Normally the __STDC__ macro can be taken as indicating that the system
 * include files conform to the ANSI C standard.  However, if you are running
 * GCC on a machine with non-ANSI system include files, that is not the case.
 * In that case change the following, or add -DNONANSI_INCLUDES to your CFLAGS.
 */

#ifdef __STDC__
#ifndef NONANSI_INCLUDES
#define INCLUDES_ARE_ANSI   /* this is what's tested before including */
#endif
#endif

/* MPW C 3.3.1 is supposed to define __STDC__ but doesn't, so... */
#ifdef applec
#define HAVE_STDC
#ifndef NONANSI_INCLUDES
#define INCLUDES_ARE_ANSI   /* this is what's tested before including */
#endif
#endif


/*
 * In ANSI C, and indeed any rational implementation, size_t is also the
 * type returned by sizeof().  However, it seems there are some irrational
 * implementations out there, in which sizeof() returns an int even though
 * size_t is defined as long or unsigned long.  To ensure consistent results
 * we always use this SIZEOF() macro in place of using sizeof() directly.
 */

#undef SIZEOF           /* in case you included X11/xmd.h */
#define SIZEOF(object)  ((size_t) sizeof(object))

/*
 * fread() and fwrite() are always invoked through these macros.
 * On some systems you may need to twiddle the argument casts.
 * CAUTION: argument order is different from underlying functions!
 */

#define JFREAD(file,buf,sizeofbuf)  \
  ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
#define JFWRITE(file,buf,sizeofbuf)  \
  ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))

/*
 * We need the memcpy() and strcmp() functions, plus memory zeroing.
 * ANSI and System V implementations declare these in <string.h>.
 * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
 * Some systems may declare memset and memcpy in <memory.h>.
 *
 * NOTE: we assume the size parameters to these functions are of type size_t.
 * Change the casts in these macros if not!
 */

#include <string.h>
#define MEMZERO(target,size)    memset((void *)(target), 0, (size_t)(size))
#define MEMCOPY(dest,src,size)  memcpy((void *)(dest), (const void *)(src), (size_t)(size))

/*
  Define a macro to access the JPEG alloc_small routine
*/
#define JALLOC(nbytes) jalloc( cinfo,  (size_t) (nbytes) )


/* Now include the portable JPEG definition files. */

/*********************** JCONFIG.H ***********************************/
/*
 * jconfig.h
 *
 * Copyright (C) 1991, 1992, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file contains preprocessor declarations that help customize
 * the JPEG software for a particular application, machine, or compiler.
 * Edit these declarations as needed (or add -D flags to the Makefile).
 */


/*
 * These symbols indicate the properties of your machine or compiler.
 * The conditional definitions given may do the right thing already,
 * but you'd best look them over closely, especially if your compiler
 * does not handle full ANSI C.  An ANSI-compliant C compiler should
 * provide all the necessary features; __STDC__ is supposed to be
 * predefined by such compilers.
 */

/*
 * HAVE_STDC is tested below to see whether ANSI features are available.
 * We avoid testing __STDC__ directly for arcane reasons of portability.
 * (On some compilers, __STDC__ is only defined if a switch is given,
 * but the switch also disables machine-specific features we need to get at.
 * In that case, -DHAVE_STDC in the Makefile is a convenient solution.)
 */


#ifdef __STDC__         /* if compiler claims to be ANSI, believe it */
#define HAVE_STDC
#endif



/* Does your compiler support function prototypes? */
/* (If not, you also need to use ansi2knr, see SETUP) */

#ifdef HAVE_STDC        /* ANSI C compilers always have prototypes */
#define PROTO
#else
#ifdef __cplusplus      /* So do C++ compilers */
#define PROTO
#endif
#endif

/* Does your compiler support the declaration "unsigned char" ? */
/* How about "unsigned short" ? */

#ifdef HAVE_STDC        /* ANSI C compilers must support both */
#define HAVE_UNSIGNED_CHAR
#define HAVE_UNSIGNED_SHORT
#endif

/* If your compiler supports inline functions, define INLINE
 * as the inline keyword; otherwise define it as empty.
 */

#ifdef __GNUC__         /* for instance, GNU C knows about inline */
#define INLINE __inline__
#endif
#ifndef INLINE          /* default is to define it as empty */
#define INLINE
#endif

/* On a few systems, type boolean and/or macros FALSE, TRUE may appear
 * in standard header files.  Or you may have conflicts with application-
 * specific header files that you want to include together with these files.
 * In that case you need only comment out these definitions.
 */

typedef Int32 boolean;
#undef FALSE            /* in case these macros already exist */
#undef TRUE
#define FALSE   0       /* values of boolean */
#define TRUE    1

/* This defines the size of the I/O buffers for entropy compression
 * and decompression; you could reduce it if memory is tight.
 */

#define JPEG_BUF_SIZE   4096 /* bytes */

/*
  Macro to test for error returns.
  Frees up all jpeg allocated memory
  and returns the error code
*/
#define CHECKERR(func) \
{ \
Int32 status; \
if ((status = (func)) != ia_successful) \
    return status; \
}

/*
  Macros to test for out-of-memory conditions.
  Frees up all jpeg memory allocated so far.

  CHECKMEM returns ia_nomem error code for functions
  returning an Int32 error code.

  PCHECKMEM returns a NULL ptr for functions 
  returning a memory address.
*/
#define CHECKMEM(ptr) \
if ((ptr) == NULL) { jfree_all(cinfo); return ia_nomem; }

#define PCHECKMEM(ptr) \
if ((ptr) == NULL) { jfree_all(cinfo); return NULL; }

/* These symbols determine the JPEG functionality supported. */

/*
 * These defines indicate whether to include various optional functions.
 * Undefining some of these symbols will produce a smaller but less capable
 * program file.  Note that you can leave certain source files out of the
 * compilation/linking process if you've #undef'd the corresponding symbols.
 * (You may HAVE to do that if your compiler doesn't like null source files.)
 */

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

/* Encoder capability options: */
#undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
#undef  C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files?  (NYI) */
#undef ENTROPY_OPT_SUPPORTED        /* Optimization of entropy coding parms? */
#undef INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
/* Decoder capability options: */
#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
#undef D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
#undef BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing during decoding? */
#undef QUANT_1PASS_SUPPORTED    /* 1-pass color quantization? */
#undef QUANT_2PASS_SUPPORTED    /* 2-pass color quantization? */
/* these defines indicate which JPEG file formats are allowed */
#define JFIF_SUPPORTED      /* JFIF or "raw JPEG" files */
#undef  JTIFF_SUPPORTED     /* JPEG-in-TIFF (not yet implemented) */
/* these defines indicate which image (non-JPEG) file formats are allowed */
#undef GIF_SUPPORTED        /* GIF image file format */
/* #define RLE_SUPPORTED */ /* RLE image file format (by default, no) */
#undef PPM_SUPPORTED        /* PPM/PGM image file format */
#undef TARGA_SUPPORTED      /* Targa image file format */
#undef  TIFF_SUPPORTED      /* TIFF image file format (not yet impl.) */

/* more capability options later, no doubt */


/*
 * Define exactly one of these three symbols to indicate whether you want
 * 8-bit, 12-bit, or 16-bit sample (pixel component) values.  8-bit is the
 * default and is nearly always the right thing to use.  You can use 12-bit if
 * you need to support image formats with more than 8 bits of resolution in a
 * color value.  16-bit should only be used for the lossless JPEG mode (not
 * currently supported).  Note that 12- and 16-bit values take up twice as
 * much memory as 8-bit!
 * Note: if you select 12- or 16-bit precision, it is dangerous to turn off
 * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
 * precision, so jchuff.c normally uses entropy optimization to compute
 * usable tables for higher precision.  If you don't want to do optimization,
 * you'll have to supply different default Huffman tables.
 */

#define EIGHT_BIT_SAMPLES
#undef  TWELVE_BIT_SAMPLES
#undef  SIXTEEN_BIT_SAMPLES



/*
 * The remaining definitions don't need to be hand-edited in most cases.
 * You may need to change these if you have a machine with unusual data
 * types; 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 it had better be at least 16.
 */

/* First define the representation of a single pixel element value. */

#ifdef EIGHT_BIT_SAMPLES
/* JSAMPLE should be the smallest type that will hold the values 0..255.
 * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
 * If you have only signed chars, and you are more worried about speed than
 * memory usage, it might be a win to make JSAMPLE be short.
 */

typedef UInt8 JSAMPLE;

#define GETJSAMPLE(value)  (value)
#define BITS_IN_JSAMPLE   8
#define MAXJSAMPLE  255
#define CENTERJSAMPLE   128

#endif /* EIGHT_BIT_SAMPLES */


#ifdef TWELVE_BIT_SAMPLES
/* JSAMPLE should be the smallest type that will hold the values 0..4095. */
/* On nearly all machines "short" will do nicely. */

typedef Int16 JSAMPLE;

#define GETJSAMPLE(value)  (value)
#define BITS_IN_JSAMPLE   12
#define MAXJSAMPLE  4095
#define CENTERJSAMPLE   2048

#endif /* TWELVE_BIT_SAMPLES */


#ifdef SIXTEEN_BIT_SAMPLES
/* JSAMPLE should be the smallest type that will hold the values 0..65535. */

#ifdef HAVE_UNSIGNED_SHORT

typedef UInt16 JSAMPLE;
#define GETJSAMPLE(value)  (value)

#else /* not HAVE_UNSIGNED_SHORT */

/* If int is 32 bits this'll be horrendously inefficient storage-wise.
 * But since we don't actually support 16-bit samples (ie lossless coding) yet,
 * I'm not going to worry about making a smarter definition ...
 */
typedef UInt32 JSAMPLE;
#define GETJSAMPLE(value)  (value)

#endif /* HAVE_UNSIGNED_SHORT */

#define BITS_IN_JSAMPLE    16
#define MAXJSAMPLE  65535
#define CENTERJSAMPLE   32768

#endif /* SIXTEEN_BIT_SAMPLES */


/* Here we define the representation of a DCT frequency coefficient.
 * This should be a signed 16-bit value; "short" is usually right.
 * It's important that this be exactly 16 bits, no more and no less;
 * more will cost you a BIG hit of memory, less will give wrong answers.
 */

typedef Int16 JCOEF;


/*****************End of JCONFIG.H ***********************************/

/******* Now include JPEGDATA.H - the data structure definition file ****/
/*
 * jpegdata.h
 *
 * Copyright (C) 1991, 1992, Thomas G. Lane.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file defines shared data structures for the various JPEG modules.
 */

/*
 * You might need to change some of the following declarations if you are
 * using the JPEG software within a surrounding application program
 * or porting it to an unusual system.
 */


/* If the source or destination of image data is not to be stdio streams,
 * these types may need work.  You can replace them with some kind of
 * pointer or indicator that is useful to you, or just ignore 'em.
 * Note that the user interface and the various jrdxxx/jwrxxx modules
 * will also need work for non-stdio input/output.
 */

typedef FILE * JFILEREF;    /* source or dest of JPEG-compressed data */

typedef FILE * IFILEREF;    /* source or dest of non-JPEG image data */

/* These defines are used in all function definitions and extern declarations.
 * You could modify them if you need to change function linkage conventions,
 * as is shown below for use with C++.  Another application would be to make
 * all functions global for use with code profilers that require it.
 * NOTE: the C++ test does the right thing if you are reading this include
 * file in a C++ application to link to JPEG code that's been compiled with a
 * regular C compiler.  I'm not sure it works if you try to compile the JPEG
 * code with C++.
 */

#define METHODDEF static    /* a function called through method pointers */
#define LOCAL     static    /* a function used only in its module */
#define GLOBAL          /* a function referenced thru EXTERNs */
#ifdef __cplusplus
#define EXTERN    extern "C"    /* a reference to a GLOBAL function */
#else
#define EXTERN    extern    /* a reference to a GLOBAL function */
#endif


/* This macro is used to declare a "method", that is, a function pointer. */
/* We want to supply prototype parameters if the compiler can cope. */
/* Note that the arglist parameter must be parenthesized! */

#ifdef PROTO
#define METHOD(type,methodname,arglist)  type (*methodname) arglist
#else
#define METHOD(type,methodname,arglist)  type (*methodname) ()
#endif

/* Forward references to lists of method pointers */
typedef struct External_methods_struct * external_methods_ptr;
typedef struct Compress_methods_struct * compress_methods_ptr;
typedef struct Decompress_methods_struct * decompress_methods_ptr;


/* Data structures for images containing either samples or coefficients. */
/* Note that the topmost (leftmost) index is always color component. */
/* On 80x86 machines, the image arrays are too big for near pointers, */
/* but the pointer arrays can fit in near memory. */

typedef JSAMPLE *JSAMPROW;  /* ptr to one image row of pixel samples. */
typedef JSAMPROW *JSAMPARRAY;   /* ptr to some rows (a 2-D sample array) */
typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */


#define DCTSIZE     8   /* The basic DCT block is 8x8 samples */
#define DCTSIZE2    64  /* DCTSIZE squared; # of elements in a block */

typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
typedef JBLOCK *JBLOCKROW;  /* pointer to one row of coefficient blocks */
typedef JBLOCKROW *JBLOCKARRAY;     /* a 2-D array of coefficient blocks */
typedef JBLOCKARRAY *JBLOCKIMAGE;   /* a 3-D array of coefficient blocks */

typedef JCOEF *JCOEFPTR;    /* useful in a couple of places */


/* The input and output data of the DCT transform subroutines are of
 * the following type, which need not be the same as JCOEF.
 * For example, on a machine with fast floating point, it might make sense
 * to recode the DCT routines to use floating point; then DCTELEM would be
 * 'float' or 'double'.
 */

typedef JCOEF DCTELEM;
typedef DCTELEM DCTBLOCK[DCTSIZE2];

/* Define the variety of user memory organizations */

#define JMEMORG_BIP         1
#define JMEMORG_BSQ_MEM     2
#define JMEMORG_BSQ_PIXR    3
#define JMEMORG_GRAY8_MEM   4
#define JMEMORG_GRAY8_PIXR  5
#define JMEMORG_GRAY4_MEM   6
#define JMEMORG_GRAY4_PIXR  7

/* Define structures for the JPEG memory manager */
typedef double align_type;
typedef union small_struct * small_ptr;

typedef union small_struct {
    small_ptr next;        /* next in list of allocated objects */
    align_type dummy;      /* ensures alignment of following storage */
} small_hdr;


/* Types for JPEG compression parameters and working tables. */


typedef enum {          /* defines known color spaces */
    CS_UNKNOWN,     /* error/unspecified */
    CS_GRAYSCALE,       /* monochrome (only 1 component) */
    CS_RGB,         /* red/green/blue */
    CS_YCbCr,       /* Y/Cb/Cr (also known as YUV) */
    CS_YIQ,         /* Y/I/Q */
    CS_CMYK         /* C/M/Y/K */
} COLOR_SPACE;


typedef struct {        /* Basic info about one component */
  /* These values are fixed over the whole image */
  /* For compression, they must be supplied by the user interface; */
  /* for decompression, they are read from the SOF marker. */
    Int16 component_id; /* identifier for this component (0..255) */
    Int16 component_index;  /* its index in SOF or cinfo->comp_info[] */
    Int16 h_samp_factor;    /* horizontal sampling factor (1..4) */
    Int16 v_samp_factor;    /* vertical sampling factor (1..4) */
    Int16 quant_tbl_no; /* quantization table selector (0..3) */
  /* These values may vary between scans */
  /* For compression, they must be supplied by the user interface; */
  /* for decompression, they are read from the SOS marker. */
    Int16 dc_tbl_no;    /* DC entropy table selector (0..3) */
    Int16 ac_tbl_no;    /* AC entropy table selector (0..3) */
  /* These values are computed during compression or decompression startup */
    Int32 true_comp_width;   /* component's image width in samples */
    Int32 true_comp_height;  /* component's image height in samples */
    /* the above are the logical dimensions of the downsampled image */
  /* These values are computed before starting a scan of the component */
    Int16 MCU_width;    /* number of blocks per MCU, horizontally */
    Int16 MCU_height;   /* number of blocks per MCU, vertically */
    Int16 MCU_blocks;   /* MCU_width * MCU_height */
    Int32 downsampled_width; /* image width in samples, after expansion */
    Int32 downsampled_height; /* image height in samples, after expansion */
    /* the above are the true_comp_xxx values rounded up to multiples of */
    /* the MCU dimensions; these are the working dimensions of the array */
    /* as it is passed through the DCT or IDCT step.  NOTE: these values */
    /* differ depending on whether the component is interleaved or not!! */
} jpeg_component_info;


/* DCT coefficient quantization tables.
 * For 8-bit precision, 'Int16' should be good enough for quantization values;
 * for more precision, we go for the full 16 bits.  'Int16' provides a useful
 * speedup on many machines (multiplication & division of JCOEFs by
 * quantization values is a significant chunk of the runtime).
 * Note: the values in a QUANT_TBL are always given in zigzag order.
 */
#ifdef EIGHT_BIT_SAMPLES
typedef Int16 QUANT_VAL;    /* element of a quantization table */
#else
typedef UInt16 QUANT_VAL;   /* element of a quantization table */
#endif
typedef QUANT_VAL QUANT_TBL[DCTSIZE2];  /* A quantization table */
typedef QUANT_VAL * QUANT_TBL_PTR;  /* pointer to same */


typedef struct {        /* A Huffman coding table */
  /* These two fields directly represent the contents of a JPEG DHT marker */
    UInt8 bits[17];     /* bits[k] = # of symbols with codes of */
                /* length k bits; bits[0] is unused */
    UInt8 huffval[256]; /* The symbols, in order of incr code length */
  /* This field is used only during compression.  It's initialized FALSE when
   * the table is created, and set TRUE when it's been output to the file.
   */
    boolean sent_table; /* TRUE when table has been output */
  /* The remaining fields are computed from the above to allow more efficient
   * coding and decoding.  These fields should be considered private to the
   * Huffman compression & decompression modules.
   */
    /* encoding tables: */
    UInt16 ehufco[256]; /* code for each symbol */
    Int8 ehufsi[256];   /* length of code for each symbol */
    /* decoding tables: (element [0] of each array is unused) */
    UInt16 mincode[17]; /* smallest code of length k */
    Int32 maxcode[18];  /* largest code of length k (-1 if none) */
    /* (maxcode[17] is a sentinel to ensure huff_DECODE terminates) */
    Int16 valptr[17];   /* huffval[] index of 1st symbol of length k */
} HUFF_TBL;


#define NUM_QUANT_TBLS      4   /* quantization tables are numbered 0..3 */
#define NUM_HUFF_TBLS       4   /* Huffman tables are numbered 0..3 */
#define NUM_ARITH_TBLS      16  /* arith-coding tables are numbered 0..15 */
#define MAX_COMPS_IN_SCAN   4   /* JPEG limit on # of components in one scan */
#define MAX_SAMP_FACTOR     4   /* JPEG limit on sampling factors */
#define MAX_BLOCKS_IN_MCU   10  /* JPEG limit on # of blocks in an MCU */


/* Working data for compression */

struct Compress_info_struct {
/*
 * All of these fields shall be established by the user interface before
 * calling jpeg_compress, or by the input_init or c_ui_method_selection
 * methods.
 * Most parameters can be set to reasonable defaults by j_c_defaults.
 * Note that the UI must supply the storage for the main methods struct,
 * though it sets only a few of the methods there.
 */
    compress_methods_ptr cmethods;  /* Points to list of BWC methods */
    decompress_methods_ptr dmethods;/* Points to list of BWE methods */
    external_methods_ptr emethods; /* Points to list of error methods */

    Int32 image_width;       /* input image width */
    Int32 image_height;      /* input image height */
    Int16 data_precision;   /* bits of precision in image data */

    COLOR_SPACE in_color_space;   /* colorspace of input file */
    COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
    COLOR_SPACE out_color_space;  /* colorspace of output file */

    Int16 input_components; /* # of color components in input image */
    Int16 num_components;   /* # of color components in JPEG image */
    Int16 color_out_comps;  /* # of color comps output by color_convert */
                            /* (need not match num_components) */
    Int16 final_out_comps;  /* # of color comps sent to put_pixel_rows */

  /* 
    Both of these buffers are declared as arrays of 2
    in order to achieve a single "cinfo" structure which
    can be used for both compression and decompression
  */  
    JSAMPIMAGE fullsize_data[2]; /* Ptrs to buffers for input MCU rows */
    JSAMPIMAGE sampled_data[2];  /* Ptrs to buffer for downsampled data */

    void *userData;         /* for access to user-supplied data */
    Int32 rowNum;           /* current row counter */
    Int32 cur_mcu_row;      /* Current MCU row */
    Int32 mcu_rows_output;  /* MCU rows written so far */
    Int32 rowsPerMCU;       /* Image lines in an MCU (for convenience) */
    Int32 whichss;          /* selects sampling buffer */
    UInt32 userMemOrg;      /* User memory organization */

  /* 
    Internal buffer - for possible conversion between caller's 
    format (e.g. band-interleaved) and JPEG format.
    Also used for dealing with endian conversions *
  */
    JSAMPIMAGE jpegBuf;

    JBLOCKIMAGE coeff_data;      /* Dequantized coeff storage */

  /*
    Function ptrs to procedures for byte swapping or
    other conversions.
  */
    Int32 CDECL (*byteSwapProc)();  /* Byte flipping proc to be used */
    Int32 CDECL (*cvtImageRow)();   /* Image format conversion routine */
    UInt16 *depthLut;              /* Ptr to table to cvt 4bpp to 8bpp */


    /* Function ptrs to user-supplied callback procedures
       to transfer the compressed JPEG data to and from the 
       JFIF file (or memory buffer). The write function is
       for compression; the read function is for decompression.
    */
    Int32 CDECL (*writeCallback) (struct Compress_info_struct *,
                           UInt8 *JPEGsrcBuffer, 
                           Int32 byteToWrite);

    Int32 CDECL (*readCallback) (struct Compress_info_struct *,
                           UInt8 *JPEGdstBuffer, 
                           Int32 bytesToRead);

    Int32 * rgb_ycc_tab;     /* RGB to YCC conversion table */
    Int32 *   Cr_r_tab;        /* YCC to RGB conversion tables */
    Int32 *   Cb_b_tab;
    Int32 * Cr_g_tab;
    Int32 * Cb_g_tab;

  /* Compression bit packing variables */
    UInt8 * output_buffer;   /* Output buffer - receives huff coded data */
    UInt8 * buffer_ptr;      /* Ptr to current pos in output_buffer */
    UInt8 * buffer_end;      /* Ptr to one byte past end of output_buffer */
    UInt32 treg;             /* "Target register" for huffman bit packing */
    UInt32  msb;             /* Bit position in treg */

  /* Decompression bit unpacking variables */
    Int32 get_buffer;     /* Word to collect bit fields from file */
    Int32   bits_left;      /* Bits remaining in get_buffer */
    boolean printed_eod;  /* Flag to prevent multiple warning msgs */

    small_ptr small_list;    /* Head of list for memory manager */

    boolean write_JFIF_header; /* should a JFIF marker be written? */

    /* These three values are not used by the JPEG code, only copied */
    /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
    /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
    /* ratio is defined by X_density/Y_density even when density_unit=0. */
    UInt8 density_unit; /* JFIF code for pixel size units */
    UInt16 X_density;   /* Horizontal pixel density */
    UInt16 Y_density;   /* Vertical pixel density */

    JSAMPLE * sample_range_limit; /* table for fast range-limiting */

  /* comp_info[i] describes component that appears i'th in SOF */
    jpeg_component_info * comp_info;

  /* ptrs to coeff quantization tables, or NULL if not defined */
    QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS];

  /* ptrs to Huffman coding tables, or NULL if not defined */
    HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
    HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];

  /* Arithmetic coding tables - not currently used */
    UInt8 arith_dc_L[NUM_ARITH_TBLS]; /* DC L values */
    UInt8 arith_dc_U[NUM_ARITH_TBLS]; /* DC U values */
    UInt8 arith_ac_K[NUM_ARITH_TBLS]; /* AC Kx values */

  /* Various option flags - currently unused */
    boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
    boolean interleave; /* TRUE=interleaved output, FALSE=not */
    boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
    boolean CCIR601_sampling; /* TRUE=first samples are cosited */
    Int32 smoothing_factor;   /* 1..100, or 0 for no input smoothing */

    /* The restart interval can be specified in absolute MCUs by setting
     * restart_interval, or in MCU rows by setting restart_in_rows
     * (in which case the correct restart_interval will be figured
     * for each scan).
     */
    UInt16 restart_interval;/* MCUs per restart , or 0 for no restart */
    Int32 restart_in_rows;    /* if > 0, MCU rows per restart interval */

/*
 * These fields are computed during startup
 */
    Int16 max_h_samp_factor; /* largest h_samp_factor */
    Int16 max_v_samp_factor; /* largest v_samp_factor */

/*
 * These fields may be useful for progress monitoring
 */
    Int32 total_passes;   /* number of passes expected */
    Int32 completed_passes;   /* number of passes completed so far */

/*
 * These fields are valid during any one scan
 */
    Int16 comps_in_scan;    /* # of JPEG components output this time */
    jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
    /* *cur_comp_info[i] describes component that appears i'th in SOS */

    Int32 MCUs_per_row;  /* # of MCUs across the image */
    Int32 MCU_rows_in_scan;  /* # of MCU rows in the image */

    Int16 blocks_in_MCU;    /* # of DCT blocks per MCU */
    Int16 MCU_membership[MAX_BLOCKS_IN_MCU];
    /* MCU_membership[i] is index in cur_comp_info of component owning */
    /* i'th block in an MCU */

    /* these fields are private data for the entropy encoder */
    JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */
    JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */
    UInt16 restarts_to_go;  /* MCUs left in this restart interval */
    Int16 next_restart_num; /* # of next RSTn marker (0..7) */

    boolean do_block_smoothing; /* T = apply cross-block smoothing */
    boolean do_pixel_smoothing; /* T = apply post-upsampling smoothing */

    Int32 pixel_rows_output; /* output counter */
    Int32 lines_to_write;    /* line output count */


    Int32 dcOnly;           /* Flag set to True if expansion is
                               to use only the DC term, producing a 
                               quick low res image */ 

#ifdef BLOCK_SMOOTHING_SUPPORTED
    JBLOCKIMAGE bsmooth[3];     /* Buffer for cross-block input smoothing */
#endif

/*
 * These fields are used for efficient buffering of data between 
 * read_jpeg_data and the entropy decoding object.  
 * By using a shared buffer, we avoid copying
 * data and eliminate the need for an "unget" operation at the end 
 * of a scan.
 *
 * The actual source of the data is known only to read_jpeg_data; see the
 * JGETC macro, below.
 *
 * Note: the user interface is expected to allocate the input_buffer and
 * initialize bytes_in_buffer to 0.  Also, for JFIF/raw-JPEG input, the UI
 * actually supplies the read_jpeg_data method.  This is all handled by
 * j_d_defaults in a typical implementation.
 */
    Int8 * input_buffer;    /* start of buffer (private to input code) */
    Int8 * next_input_byte; /* => next byte to read from buffer */
    Int32 bytes_in_buffer;    /* # of bytes remaining in buffer */

};

typedef struct Compress_info_struct CompressInfo;
typedef struct Compress_info_struct * compress_info_ptr;


/* Define decompress_info structures to be same as compress_info */
typedef struct Compress_info_struct DecompressInfo;
typedef struct Compress_info_struct * decompress_info_ptr;


/* Macros for reading data from the decompression input buffer */

#ifdef CHAR_IS_UNSIGNED
#define JGETC(cinfo)    (( --(cinfo)->bytes_in_buffer < 0) ? \
             ((*(cinfo)->dmethods->read_jpeg_data) (cinfo)) : \
             ((Int32) (*(cinfo)->next_input_byte++) ) )
#else
#define JGETC(cinfo)    ( (--(cinfo)->bytes_in_buffer < 0) ? \
             ((*(cinfo)->dmethods->read_jpeg_data) (cinfo) ) : \
             ((Int32) (*(cinfo)->next_input_byte++) & 0xFF ) )
#endif

#define JUNGETC(ch,cinfo)  ( ((cinfo)->bytes_in_buffer++), \
                (*(--((cinfo)->next_input_byte)) = (Int8) (ch)))

#define MIN_UNGET   4   /* may always do at least 4 JUNGETCs */


/* A virtual image has a control block whose contents are private to the
 * memory manager module (and may differ between managers).  The rest of the
 * code only refers to virtual images by these pointer types, and never
 * dereferences the pointer.
 */

typedef struct big_sarray_control * big_sarray_ptr;
typedef struct big_barray_control * big_barray_ptr;

/* Although a real ANSI C compiler can deal perfectly well with pointers to
 * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI
 * and pseudo-ANSI compilers get confused.  To keep one of these bozos happy,
 * add -DINCOMPLETE_TYPES_BROKEN to CFLAGS in your Makefile.  Then we will
 * pseudo-define the structs as containing a single "dummy" field.
 * The memory managers #define AM_MEMORY_MANAGER before including this file,
 * so that they can make their own definitions of the structs.
 */

#ifdef INCOMPLETE_TYPES_BROKEN
#ifndef AM_MEMORY_MANAGER
struct big_sarray_control { Int32 dummy; };
struct big_barray_control { Int32 dummy; };
#endif
#endif


/* Method types that need typedefs */

typedef METHOD(Int32 CDECL, MCU_output_method_ptr, (compress_info_ptr cinfo,
                         JBLOCK *MCU_data));
typedef METHOD(Int32 CDECL, MCU_output_caller_ptr, (compress_info_ptr cinfo,
                         MCU_output_method_ptr output_method));
typedef METHOD(Int32 CDECL, downsample_ptr, (compress_info_ptr cinfo,
                      Int32 which_component,
                      Int32 input_cols, Int32 input_rows,
                      Int32 output_cols, Int32 output_rows,
                      JSAMPARRAY above,
                      JSAMPARRAY input_data,
                      JSAMPARRAY below,
                      JSAMPARRAY output_data));
typedef METHOD(Int32 CDECL, upsample_ptr, (decompress_info_ptr cinfo,
                    Int32 which_component,
                    Int32 input_cols, Int32 input_rows,
                    Int32 output_cols, Int32 output_rows,
                    JSAMPARRAY above,
                    JSAMPARRAY input_data,
                    JSAMPARRAY below,
                    JSAMPARRAY output_data));
typedef METHOD(Int32 CDECL, quantize_method_ptr, (decompress_info_ptr cinfo,
                       Int32 num_rows,
                       JSAMPIMAGE input_data,
                       JSAMPARRAY output_workspace));
typedef METHOD(Int32 CDECL, quantize_caller_ptr, (decompress_info_ptr cinfo,
                       quantize_method_ptr quantize_method));


/* These structs contain function pointers for the various JPEG methods. */

/* Routines to be provided by the surrounding application, rather than the
 * portable JPEG code proper.  These are the same for compression and
 * decompression.
 */

struct External_methods_struct {
    /* User interface: error exit and trace message routines */
    /* NOTE: the string msgtext parameters will eventually be replaced
     * by an enumerated-type code so that non-English error messages
     * can be substituted easily.  This will not be done until all the
     * code is in place, so that we know what messages are needed.
     */
    METHOD(Int32 CDECL, error_exit, (compress_info_ptr cinfo, const char *msgtext, Int32 ecode));
    METHOD(void CDECL, trace_message, (compress_info_ptr cinfo, const char *msgtext, Int32 ecode));

    /* Working data for error/trace facility */
    /* See macros below for the usage of these variables */
    Int32 trace_level;    /* level of detail of tracing messages */
    /* Use level 0 for important warning messages (nonfatal errors) */
    /* Use levels 1, 2, 3 for successively more detailed trace options */

    /* For recoverable corrupt-data errors, we emit a warning message and
     * keep going.  A surrounding application can check for bad data by
     * seeing if num_warnings is nonzero at the end of processing.
     */
    Int32 num_warnings;  /* number of corrupt-data warnings */
    Int32 first_warning_level; /* trace level for first warning */
    Int32 more_warning_level; /* trace level for subsequent warnings */

    Int32 message_parm[8];    /* store numeric parms for messages here */

};

/* Macros to simplify using the error and trace message stuff */
/* The first parameter is generally cinfo->emethods */


#define MAKESTMT(stuff)     do { stuff } while (0)

#ifdef JDEBUG

/* Fatal errors (print message and exit) */

#define ERREXIT(emeth,msg,errcode)      return ((*(emeth)->error_exit) (cinfo,msg,errcode))
#define ERREXIT1(emeth,msg,errcode, p1)     return ((emeth)->message_parm[0] = (p1), \
                     (*(emeth)->error_exit) (cinfo,msg,errcode))
#define ERREXIT2(emeth,msg,errcode,p1,p2)   return ((emeth)->message_parm[0] = (p1), \
                     (emeth)->message_parm[1] = (p2), \
                     (*(emeth)->error_exit) (cinfo,msg,errcode))
#define ERREXIT3(emeth,msg,errcode,p1,p2,p3)    return ((emeth)->message_parm[0] = (p1), \
                     (emeth)->message_parm[1] = (p2), \
                     (emeth)->message_parm[2] = (p3), \
                     (*(emeth)->error_exit) (cinfo,msg,errcode))
#define ERREXIT4(emeth,msg,errcode,p1,p2,p3,p4) return ((emeth)->message_parm[0] = (p1), \
                     (emeth)->message_parm[1] = (p2), \
                     (emeth)->message_parm[2] = (p3), \
                     (emeth)->message_parm[3] = (p4), \
                     (*(emeth)->error_exit) (cinfo,msg,errcode))

/* Nonfatal errors (we'll keep going, but the data is probably corrupt) */
/* Note that warning count is incremented as a side-effect! */

#define WARNMS(emeth,msg,errcode)    \
  MAKESTMT( if ((emeth)->trace_level >= ((emeth)->num_warnings++ ? \
        (emeth)->more_warning_level : (emeth)->first_warning_level)){ \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define WARNMS1(emeth,msg,errcode,p1)    \
  MAKESTMT( if ((emeth)->trace_level >= ((emeth)->num_warnings++ ? \
        (emeth)->more_warning_level : (emeth)->first_warning_level)){ \
        (emeth)->message_parm[0] = (p1); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define WARNMS2(emeth,msg,errcode,p1,p2)    \
  MAKESTMT( if ((emeth)->trace_level >= ((emeth)->num_warnings++ ? \
        (emeth)->more_warning_level : (emeth)->first_warning_level)){ \
        (emeth)->message_parm[0] = (p1); \
        (emeth)->message_parm[1] = (p2); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )

/* Informational/debugging messages */
#define TRACEMS(emeth,lvl,msg,errcode)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define TRACEMS1(emeth,lvl,msg,errcode,p1)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        (emeth)->message_parm[0] = (p1); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define TRACEMS2(emeth,lvl,msg,errcode,p1,p2)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        (emeth)->message_parm[0] = (p1); \
        (emeth)->message_parm[1] = (p2); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define TRACEMS3(emeth,lvl,msg,errcode,p1,p2,p3)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        Int32 * _mp = (emeth)->message_parm; \
        *_mp++ = (p1); *_mp++ = (p2); *_mp = (p3); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define TRACEMS4(emeth,lvl,msg,errcode,p1,p2,p3,p4)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        Int32 * _mp = (emeth)->message_parm; \
        *_mp++ = (p1); *_mp++ = (p2); *_mp++ = (p3); *_mp = (p4); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )
#define TRACEMS8(emeth,lvl,msg,errcode,p1,p2,p3,p4,p5,p6,p7,p8)    \
  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
        Int32 * _mp = (emeth)->message_parm; \
        *_mp++ = (p1); *_mp++ = (p2); *_mp++ = (p3); *_mp++ = (p4); \
        *_mp++ = (p5); *_mp++ = (p6); *_mp++ = (p7); *_mp = (p8); \
        (*(emeth)->trace_message) (cinfo,msg,errcode); } )

/*
  If JDEBUG is not true, define the warning stuff away to
  nothing. Also eliminate the message strings from the
  error_exit routine. Code in jerrString translates the
  error codes. It should be called by the app.
*/

#else
/*
  Define these away to nothing unless debugging,
  otherwise they just generate useless code which
  takes up space. Use a semi-colon to generate
  a null statement -- prevents compiler whining
  about empty bodies
*/
#define WARNMS(emeth,msg,errcode) do {;} while (0);
#define WARNMS1(emeth,msg,errcode,p1) do {;} while (0);
#define WARNMS2(emeth,msg,errcode,p1,p2) do {;} while (0);
#define TRACEMS(emeth,lvl,msg,errcode) do {;} while (0);
#define TRACEMS1(emeth,lvl,msg,errcode,p1) do {;} while (0);
#define TRACEMS2(emeth,lvl,msg,errcode,p1,p2) do {;} while (0);
#define TRACEMS3(emeth,lvl,msg,errcode,p1,p2,p3) do {;} while (0);
#define TRACEMS4(emeth,lvl,msg,errcode,p1,p2,p3,p4) do {;} while (0);
#define TRACEMS8(emeth,lvl,msg,errcode,p1,p2,p3,p4,p5,p6,p7,p8) \
do {;} while (0);

/* 
  For fatal errors (clean up exit with error code) 
*/
#define ERREXIT(emeth,msg,errcode) return \
    ((*(emeth)->error_exit) (cinfo,NULL,errcode))
#define ERREXIT1(emeth,msg,errcode,p1) return \
    ((*(emeth)->error_exit) (cinfo,NULL,errcode))
#define ERREXIT2(emeth,msg,errcode,p1,p2) return \
    ((*(emeth)->error_exit) (cinfo,NULL,errcode))
#define ERREXIT3(emeth,msg,errcode,p1,p2,p3) return \
    ((*(emeth)->error_exit) (cinfo,NULL,errcode))
#define ERREXIT4(emeth,msg,errcode,p1,p2,p3,p4) return \
    ((*(emeth)->error_exit) (cinfo,NULL,errcode))

#endif

/* Methods used during JPEG compression. */


struct Compress_methods_struct {
  /* Color space and gamma conversion */
    METHOD(Int32 CDECL, colorin_init, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, get_sample_rows, (compress_info_ptr cinfo,
                       Int32 rows_to_read,
                       JSAMPIMAGE inbuf,
                       JSAMPIMAGE image_data));
    METHOD(Int32 CDECL, colorin_term, (compress_info_ptr cinfo));

  /* Expand picture data at edges */
    METHOD(Int32 CDECL, edge_expand, (compress_info_ptr cinfo,
                   Int32 input_cols, Int32 input_rows,
                   Int32 output_cols, Int32 output_rows,
                   JSAMPIMAGE image_data));

  /* Downsample pixel values of a single component */
  /* There can be a different downsample method for each component */
    METHOD(Int32 CDECL, downsample_init, (compress_info_ptr cinfo));
    downsample_ptr downsample[MAX_COMPS_IN_SCAN];
    METHOD(Int32 CDECL, downsample_term, (compress_info_ptr cinfo));

  /* Extract samples in MCU order, process & hand off to output_method */
  /* The input is always exactly N MCU rows worth of data */
    METHOD(Int32 CDECL, extract_init, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, extract_MCUs, (compress_info_ptr cinfo,
                    JSAMPIMAGE image_data,
                    Int32 num_mcu_rows,
                    MCU_output_method_ptr output_method));
    METHOD(Int32 CDECL, extract_term, (compress_info_ptr cinfo));

  /* Entropy encoding parameter optimization */
  /* Entropy encoding */
    METHOD(Int32 CDECL, entropy_encode_init, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, entropy_encode, (compress_info_ptr cinfo,
                      JBLOCK *MCU_data));
    METHOD(Int32 CDECL, entropy_encode_term, (compress_info_ptr cinfo));

  /* JPEG file header construction */
    METHOD(Int32 CDECL, write_file_header, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, write_scan_header, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, write_jpeg_data, (compress_info_ptr cinfo,
                       Int8 *dataptr, Int32 datacount));
    METHOD(Int32 CDECL, write_scan_trailer, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, write_file_trailer, (compress_info_ptr cinfo));
    METHOD(Int32 CDECL, entropy_output, (compress_info_ptr cinfo,
		      Int8 *dataptr, Int32 datacount));
};

/* Methods used during JPEG decompression. */

struct Decompress_methods_struct {
  /* JPEG file scanning */
    METHOD(Int32 CDECL, read_file_header, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, read_scan_header, (decompress_info_ptr cinfo,
           boolean *parseOK));
    METHOD(Int32 CDECL, read_jpeg_data, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, resync_to_restart, (decompress_info_ptr cinfo,
                     Int32 marker));
    METHOD(Int32 CDECL, read_scan_trailer, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, read_file_trailer, (decompress_info_ptr cinfo));

  /* Entropy decoding */
    METHOD(Int32 CDECL, entropy_decode_init, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, entropy_decode, (decompress_info_ptr cinfo,
                      JBLOCKROW *MCU_data));
    METHOD(Int32 CDECL, entropy_decode_term, (decompress_info_ptr cinfo));

  /* MCU disassembly: fetch MCUs from entropy_decode, build coef array */
  /* The reverse_DCT step is in the same module for symmetry reasons */
    METHOD(Int32 CDECL, disassemble_init, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, disassemble_MCU, (decompress_info_ptr cinfo,
                       JBLOCKIMAGE image_data));
    METHOD(Int32 CDECL, reverse_DCT, (decompress_info_ptr cinfo,
                   JBLOCKIMAGE coeff_data,
                   JSAMPIMAGE output_data, Int32 start_row));
    METHOD(Int32 CDECL, disassemble_term, (decompress_info_ptr cinfo));

  /* Upsample pixel values of a single component */
  /* There can be a different upsample method for each component */
    METHOD(Int32 CDECL, upsample_init, (decompress_info_ptr cinfo));
    upsample_ptr upsample[MAX_COMPS_IN_SCAN];
    METHOD(Int32 CDECL CDECL, upsample_term, (decompress_info_ptr cinfo));

  /* Color space and gamma conversion */
    METHOD(Int32 CDECL, colorout_init, (decompress_info_ptr cinfo));
    METHOD(Int32 CDECL, color_convert, (decompress_info_ptr cinfo,
                     Int32 num_rows, Int32 num_cols,
                     JSAMPIMAGE input_data,
                     JSAMPIMAGE output_data));
    METHOD(Int32 CDECL, colorout_term, (decompress_info_ptr cinfo));

};


/* We assume that right shift corresponds to signed division by 2 with
 * rounding towards minus infinity.  This is correct for typical "arithmetic
 * shift" instructions that shift in copies of the sign bit.  But some
 * C compilers implement >> with an unsigned shift.  For these machines you
 * must define RIGHT_SHIFT_IS_UNSIGNED.
 * RIGHT_SHIFT provides a proper signed right shift of an Int32 quantity.
 * It is only applied with constant shift counts.  SHIFT_TEMPS must be
 * included in the variables of any routine using RIGHT_SHIFT.
 */

#ifdef RIGHT_SHIFT_IS_UNSIGNED
#define SHIFT_TEMPS Int32 shift_temp;
#define RIGHT_SHIFT(x,shft)  \
    ((shift_temp = (x)) < 0 ? \
     (shift_temp >> (shft)) | ((~((Int32) 0)) << (32-(shft))) : \
     (shift_temp >> (shft)))
#else
#define SHIFT_TEMPS
#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
#endif


/* Miscellaneous useful macros */

#ifndef MAX
#define MAX(a,b)    ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a,b)    ((a) < (b) ? (a) : (b))
#endif


#define RST0    0xD0        /* RST0 marker code */

/*****************End of JPEGDATA.H ***********************************/

/************** End of JINCLUDE.H ***********************/

/* Define all of the error return codes */
/* Codes below 1024 are reserved for ia_xxxx returns */
#define JERR_FATAL 2048
#define JERR_WARNING 1536
#define JERR_INFO 1024

#define JERR_DHTCOUNT (JERR_FATAL + 1)
#define JERR_DHTINDEX (JERR_FATAL + 2)
#define JERR_DACINDEX (JERR_FATAL + 3)
#define JERR_QTNUM (JERR_FATAL + 4)
#define JERR_DRILEN (JERR_FATAL + 5)
#define JERR_JFIFREV (JERR_FATAL + 6)
#define JERR_ZERODNL (JERR_FATAL + 7)
#define JERR_PREC (JERR_FATAL + 8)
#define JERR_SOFLEN (JERR_FATAL + 9)
#define JERR_SOSLEN (JERR_FATAL + 10)
#define JERR_BADSOSCOMP (JERR_FATAL + 11)
#define JERR_NOTJPEG (JERR_FATAL + 12)
#define JERR_BADSOF (JERR_FATAL + 13)
#define JERR_BADMARKER (JERR_FATAL + 14)
#define JERR_BADHUFF (JERR_FATAL + 15)
#define JERR_IMAGETOOBIG (JERR_FATAL + 16)
#define JERR_EOF (JERR_FATAL + 17)
#define JERR_BADDATA (JERR_FATAL + 18)
#define JERR_TOOMANYCOMPS (JERR_FATAL + 19)
#define JERR_BADWIDTH (JERR_FATAL + 20)
#define JERR_NOAC (JERR_FATAL + 21)
#define JERR_CMAP (JERR_FATAL + 22)
#define JERR_BADCSPACE (JERR_FATAL + 23)
#define JERR_MULTISCAN (JERR_FATAL + 24)
#define JERR_BADSAMP (JERR_FATAL + 25)
#define JERR_NOMEM (JERR_FATAL + 26)
#define JERR_MEMERR (JERR_FATAL + 27)
#define JERR_DACVALUE (JERR_FATAL + 28)
#define JERR_WRITE (JERR_FATAL + 29)


#define JINFO_TEM (JERR_FATAL + 64)
#define JINFO_BADQT (JERR_FATAL + 65)


#define JINFO_SKIPMARKER (JERR_WARNING + 1)
#define JINFO_JFIFREV (JERR_WARNING + 2)
#define JINFO_BADTHUMB (JERR_WARNING + 3)
#define JINFO_BADAPP0 (JERR_WARNING + 4)
#define JINFO_SHORTAPP0 (JERR_WARNING + 5)
#define JINFO_BADCSPACE (JERR_WARNING + 6)
#define JINFO_RECOVER (JERR_WARNING + 7)

/* Stupid macro to avoid compiler complaints about unused args */
#define MENTION(arg) { (arg) = (arg);}

#endif /*  _JPEG_H_INCLUDED_ */

/*
$Log:   S:\products\msprods\xfilexr\include\jpeg.h_v  $
 * 
 *    Rev 1.0   12 Jun 1996 05:47:16   BLDR
 *  
 * 
 *    Rev 1.0   01 Jan 1996 11:24:04   MHUGHES
 * Initial revision.
 * Revision 1.16  1994/11/08  00:20:35  lperry
 * lperry on Mon Nov 7 16:16:21 PST 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Change code issuing error messages to eliminate
 * the strings in the ERREXIT macros. Unless the
 * value JDEBUG is defined, these strings are replaced
 * with NULL. (Clients still get the error code returned
 * which can be translated to a string by jerrorString().
 * Also defined away all the warning and trace code, which
 * was a no-op now anyway, to nothing.
 * All this trims about 6Kbytes off the JPEG libraries.
 *
 * Revision 1.15  1994/10/21  00:52:07  lperry
 * lperry on Thu Oct 20 17:51:55 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Get rid of UINT32, etc., so these files can work with Peter's interpreter.
 *
 * Revision 1.14  1994/09/08  00:17:35  lperry
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Conditionally define away IP_RCSINFO macro on PRODUCTION.
 *
 * Revision 1.13  1994/09/07  18:44:35  lperry
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Abbreviate the RCSINFO macro to remove the date, reducing string size.
 *
 * Revision 1.12  1994/08/01  20:41:43  lperry
 * lperry on Mon Aug 1 13:38:24 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Add complete declarations of parameters to function pointers
 * for the read and write callback functions in the cinfo
 * structure.
 *
 * Revision 1.11  1994/07/26  00:35:01  lperry
 * lperry on Mon Jul 25 17:30:44 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Added a test for the predefined variable "applec"
 * so that MPW compiles of the JPEG code pick up all
 * the right STDC definitions. Previous version
 * was defining a UInt16 to be an unsigned int
 * instead of an usigned short.
 *
 * Revision 1.10  1994/07/21  00:18:53  lperry
 * lperry on Wed Jul 20 17:18:50 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Change error handling from old setjmp/longjmp to function return codes.
 *
 * Revision 1.9  1994/06/27  17:13:19  lperry
 * lperry on Mon Jun 27 10:08:37 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Added formerly static parameters from the jpeg functions
 * to the "cinfo" structure, which is passed to almost all
 * routines. This was done to achieve reentrant code which
 * can be used in DLL's.
 *
 * Also merged the structure definitions for the compression
 * and decompression process into a single structure. (About
 * 70% of the structure members were identical in the two versions
 * anyway). This allows the same structure to be passed to a
 * compression or decompression function, eliminating the need
 * for several essentially duplicate functions in the two modes.
 *
 * Revision 1.8  1994/05/24  00:43:11  lperry
 * lperry on Mon May 23 17:41:16 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Added constants for specifying users data organization (JMEMORG_XXX)
 * Added hooks to cinfo/dinfo structures for specifying byte swapping
 * routines and internal buffers. These had been globals before.
 *
 * Revision 1.7  1994/05/05  01:39:03  ddavies
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Define MIN and MAX only if they're not already defined.
 *
 * Revision 1.6  1994/05/03  20:38:09  ddavies
 * ddavies on Tue May 3 13:37:49 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Add ansiprot.h so gcc sees a prototype for memset.
 *
 * Revision 1.5  1994/04/08  00:29:03  lperry
 * lperry on Thu Apr 7 17:25:13 PDT 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Added macro JALLOC for memory allocation with proper casting.
 *
 * Commented out a conditional define of "const" to null
 * which tested the value of STDC. This didn't cause the
 * compiler any problems, but cextract couldn't handle it.
 * (We've been assuming all our compilers are ANSI anyway).
 *
 * Revision 1.4  1994/03/26  00:46:44  ddavies
 * ddavies on Fri Mar 25 16:45:22 PST 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Add "const" to declaration of jerrorString to make gcc happy.  This routine
 * returns pointers to strings used to tell folks about errors.
 *
 * Revision 1.3  1994/03/24  23:43:59  lperry
 * lperry on Thu Mar 24 15:40:00 PST 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Add a parameter to the decompression data structure to
 * indicate that the DCT blocks should be filled with the
 * DC (average) value (dinfo.dcOnly). This variable being
 * set to True will cause the decompressor to skip the
 * reverse DCT step, saving a significant chunk of time
 * (actually only about 15%).
 *
 * Revision 1.2  1994/03/12  01:16:24  dferrell
 * dferrell on Fri Mar 11 17:13:48 PST 1994
 *
 * jpeg.h -> /product/ipcore/ipshared/include/RCS/jpeg.h,v
 *
 * Fixed problem related to __STDC__ not being defined by MPW C.  This
 * change only affects compilation on the Mac.
 *
 * Revision 1.1  1994/02/28  17:26:31  lperry
 * Initial revision
 *
 * Revision 1.1  1994/02/27  02:39:59  lperry
 * Initial revision
 *
*/