/*M*
//
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 1998 Intel Corporation. All Rights Reserved.
//
//
//  File:
//    ijl.h
//
//  Purpose:
//    IJL Common Header File
//    This file contains:  definitions for data types, data
//    structures, error codes, and function prototypes used
//    in the Intel(R) JPEG Library (IJL).
//
//  Version:
//    1.51
//
*M*/

#ifndef __IJL_H__
#define __IJL_H__


#if defined( __cplusplus )
extern "C" {
#endif


#ifndef IJL_ALL_WARNINGS
#if defined (_WIN32)
#if _MSC_VER >= 1000

/* nonstandard extension used : nameless struct/union          */
#pragma warning(disable : 4201)
/* nonstandard extension used : bit field types other than int */
#pragma warning(disable : 4214)
/* unreferenced inline function has been removed               */
#pragma warning(disable : 4514)
/* named type definition in parentheses                        */
#pragma warning(disable : 4115)

#endif /* _MSC_VER >= 1000 */
#endif /* _WIN32 */
#endif /* IJL_ALL_WARNINGS */


#if defined (_WIN32)
#define IJL_STDCALL __stdcall
#else
#define IJL_STDCALL
#endif


/* align struct on 8 bytes boundary */
#if defined (_WIN32)
#pragma pack (8)
#else
#endif


/* /////////////////////////////////////////////////////////////////////////
// Macros/Constants */

/* Size of file I/O buffer (4K). */
#define JBUFSIZE    4096


#if defined (_WIN32)
#define IJL_INT64  __int64
#else
#define IJL_INT64  long long
#endif

#define IJL_UINT64 unsigned IJL_INT64


#ifndef IJLAPI
  #ifdef IJL_MSEXPORTS
    #define IJLAPI(type,name,arg) \
      extern __declspec(dllimport) type IJL_STDCALL name arg
  #else
    #define IJLAPI(type,name,arg) \
      extern type IJL_STDCALL name arg
  #endif
#endif



#define IJL_DIB_ALIGN (sizeof(int) - 1)

#define IJL_DIB_UWIDTH(width,nchannels) \
  ((width) * (nchannels))

#define IJL_DIB_AWIDTH(width,nchannels) \
  ( ((IJL_DIB_UWIDTH(width,nchannels) + IJL_DIB_ALIGN) & (~IJL_DIB_ALIGN)) )

#define IJL_DIB_PAD_BYTES(width,nchannels) \
  ( IJL_DIB_AWIDTH(width,nchannels) - IJL_DIB_UWIDTH(width,nchannels) )


#define IJL_DIB_SCALE_SIZE(jpgsize,scale) \
  ( ((jpgsize) + (scale) - 1) / (scale) )




/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJLibVersion
//
// Purpose:     Stores library version info.
//
// Context:
//
// Example:
//   major           - 1
//   minor           - 0
//   build           - 1
//   Name            - "ijl10.dll"
//   Version         - "1.0.1 Beta1"
//   InternalVersion - "1.0.1.1"
//   BuildDate       - "Sep 22 1998"
//   CallConv        - "DLL"
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _IJLibVersion
{
  int         major;
  int         minor;
  int         build;
  const char* Name;
  const char* Version;
  const char* InternalVersion;
  const char* BuildDate;
  const char* CallConv;

} IJLibVersion;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_RECT
//
// Purpose:     Keep coordinates for rectangle region of image
//
// Context:     Used to specify roi
//
// Fields:
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _IJL_RECT
{
  long  left;
  long  top;
  long  right;
  long  bottom;

} IJL_RECT;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_HANDLE
//
// Purpose:     file handle
//
// Context:     used internally
//
// Fields:
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef void* IJL_HANDLE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJLIOTYPE
//
// Purpose:     Possible types of data read/write/other operations to be
//              performed by the functions IJL_Read and IJL_Write.
//
//              See the Developer's Guide for details on appropriate usage.
//
// Fields:
//
//  IJL_JFILE_XXXXXXX   Indicates JPEG data in a stdio file.
//
//  IJL_JBUFF_XXXXXXX   Indicates JPEG data in an addressable buffer.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _IJLIOTYPE
{
  IJL_SETUP                   = -1,


  /* Read JPEG parameters (i.e., height, width, channels, sampling, etc.) */
  /* from a JPEG bit stream. */
  IJL_JFILE_READPARAMS        =  0,
  IJL_JBUFF_READPARAMS        =  1,

  /* Read a JPEG Interchange Format image. */
  IJL_JFILE_READWHOLEIMAGE    =  2,
  IJL_JBUFF_READWHOLEIMAGE    =  3,

  /* Read JPEG tables from a JPEG Abbreviated Format bit stream. */
  IJL_JFILE_READHEADER        =  4,
  IJL_JBUFF_READHEADER        =  5,

  /* Read image info from a JPEG Abbreviated Format bit stream. */
  IJL_JFILE_READENTROPY       =  6,
  IJL_JBUFF_READENTROPY       =  7,

  /* Write an entire JFIF bit stream. */
  IJL_JFILE_WRITEWHOLEIMAGE   =  8,
  IJL_JBUFF_WRITEWHOLEIMAGE   =  9,

  /* Write a JPEG Abbreviated Format bit stream. */
  IJL_JFILE_WRITEHEADER       = 10,
  IJL_JBUFF_WRITEHEADER       = 11,

  /* Write image info to a JPEG Abbreviated Format bit stream. */
  IJL_JFILE_WRITEENTROPY      = 12,
  IJL_JBUFF_WRITEENTROPY      = 13,


  /* Scaled Decoding Options: */

  /* Reads a JPEG image scaled to 1/2 size. */
  IJL_JFILE_READONEHALF       = 14,
  IJL_JBUFF_READONEHALF       = 15,

  /* Reads a JPEG image scaled to 1/4 size. */
  IJL_JFILE_READONEQUARTER    = 16,
  IJL_JBUFF_READONEQUARTER    = 17,

  /* Reads a JPEG image scaled to 1/8 size. */
  IJL_JFILE_READONEEIGHTH     = 18,
  IJL_JBUFF_READONEEIGHTH     = 19,

  /* Reads an embedded thumbnail from a JFIF bit stream. */
  IJL_JFILE_READTHUMBNAIL     = 20,
  IJL_JBUFF_READTHUMBNAIL     = 21

} IJLIOTYPE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_COLOR
//
// Purpose:     Possible color space formats.
//
//              Note these formats do *not* necessarily denote
//              the number of channels in the color space.
//              There exists separate "channel" fields in the
//              JPEG_CORE_PROPERTIES data structure specifically
//              for indicating the number of channels in the
//              JPEG and/or DIB color spaces.
//
//              See the Developer's Guide for details on appropriate usage.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _IJL_COLOR
{
  IJL_RGB         = 1,    /* Red-Green-Blue color space. */
  IJL_BGR         = 2,    /* Reversed channel ordering from IJL_RGB. */
  IJL_YCBCR       = 3,    /* Luminance-Chrominance color space as defined */
                          /* by CCIR Recommendation 601. */
  IJL_G           = 4,    /* Grayscale color space. */
  IJL_RGBA_FPX    = 5,    /* FlashPix RGB 4 channel color space that */
                          /* has pre-multiplied opacity. */
  IJL_YCBCRA_FPX  = 6,    /* FlashPix YCbCr 4 channel color space that */
                          /* has pre-multiplied opacity. */

  IJL_OTHER       = 255   /* Some other color space not defined by the IJL. */
                          /* (This means no color space conversion will */
                          /* be done by the IJL.) */

} IJL_COLOR;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_JPGSUBSAMPLING
//
// Purpose:     Possible subsampling formats used in the JPEG.
//
//              See the Developer's Guide for details on appropriate usage.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _IJL_JPGSUBSAMPLING
{
  IJL_NONE    = 0,    /* Corresponds to "No Subsampling". */
                      /* Valid on a JPEG w/ any number of channels. */
  IJL_411     = 1,    /* Valid on a JPEG w/ 3 channels. */
  IJL_422     = 2,    /* Valid on a JPEG w/ 3 channels. */

  IJL_4114    = 3,    /* Valid on a JPEG w/ 4 channels. */
  IJL_4224    = 4     /* Valid on a JPEG w/ 4 channels. */

} IJL_JPGSUBSAMPLING;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_DIBSUBSAMPLING
//
// Purpose:     Possible subsampling formats used in the DIB.
//
//              See the Developer's Guide for details on appropriate usage.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef IJL_JPGSUBSAMPLING IJL_DIBSUBSAMPLING;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        HUFFMAN_TABLE
//
// Purpose:     Stores Huffman table information in a fast-to-use format.
//
// Context:     Used by Huffman encoder/decoder to access Huffman table
//              data.  Raw Huffman tables are formatted to fit this
//              structure prior to use.
//
// Fields:
//  huff_class  0 == DC Huffman or lossless table, 1 == AC table.
//  ident       Huffman table identifier, 0-3 valid (Extended Baseline).
//  huffelem    Huffman elements for codes <= 8 bits long;
//              contains both zero run-length and symbol length in bits.
//  huffval     Huffman values for codes 9-16 bits in length.
//  mincode     Smallest Huffman code of length n.
//  maxcode     Largest Huffman code of length n.
//  valptr      Starting index into huffval[] for symbols of length k.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _HUFFMAN_TABLE
{
  int             huff_class;
  int             ident;
  unsigned int    huffelem[256];
  unsigned short  huffval[256];
  unsigned short  mincode[17];
  short           maxcode[18];
  unsigned short  valptr[17];

} HUFFMAN_TABLE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        JPEGHuffTable
//
// Purpose:     Stores pointers to JPEG-binary spec compliant
//              Huffman table information.
//
// Context:     Used by interface and table methods to specify encoder
//              tables to generate and store JPEG images.
//
// Fields:
//  bits        Points to number of codes of length i (<=16 supported).
//  vals        Value associated with each Huffman code.
//  hclass      0 == DC table, 1 == AC table.
//  ident       Specifies the identifier for this table.
//              0-3 for extended JPEG compliance.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _JPEGHuffTable
{
  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_PENTIUM_4_PROC
//      Corresponds to an Intel(R) Pentium(R) 4 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_4_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.
////////////////////////////////////////////////////////////////////////////
*D*/
typedef struct _RAW_DATA_TYPES_STATE
{
  int data_type;
  unsigned short* raw_ptrs[4];

} RAW_DATA_TYPES_STATE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        ENTROPYSTRUCT
//
// Purpose:     Stores the decoder state information necessary to "jump"
//              to a particular MCU row in a compressed entropy stream.
//
// Context:     Used to persist the decoder state within Decode_Scan when
//              decoding using ROIs.
//
// Fields:
//      offset              Offset (in bytes) into the entropy stream
//                          from the beginning.
//      dcval1              DC val at the beginning of the MCU row
//                          for component 1.
//      dcval2              DC val at the beginning of the MCU row
//                          for component 2.
//      dcval3              DC val at the beginning of the MCU row
//                          for component 3.
//      dcval4              DC val at the beginning of the MCU row
//                          for component 4.
//      bit_buffer_64       64-bit Huffman bit buffer.  Stores current
//                          bit buffer at the start of a MCU row.
//                          Also used as a 32-bit buffer on 32-bit
//                          architectures.
//      bitbuf_bits_valid   Number of valid bits in the above bit buffer.
//      unread_marker       Have any markers been decoded but not
//                          processed at the beginning of a MCU row?
//                          This entry holds the unprocessed marker, or
//                          0 if none.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _ENTROPYSTRUCT
{
  unsigned int   offset;
  int            dcval1;
  int            dcval2;
  int            dcval3;
  int            dcval4;
  IJL_UINT64     bit_buffer_64;
  int            bitbuf_bits_valid;
  unsigned char  unread_marker;

} ENTROPYSTRUCT;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        STATE
//
// Purpose:     Stores the active state of the IJL.
//
// Context:     Used by all low-level routines to store pseudo-global or
//              state variables.
//
// Fields:
//      bit_buffer_64           64-bit bitbuffer utilized by Huffman
//                              encoder/decoder algorithms utilizing routines
//                              designed for MMX(TM) technology.
//      bit_buffer_32           32-bit bitbuffer for all other Huffman
//                              encoder/decoder algorithms.
//      bitbuf_bits_valid       Number of bits in the above two fields that
//                              are valid.
//
//      cur_entropy_ptr         Current position (absolute address) in
//                              the entropy buffer.
//      start_entropy_ptr       Starting position (absolute address) of
//                              the entropy buffer.
//      end_entropy_ptr         Ending position (absolute address) of
//                              the entropy buffer.
//      entropy_bytes_processed Number of bytes actually processed
//                              (passed over) in the entropy buffer.
//      entropy_buf_maxsize     Max size of the entropy buffer.
//      entropy_bytes_left      Number of bytes left in the entropy buffer.
//      Prog_EndOfBlock_Run     Progressive block run counter.
//
//      DIB_ptr                 Temporary offset into the input/output DIB.
//
//      unread_marker           If a marker has been read but not processed,
//                              stick it in this field.
//      processor_type          (0, 1, or 2) == current processor does not
//                              support MMX(TM) instructions.
//                              (3 or 4) == current processor does
//                              support MMX(TM) instructions.
//      cur_scan_comp           On which component of the scan are we working?
//      file                    Process file handle, or
//                              0x00000000 if no file is defined.
//      JPGBuffer               Entropy buffer (~4K).
//
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _STATE
{
  /* Bit buffer. */
  IJL_UINT64     bit_buffer_64;
  void*          ctx;
  int            bitbuf_bits_valid;

  /* Entropy. */
  unsigned char* cur_entropy_ptr;
  unsigned char* start_entropy_ptr;
  unsigned char* end_entropy_ptr;
  int            entropy_bytes_processed;
  int            entropy_buf_maxsize;
  int            entropy_bytes_left;
  int            Prog_EndOfBlock_Run;

  /* Input or output DIB. */
  unsigned char* DIB_ptr;

  /* Control. */
  unsigned char  unread_marker;
  PROCESSOR_TYPE processor_type;
  int            cur_scan_comp;
  IJL_HANDLE     file;
  unsigned char  JPGBuffer [JBUFSIZE];

} STATE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        FAST_MCU_PROCESSING_TYPE
//
// Purpose:     Advanced Control Option.  Do NOT modify.
//              WARNING:  Used for internal reference only.
//
// Fields:
//
//   IJL_(sampling)_(JPEG color space)_(sampling)_(DIB color space)
//      Decode is read left to right w/ upsampling.
//      Encode is read right to left w/ subsampling.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _FAST_MCU_PROCESSING_TYPE
{
  IJL_NO_CC_OR_US                   = 0,

  IJL_111_YCBCR_111_RGB             = 1,
  IJL_111_YCBCR_111_BGR             = 2,

  IJL_411_YCBCR_111_RGB             = 3,
  IJL_411_YCBCR_111_BGR             = 4,

  IJL_422_YCBCR_111_RGB             = 5,
  IJL_422_YCBCR_111_BGR             = 6,

  IJL_111_YCBCR_1111_RGBA_FPX       = 7,
  IJL_411_YCBCR_1111_RGBA_FPX       = 8,
  IJL_422_YCBCR_1111_RGBA_FPX       = 9,

  IJL_1111_YCBCRA_FPX_1111_RGBA_FPX = 10,
  IJL_4114_YCBCRA_FPX_1111_RGBA_FPX = 11,
  IJL_4224_YCBCRA_FPX_1111_RGBA_FPX = 12,

  IJL_111_RGB_1111_RGBA_FPX         = 13,

  IJL_1111_RGBA_FPX_1111_RGBA_FPX   = 14,

  IJL_111_OTHER_111_OTHER           = 15,
  IJL_411_OTHER_111_OTHER           = 16,
  IJL_422_OTHER_111_OTHER           = 17,

  IJL_YCBYCR_YCBCR                  = 18,
  IJL_YCBCR_YCBYCR                  = 19,

  IJL_1_G_1_G                       = 20

} FAST_MCU_PROCESSING_TYPE;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        JPEG_PROPERTIES
//
// Purpose:     Stores low-level and control information.  It is used by
//              both the encoder and decoder.  An advanced external user
//              may access this structure to expand the interface
//              capability.
//
//              See the Developer's Guide for an expanded description
//              of this structure and its use.
//
// Context:     Used by all interface methods and most IJL routines.
//
// Fields:
//
//  iotype              IN:     Specifies type of data operation
//                              (read/write/other) to be
//                              performed by IJL_Read or IJL_Write.
//  roi                 IN:     Rectangle-Of-Interest to read from, or
//                              write to, in pixels.
//  dcttype             IN:     DCT alogrithm to be used.
//  fast_processing     OUT:    Supported fast pre/post-processing path.
//                              This is set by the IJL.
//  interrupt           IN:     Signals an interrupt has been requested.
//
//  DIBBytes            IN:     Pointer to buffer of uncompressed data.
//  DIBWidth            IN:     Width of uncompressed data.
//  DIBHeight           IN:     Height of uncompressed data.
//  DIBPadBytes         IN:     Padding (in bytes) at end of each
//                              row in the uncompressed data.
//  DIBChannels         IN:     Number of components in the
//                              uncompressed data.
//  DIBColor            IN:     Color space of uncompressed data.
//  DIBSubsampling      IN:     Required to be IJL_NONE or IJL_422.
//  DIBLineBytes        OUT:    Number of bytes in an output DIB line
//                              including padding.
//
//  JPGFile             IN:     Pointer to file based JPEG.
//  JPGBytes            IN:     Pointer to buffer based JPEG.
//  JPGSizeBytes        IN:     Max buffer size. Used with JPGBytes.
//                      OUT:    Number of compressed bytes written.
//  JPGWidth            IN:     Width of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGHeight           IN:     Height of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGChannels         IN:     Number of components in JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGColor            IN:     Color space of JPEG image.
//  JPGSubsampling      IN:     Subsampling of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGThumbWidth       OUT:    JFIF embedded thumbnail width [0-255].
//  JPGThumbHeight      OUT:    JFIF embedded thumbnail height [0-255].
//
//  cconversion_reqd    OUT:    If color conversion done on decode, TRUE.
//  upsampling_reqd     OUT:    If upsampling done on decode, TRUE.
//  jquality            IN:     [0-100] where highest quality is 100.
//  jinterleaveType     IN/OUT: 0 => MCU interleaved file, and
//                              1 => 1 scan per component.
//  numxMCUs            OUT:    Number of MCUs in the x direction.
//  numyMCUs            OUT:    Number of MCUs in the y direction.
//
//  nqtables            IN/OUT: Number of quantization tables.
//  maxquantindex       IN/OUT: Maximum index of quantization tables.
//  nhuffActables       IN/OUT: Number of AC Huffman tables.
//  nhuffDctables       IN/OUT: Number of DC Huffman tables.
//  maxhuffindex        IN/OUT: Maximum index of Huffman tables.
//  jFmtQuant           IN/OUT: Formatted quantization table info.
//  jFmtAcHuffman       IN/OUT: Formatted AC Huffman table info.
//  jFmtDcHuffman       IN/OUT: Formatted DC Huffman table info.
//
//  jEncFmtQuant        IN/OUT: Pointer to one of the above, or
//                              to externally persisted table.
//  jEncFmtAcHuffman    IN/OUT: Pointer to one of the above, or
//                              to externally persisted table.
//  jEncFmtDcHuffman    IN/OUT: Pointer to one of the above, or
//                              to externally persisted table.
//
//  use_default_qtables IN:     Set to default quantization tables.
//                              Clear to supply your own.
//  use_default_htables IN:     Set to default Huffman tables.
//                              Clear to supply your own.
//  rawquanttables      IN:     Up to 4 sets of quantization tables.
//  rawhufftables       IN:     Alternating pairs (DC/AC) of up to 4
//                              sets of raw Huffman tables.
//  HuffIdentifierAC    IN:     Indicates what channel the user-
//                              supplied Huffman AC tables apply to.
//  HuffIdentifierDC    IN:     Indicates what channel the user-
//                              supplied Huffman DC tables apply to.
//
//  jframe              OUT:    Structure with frame-specific info.
//  needframe           OUT:    TRUE when a frame has been detected.
//
//  jscan               Persistence for current scan pointer when
//                      interrupted.
//
//  state               OUT:    Contains info on the state of the IJL.
//  SawAdobeMarker      OUT:    Decoder saw an APP14 marker somewhere.
//  AdobeXform          OUT:    If SawAdobeMarker TRUE, this indicates
//                              the JPEG color space given by that marker.
//
//  rowoffsets          Persistence for the decoder MCU row origins
//                      when decoding by ROI.  Offsets (in bytes
//                      from the beginning of the entropy data)
//                      to the start of each of the decoded rows.
//                      Fill the offsets with -1 if they have not
//                      been initalized and NULL could be the
//                      offset to the first row.
//
//  MCUBuf              OUT:    Quadword aligned internal buffer.
//                              Big enough for the largest MCU
//                              (10 blocks) with extra room for
//                              additional operations.
//  tMCUBuf             OUT:    Version of above, without alignment.
//
//  processor_type      OUT:    Determines type of processor found
//                              during initialization.
//
//  raw_coefs           IN:     Place to hold pointers to raw data buffers or
//                              raw DCT coefficients buffers
//
//  progressive_found   OUT:    1 when progressive image detected.
//  coef_buffer         IN:     Pointer to a larger buffer containing
//                              frequency coefficients when they
//                              cannot be decoded dynamically
//                              (i.e., as in progressive decoding).
//
//  upsampling_type     IN:     Type of sampling:
//                              IJL_BOX_FILTER or IJL_TRIANGLE_FILTER.
//  SAMPLING_STATE*    OUT:     pointer to structure, describing current
//                              condition of upsampling
//
//  AdobeVersion       OUT      version field, if Adobe APP14 marker detected
//  AdobeFlags0        OUT      flags0 field, if Adobe APP14 marker detected
//  AdobeFlags1        OUT      flags1 field, if Adobe APP14 marker detected
//
//  jfif_app0_detected OUT:     1 - if JFIF APP0 marker detected,  
//                              0 - if not
//  jfif_app0_version  IN/OUT   The JFIF file version
//  jfif_app0_units    IN/OUT   units for the X and Y densities
//                              0 - no units, X and Y specify
//                                  the pixel aspect ratio
//                              1 - X and Y are dots per inch
//                              2 - X and Y are dots per cm
//  jfif_app0_Xdensity IN/OUT   horizontal pixel density
//  jfif_app0_Ydensity IN/OUT   vertical pixel density
//
//  jpeg_comment       IN       pointer to JPEG comments
//  jpeg_comment_size  IN/OUT   size of JPEG comments, in bytes
//
//  raw_coefs          IN/OUT   if !NULL, then pointer to vector of pointers
//                              (size = JPGChannels) to buffers for raw (short)
//                              dct coefficients. 1 pointer corresponds to one
//                              component;
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _JPEG_PROPERTIES
{
  /* Compression/Decompression control. */
  IJLIOTYPE                iotype;               /* default = IJL_SETUP */
  IJL_RECT                 roi;                  /* default = 0 */
  DCTTYPE                  dcttype;              /* default = IJL_AAN */
  FAST_MCU_PROCESSING_TYPE fast_processing;      /* default = IJL_NO_CC_OR_US */
  int                      interrupt;            /* default = FALSE */

  /* DIB specific I/O data specifiers. */
  unsigned char*           DIBBytes;             /* default = NULL */
  int                      DIBWidth;             /* default = 0 */
  int                      DIBHeight;            /* default = 0 */
  int                      DIBPadBytes;          /* default = 0 */
  int                      DIBChannels;          /* default = 3 */
  IJL_COLOR                DIBColor;             /* default = IJL_BGR */
  IJL_DIBSUBSAMPLING       DIBSubsampling;       /* default = IJL_NONE */
  int                      DIBLineBytes;         /* default = 0 */

  /* JPEG specific I/O data specifiers. */
  const char*              JPGFile;              /* default = NULL */
  unsigned char*           JPGBytes;             /* default = NULL */
  int                      JPGSizeBytes;         /* default = 0 */
  int                      JPGWidth;             /* default = 0 */
  int                      JPGHeight;            /* default = 0 */
  int                      JPGChannels;          /* default = 3 */
  IJL_COLOR                JPGColor;             /* default = IJL_YCBCR */
  IJL_JPGSUBSAMPLING       JPGSubsampling;       /* default = IJL_411 */
  int                      JPGThumbWidth;        /* default = 0 */
  int                      JPGThumbHeight;       /* default = 0 */

  /* JPEG conversion properties. */
  int                      cconversion_reqd;     /* default = TRUE */
  int                      upsampling_reqd;      /* default = TRUE */
  int                      jquality;             /* default = 75 */
  int                      jinterleaveType;      /* default = 0 */
  int                      numxMCUs;             /* default = 0 */
  int                      numyMCUs;             /* default = 0 */

  /* Tables. */
  int                      nqtables;
  int                      maxquantindex;
  int                      nhuffActables;
  int                      nhuffDctables;
  int                      maxhuffindex;

  QUANT_TABLE              jFmtQuant[4];
  HUFFMAN_TABLE            jFmtAcHuffman[4];
  HUFFMAN_TABLE            jFmtDcHuffman[4];

  short*                   jEncFmtQuant[4];
  HUFFMAN_TABLE*           jEncFmtAcHuffman[4];
  HUFFMAN_TABLE*           jEncFmtDcHuffman[4];

  /* Allow user-defined tables. */
  int                      use_external_qtables;
  int                      use_external_htables;

  JPEGQuantTable           rawquanttables[4];
  JPEGHuffTable            rawhufftables[8];
  char                     HuffIdentifierAC[4];
  char                     HuffIdentifierDC[4];

  /* Frame specific members. */
  FRAME                    jframe;
  int                      needframe;

  /* SCAN persistent members. */
  SCAN*                    jscan;

  /* State members. */
  STATE                    state;
  int                      SawAdobeMarker;
  int                      AdobeXform;

  /* ROI decoder members. */
  ENTROPYSTRUCT*           rowoffsets;

  /* Intermediate buffers. */
  unsigned char*           MCUBuf;
  unsigned char            tMCUBuf[720*2];

  /* Processor detected. */
  PROCESSOR_TYPE           processor_type;

  RAW_DATA_TYPES_STATE*    raw_coefs;

  /* Progressive mode members. */
  int                      progressive_found;
  short*                   coef_buffer;

  /* Upsampling mode members. */
  UPSAMPLING_TYPE          upsampling_type;
  SAMPLING_STATE*          sampling_state_ptr;

  /* Adobe APP14 segment variables */
  unsigned short           AdobeVersion;         /* default = 100 */
  unsigned short           AdobeFlags0;          /* default = 0 */
  unsigned short           AdobeFlags1;          /* default = 0 */

  /* JFIF APP0 segment variables */
  int                      jfif_app0_detected;
  unsigned short           jfif_app0_version;    /* default = 0x0101 */
  unsigned char            jfif_app0_units;      /* default = 0 - pixel */
  unsigned short           jfif_app0_Xdensity;   /* default = 1 */
  unsigned short           jfif_app0_Ydensity;   /* default = 1 */

  /* comments related fields */
  char*                    jpeg_comment;         /* default = NULL */
  unsigned short           jpeg_comment_size;    /* default = 0 */

} JPEG_PROPERTIES;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        JPEG_CORE_PROPERTIES
//
// Purpose:     This is the primary data structure between the IJL and
//              the external user.  It stores JPEG state information
//              and controls the IJL.  It is user-modifiable.
//
//              See the Developer's Guide for details on appropriate usage.
//
// Context:     Used by all low-level IJL routines to store
//              pseudo-global information.
//
// Fields:
//
//  UseJPEGPROPERTIES   Set this flag != 0 if you wish to override
//                      the JPEG_CORE_PROPERTIES "IN" parameters with
//                      the JPEG_PROPERTIES parameters.
//
//  DIBBytes            IN:     Pointer to buffer of uncompressed data.
//  DIBWidth            IN:     Width of uncompressed data.
//  DIBHeight           IN:     Height of uncompressed data.
//  DIBPadBytes         IN:     Padding (in bytes) at end of each
//                              row in the uncompressed data.
//  DIBChannels         IN:     Number of components in the
//                              uncompressed data.
//  DIBColor            IN:     Color space of uncompressed data.
//  DIBSubsampling      IN:     Required to be IJL_NONE or IJL_422.
//
//  JPGFile             IN:     Pointer to file based JPEG.
//  JPGBytes            IN:     Pointer to buffer based JPEG.
//  JPGSizeBytes        IN:     Max buffer size. Used with JPGBytes.
//                      OUT:    Number of compressed bytes written.
//  JPGWidth            IN:     Width of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGHeight           IN:     Height of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGChannels         IN:     Number of components in JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGColor            IN:     Color space of JPEG image.
//  JPGSubsampling      IN:     Subsampling of JPEG image.
//                      OUT:    After reading (except READHEADER).
//  JPGThumbWidth       OUT:    JFIF embedded thumbnail width [0-255].
//  JPGThumbHeight      OUT:    JFIF embedded thumbnail height [0-255].
//
//  cconversion_reqd    OUT:    If color conversion done on decode, TRUE.
//  upsampling_reqd     OUT:    If upsampling done on decode, TRUE.
//  jquality            IN:     [0-100] where highest quality is 100.
//
//  jprops              "Low-Level" IJL data structure.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef struct _JPEG_CORE_PROPERTIES
{
  int                UseJPEGPROPERTIES;         /* default = 0 */

  /* DIB specific I/O data specifiers. */
  unsigned char*     DIBBytes;                  /* default = NULL */
  int                DIBWidth;                  /* default = 0 */
  int                DIBHeight;                 /* default = 0 */
  int                DIBPadBytes;               /* default = 0 */
  int                DIBChannels;               /* default = 3 */
  IJL_COLOR          DIBColor;                  /* default = IJL_BGR */
  IJL_DIBSUBSAMPLING DIBSubsampling;            /* default = IJL_NONE */

  /* JPEG specific I/O data specifiers. */
  const char*        JPGFile;                   /* default = NULL */
  unsigned char*     JPGBytes;                  /* default = NULL */
  int                JPGSizeBytes;              /* default = 0 */
  int                JPGWidth;                  /* default = 0 */
  int                JPGHeight;                 /* default = 0 */
  int                JPGChannels;               /* default = 3 */
  IJL_COLOR          JPGColor;                  /* default = IJL_YCBCR */
  IJL_JPGSUBSAMPLING JPGSubsampling;            /* default = IJL_411 */
  int                JPGThumbWidth;             /* default = 0 */
  int                JPGThumbHeight;            /* default = 0 */

  /* JPEG conversion properties. */
  int                cconversion_reqd;          /* default = TRUE */
  int                upsampling_reqd;           /* default = TRUE */
  int                jquality;                  /* default = 75 */

  /* Low-level properties. */
  JPEG_PROPERTIES    jprops;

} JPEG_CORE_PROPERTIES;


/*D*
////////////////////////////////////////////////////////////////////////////
// Name:        IJLERR
//
// Purpose:     Listing of possible "error" codes returned by the IJL.
//
//              See the Developer's Guide for details on appropriate usage.
//
// Context:     Used for error checking.
//
////////////////////////////////////////////////////////////////////////////
*D*/

typedef enum _IJLERR
{
  /* The following "error" values indicate an "OK" condition. */
  IJL_OK                          = 0,
  IJL_INTERRUPT_OK                = 1,
  IJL_ROI_OK                      = 2,

  /* The following "error" values indicate an error has occurred. */
  IJL_EXCEPTION_DETECTED          =  -1,
  IJL_INVALID_ENCODER             =  -2,
  IJL_UNSUPPORTED_SUBSAMPLING     =  -3,
  IJL_UNSUPPORTED_BYTES_PER_PIXEL =  -4,
  IJL_MEMORY_ERROR                =  -5,
  IJL_BAD_HUFFMAN_TABLE           =  -6,
  IJL_BAD_QUANT_TABLE             =  -7,
  IJL_INVALID_JPEG_PROPERTIES     =  -8,
  IJL_ERR_FILECLOSE               =  -9,
  IJL_INVALID_FILENAME            = -10,
  IJL_ERROR_EOF                   = -11,
  IJL_PROG_NOT_SUPPORTED          = -12,
  IJL_ERR_NOT_JPEG                = -13,
  IJL_ERR_COMP                    = -14,
  IJL_ERR_SOF                     = -15,
  IJL_ERR_DNL                     = -16,
  IJL_ERR_NO_HUF                  = -17,
  IJL_ERR_NO_QUAN                 = -18,
  IJL_ERR_NO_FRAME                = -19,
  IJL_ERR_MULT_FRAME              = -20,
  IJL_ERR_DATA                    = -21,
  IJL_ERR_NO_IMAGE                = -22,
  IJL_FILE_ERROR                  = -23,
  IJL_INTERNAL_ERROR              = -24,
  IJL_BAD_RST_MARKER              = -25,
  IJL_THUMBNAIL_DIB_TOO_SMALL     = -26,
  IJL_THUMBNAIL_DIB_WRONG_COLOR   = -27,
  IJL_BUFFER_TOO_SMALL            = -28,
  IJL_UNSUPPORTED_FRAME           = -29,
  IJL_ERR_COM_BUFFER              = -30,
  IJL_RESERVED                    = -99

} IJLERR;




/* /////////////////////////////////////////////////////////////////////////
//                     Function Prototypes (API Calls)                    //
///////////////////////////////////////////////////////////////////////// */


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        ijlInit
//
// Purpose:     Used to initalize the IJL.
//
//              See the Developer's Guide for details on appropriate usage.
//
// Context:     Always call this before anything else.
//              Also, only call this with a new jcprops structure, or
//              after calling IJL_Free.  Otherwise, dynamically
//              allocated memory may be leaked.
//
// Returns:     Any IJLERR value.  IJL_OK indicates success.
//
// Parameters:
//  jcprops     Pointer to an externally allocated
//              JPEG_CORE_PROPERTIES structure.
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(IJLERR, ijlInit, ( JPEG_CORE_PROPERTIES* jcprops ));


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        ijlFree
//
// Purpose:     Used to properly close down the IJL.
//
//              See the Developer's Guide for details on appropriate usage.
//
// Context:     Always call this when done using the IJL to perform
//              clean-up of dynamically allocated memory.
//              Note, IJL_Init will have to be called to use the
//              IJL again.
//
// Returns:     Any IJLERR value.  IJL_OK indicates success.
//
// Parameters:
//  jcprops     Pointer to an externally allocated
//              JPEG_CORE_PROPERTIES structure.
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(IJLERR, ijlFree, ( JPEG_CORE_PROPERTIES* jcprops ));


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        IJL_Read
//
// Purpose:     Used to read JPEG data (entropy, or header, or both) into
//              a user-supplied buffer (to hold the image data) and/or
//              into the JPEG_CORE_PROPERTIES structure (to hold the
//              header info).
//
// Context:     See the Developer's Guide for a detailed description
//              on the use of this function.  The jcprops main data
//              members are checked for consistency.
//
// Returns:     Any IJLERR value.  IJL_OK indicates success.
//
// Parameters:
//  jcprops     Pointer to an externally allocated
//              JPEG_CORE_PROPERTIES structure.
//  iotype      Specifies what type of read operation to perform.
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(IJLERR, ijlRead, ( JPEG_CORE_PROPERTIES* jcprops, IJLIOTYPE iotype ));


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        ijlWrite
//
// Purpose:     Used to write JPEG data (entropy, or header, or both) into
//              a user-supplied buffer (to hold the image data) and/or
//              into the JPEG_CORE_PROPERTIES structure (to hold the
//              header info).
//
// Context:     See the Developer's Guide for a detailed description
//              on the use of this function.  The jcprops main data
//              members are checked for consistency.
//
// Returns:     Any IJLERR value.  IJL_OK indicates success.
//
// Parameters:
//  jcprops     Pointer to an externally allocated
//              JPEG_CORE_PROPERTIES structure.
//  iotype      Specifies what type of write operation to perform.
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(IJLERR, ijlWrite, ( JPEG_CORE_PROPERTIES* jcprops, IJLIOTYPE iotype ));


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        ijlGetLibVersion
//
// Purpose:     To identify the version number of the IJL.
//
// Context:     Call to get the IJL version number.
//
// Returns:     pointer to IJLibVersion struct
//
// Parameters:  none
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(const IJLibVersion*, ijlGetLibVersion, (void));


/*F*
////////////////////////////////////////////////////////////////////////////
// Name:        ijlErrorStr
//
// Purpose:     Gets the string to describe error code.
//
// Context:     Is called to get descriptive string on arbitrary IJLERR code.
//
// Returns:     pointer to string
//
// Parameters:  IJLERR - IJL error code
//
////////////////////////////////////////////////////////////////////////////
*F*/

IJLAPI(const char*, ijlErrorStr, (IJLERR code));




#if defined( __cplusplus )
}
#endif

#endif  /* __IJL_H__ */
