{
  unsigned char* bits;
  unsigned char* vals;
  unsigned char  hclass;
  unsigned char  ident;

} JPEGHuffTable;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        QUANT_TABLE
//
// Purpose:     Stores quantization table information in a
//              fast-to-use format.
//
// Context:     Used by quantizer/dequantizer to store formatted
//              quantization tables.
//
// Fields:
//  precision   0 => elements contains 8-bit elements,
//              1 => elements contains 16-bit elements.
//  ident       Table identifier (0-3).
//  elements    Pointer to 64 table elements + 16 extra elements to catch
//              input data errors that may cause malfunction of the
//              Huffman decoder.
//  elarray     Space for elements (see above) plus 8 bytes to align
//              to a quadword boundary.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _QUANT_TABLE
{
  int    precision;
  int    ident;
  short* elements;
  short  elarray [84];

} QUANT_TABLE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        JPEGQuantTable
//
// Purpose:     Stores pointers to JPEG binary spec compliant
//              quantization table information.
//
// Context:     Used by interface and table methods to specify encoder
//              tables to generate and store JPEG images.
//
// Fields:
//  quantizer   Zig-zag order elements specifying quantization factors.
//  ident       Specifies identifier for this table.
//              0-3 valid for Extended Baseline JPEG compliance.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _JPEGQuantTable
{
  unsigned char* quantizer;
  unsigned char  ident;

} JPEGQuantTable;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        FRAME_COMPONENT
//
// Purpose:     One frame-component structure is allocated per component
//              in a frame.
//
// Context:     Used by Huffman decoder to manage components.
//
// Fields:
//  ident       Component identifier.  The tables use this ident to
//              determine the correct table for each component.
//  hsampling   Horizontal subsampling factor for this component,
//              1-4 are legal.
//  vsampling   Vertical subsampling factor for this component,
//              1-4 are legal.
//  quant_sel   Quantization table selector.  The quantization table
//              used by this component is determined via this selector.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _FRAME_COMPONENT
{
  int ident;
  int hsampling;
  int vsampling;
  int quant_sel;

} FRAME_COMPONENT;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        FRAME
//
// Purpose:     Stores frame-specific data.
//
// Context:     One Frame structure per image.
//
// Fields:
//  precision       Sample precision in bits.
//  width           Width of the source image in pixels.
//  height          Height of the source image in pixels.
//  MCUheight       Height of a frame MCU.
//  MCUwidth        Width of a frame MCU.
//  max_hsampling   Max horiz sampling ratio of any component in the frame.
//  max_vsampling   Max vert sampling ratio of any component in the frame.
//  ncomps          Number of components/channels in the frame.
//  horMCU          Number of horizontal MCUs in the frame.
//  totalMCU        Total number of MCUs in the frame.
//  comps           Array of 'ncomps' component descriptors.
//  restart_interv  Indicates number of MCUs after which to restart the
//                  entropy parameters.
//  SeenAllDCScans  Used when decoding Multiscan images to determine if
//                  all channels of an image have been decoded.
//  SeenAllACScans  (See SeenAllDCScans)
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _FRAME
{
  int              precision;
  int              width;
  int              height;
  int              MCUheight;
  int              MCUwidth;
  int              max_hsampling;
  int              max_vsampling;
  int              ncomps;
  int              horMCU;
  long             totalMCU;
  FRAME_COMPONENT* comps;
  int              restart_interv;
  int              SeenAllDCScans;
  int              SeenAllACScans;

} FRAME;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        SCAN_COMPONENT
//
// Purpose:     One scan-component structure is allocated per component
//              of each scan in a frame.
//
// Context:     Used by Huffman decoder to manage components within scans.
//
// Fields:
//  comp        Component number, index to the comps member of FRAME.
//  hsampling   Horizontal sampling factor.
//  vsampling   Vertical sampling factor.
//  dc_table    DC Huffman table pointer for this scan.
//  ac_table    AC Huffman table pointer for this scan.
//  quant_table Quantization table pointer for this scan.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _SCAN_COMPONENT
{
  int            comp;
  int            hsampling;
  int            vsampling;
  HUFFMAN_TABLE* dc_table;
  HUFFMAN_TABLE* ac_table;
  QUANT_TABLE*   quant_table;

} SCAN_COMPONENT;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        SCAN
//
// Purpose:     One SCAN structure is allocated per scan in a frame.
//
// Context:     Used by Huffman decoder to manage scans.
//
// Fields:
//  ncomps          Number of image components in a scan, 1-4 legal.
//  gray_scale      If TRUE, decode only the Y channel.
//  start_spec      Start coefficient of spectral or predictor selector.
//  end_spec        End coefficient of spectral selector.
//  approx_high     High bit position in successive approximation
//                  Progressive coding.
//  approx_low      Low bit position in successive approximation
//                  Progressive coding.
//  restart_interv  Restart interval, 0 if disabled.
//  curxMCU         Next horizontal MCU index to be processed after
//                  an interrupted SCAN.
//  curyMCU         Next vertical MCU index to be processed after
//                  an interrupted SCAN.
//  dc_diff         Array of DC predictor values for DPCM modes.
//  comps           Array of ncomps SCAN_COMPONENT component identifiers.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _SCAN
{
  int             ncomps;
  int             gray_scale;
  int             start_spec;
  int             end_spec;
  int             approx_high;
  int             approx_low;
  unsigned int    restart_interv;
  int             curxMCU;
  int             curyMCU;
  int             dc_diff[4];
  SCAN_COMPONENT* comps;

} SCAN;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        DCTTYPE
//
// Purpose:     Possible algorithms to be used to perform the discrete
//              cosine transform (DCT).
//
// Fields:
//  IJL_AAN     The AAN (Arai, Agui, and Nakajima) algorithm from
//              Trans. IEICE, vol. E 71(11), 1095-1097, Nov. 1988.
//  IJL_IPP     The modified K. R. Rao and P. Yip algorithm from
//              Intel Performance Primitives Library
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _DCTTYPE
{
  IJL_AAN = 0,
  IJL_IPP = 1

} DCTTYPE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        UPSAMPLING_TYPE
//
// Purpose:            -  Possible algorithms to be used to perform upsampling
//
// Fields:
//  IJL_BOX_FILTER      - the algorithm is simple replication of the input pixel
//                        onto the corresponding output pixels (box filter);
//  IJL_TRIANGLE_FILTER - 3/4 * nearer pixel + 1/4 * further pixel in each
//                        dimension
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _UPSAMPLING_TYPE
{
  IJL_BOX_FILTER      = 0,
  IJL_TRIANGLE_FILTER = 1

} UPSAMPLING_TYPE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        SAMPLING_STATE
//
// Purpose:     Stores current conditions of sampling. Only for upsampling 
//              with triangle filter is used now.
//
// Fields:
//  top_row        - pointer to buffer with MCUs, that are located above than
//                   current row of MCUs;
//  cur_row        - pointer to buffer with current row of MCUs;
//  bottom_row     - pointer to buffer with MCUs, that are located below than
//                   current row of MCUs;
//  last_row       - pointer to bottom boundary of last row of MCUs
//  cur_row_number - number of row of MCUs, that is decoding;
//  user_interrupt - field to store jprops->interrupt, because of we prohibit 
//                   interrupts while top row of MCUs is upsampling.
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _SAMPLING_STATE
{
  short* top_row;
  short* cur_row;
  short* bottom_row;
  short* last_row;
  int    cur_row_number;

} SAMPLING_STATE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        PROCESSOR_TYPE
//
// Purpose:     Possible types of processors.
//              Note that the enums are defined in ascending order
//              depending upon their various IA32 instruction support.
//
// Fields:
//
// IJL_OTHER_PROC
//      Does not support the CPUID instruction and
//      assumes no Pentium(R) processor instructions.
//
// IJL_PENTIUM_PROC
//      Corresponds to an Intel(R) Pentium(R) processor
//      (or a 100% compatible) that supports the
//      Pentium(R) processor instructions.
//
// IJL_PENTIUM_PRO_PROC
//      Corresponds to an Intel(R) Pentium(R) Pro processor
//      (or a 100% compatible) that supports the
//      Pentium(R) Pro processor instructions.
//
// IJL_PENTIUM_PROC_MMX_TECH
//      Corresponds to an Intel(R) Pentium(R) processor
//      with MMX(TM) technology (or a 100% compatible)
//      that supports the MMX(TM) instructions.
//
// IJL_PENTIUM_II_PROC
//      Corresponds to an Intel(R) Pentium(R) II processor
//      (or a 100% compatible) that supports both the
//      Pentium(R) Pro processor instructions and the
//      MMX(TM) instructions.
//
// IJL_PENTIUM_III_PROC
//      Corresponds to an Intel(R) Pentium(R) III processor
//
// IJL_NEW_PROCESSOR
//      Correponds to new processor
//
//  Any additional processor types that support a superset
//  of both the Pentium(R) Pro processor instructions and the
//  MMX(TM) instructions should be given an enum value greater
//  than IJL_PENTIUM_III_PROC.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _PROCESSOR_TYPE
{
  IJL_OTHER_PROC            = 0,
  IJL_PENTIUM_PROC          = 1,
  IJL_PENTIUM_PRO_PROC      = 2,
  IJL_PENTIUM_PROC_MMX_TECH = 3,
  IJL_PENTIUM_II_PROC       = 4,
  IJL_PENTIUM_III_PROC      = 5,
  IJL_PENTIUM_4_PROC        = 6,
  IJL_NEW_PROCESSOR         = 7

} PROCESSOR_TYPE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        RAW_DATA_TYPES_STATE
//
// Purpose:     Stores data types: raw dct coefficients or raw sampled data.
//              Pointer to structure in JPEG_PROPERTIES is NULL, if any raw
//              data isn't request (DIBBytes!=NULL).
//
// Fields:
//  short* raw_ptrs[4] - pointers to buffers with raw data; one pointer 
//                       corresponds one JPG component;
//  data_type          - 0 - raw dct coefficients, 1 - raw sampled data.
////////////////////////////////////////////////////////////////////////////