path: root/baseline/source/cjpeg_transupp/jpeglib.h

/*

  This program is part of the TACLeBench benchmark suite.
  Version V 2.0

  Name: jpeglib

  Author: Thomas G. Lane

  Function: This file defines the application interface for the JPEG library.
    Most applications using the library need only include this file, and perhaps
    jerror.h if they want to know the exact error codes.

  Source: MediaBench II
          http://euler.slu.edu/~fritts/mediabench (mirror)

  Original name: cjpeg

  Changes: No major functional changes.

  License: See the accompanying README file.

*/


#ifndef JPEGLIB_H
#define JPEGLIB_H

/*
  Various constants determining the sizes of things.
  All of these are specified by the JPEG standard, so don't change them if you
  want to be compatible.
*/

/* The basic DCT block is 8x8 samples */
#define DCTSIZE       8

/* DCTSIZE squared; # of elements in a block */
#define DCTSIZE2      64


/*
  Data structures for images (arrays of samples and of DCT coefficients).
  On 80x86 machines, the image arrays are too big for near pointers, but the
  pointer arrays can fit in near memory.
*/

/* ptr to one image row of pixel samples. */
typedef unsigned char *JSAMPROW;

/* ptr to some rows (a 2-D sample array) */
typedef JSAMPROW *JSAMPARRAY;

/* one block of coefficients */
typedef signed char JBLOCK[DCTSIZE2];

/* pointer to one row of coefficient blocks */
typedef JBLOCK *JBLOCKROW;

/* a 2-D array of coefficient blocks */
typedef JBLOCKROW *JBLOCKARRAY;

/* useful in a couple of places */
typedef signed char *JCOEFPTR;


/*
  DCT coefficient quantization tables.
*/

typedef struct {
  /* quantization step for each coefficient */
  /*
    This array gives the coefficient quantizers in natural array order (not the
    zigzag order in which they are stored in a JPEG DQT marker).
    CAUTION: IJG versions prior to v6a kept this array in zigzag order.
  */
  unsigned short quantval[ DCTSIZE2 ];

  /* 1 when table has been output */
  /*
    This field is used only during compression. It's initialized 0 when the
    table is created, and set 1 when it's been output to the file. You could
    suppress output of a table by setting this to 1. (See jpeg_suppress_tables
    for an example.)
  */
  int sent_table;
} JQUANT_TBL;


/*
 Huffman coding tables.
*/

typedef struct {
  /* These two fields directly represent the contents of a JPEG DHT marker */

  /* bits[k] = # of symbols with codes of */
  /* length k bits; bits[0] is unused */
  unsigned char bits[ 17 ];

  /* The symbols, in order of incr code length */
  /*
    This field is used only during compression. It's initialized 0 when the
    table is created, and set 1 when it's been output to the file. You could
    suppress output of a table by setting this to 1. (See jpeg_suppress_tables
    for an example.)
  */
  unsigned char huffval[ 256 ];

  /* 1 when table has been output */
  int sent_table;
} JHUFF_TBL;


/*
 Basic info about one component (color channel).
*/

typedef struct {
  /*
    These values are fixed over the whole image. For compression, they must be
    supplied by parameter setup; for decompression, they are read from the SOF
    marker.
  */

  /* identifier for this component (0..255) */
  int component_id;

  /* its index in SOF or cinfo->comp_info[] */
  int component_index;

  /* horizontal sampling factor (1..4) */
  int h_samp_factor;

  /* vertical sampling factor (1..4) */
  int v_samp_factor;

  /* quantization table selector (0..3) */
  int quant_tbl_no;

  /*
    These values may vary between scans. For compression, they must be supplied
    by parameter setup; for decompression, they are read from the SOS marker.
    The decompressor output side may not use these variables.
  */

  /* DC entropy table selector (0..3) */
  int dc_tbl_no;

  /* AC entropy table selector (0..3) */
  int ac_tbl_no;

  /* Remaining fields should be treated as private by applications. */

  /*
    These values are computed during compression or decompression startup:
    Component's size in DCT blocks. Any dummy blocks added to complete an MCU
    are not counted; therefore these values do not depend on whether a scan is
    interleaved or not.
  */
  unsigned int width_in_blocks;
  unsigned int height_in_blocks;

  /*
    Size of a DCT block in samples. Always DCTSIZE for compression. For
    decompression this is the size of the output from one DCT block, reflecting
    any scaling we choose to apply during the IDCT step. Values of 1,2,4,8 are
    likely to be supported. Note that different components may receive different
    IDCT scalings.
  */
  int DCT_scaled_size;

  /*
    The downsampled dimensions are the component's actual, unpadded number of
    samples at the main buffer (preprocessing/compression interface), thus
    downsampled_width = ceil(image_width * Hi/Hmax) and similarly for height.
    For decompression, IDCT scaling is included, so
    downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
  */

  /* actual width in samples */
  unsigned int downsampled_width;

  /* actual height in samples */
  unsigned int downsampled_height;

  /*
    This flag is used only for decompression. In cases where some of the
    components will be ignored (eg grayscale output from YCbCr image), we can
    skip most computations for the unused components.
  */

  /* do we need the value of this component? */
  int component_needed;

  /*
    These values are computed before starting a scan of the component. The
    decompressor output side may not use these variables.
  */

  /* number of blocks per MCU, horizontally */
  int MCU_width;

  /* number of blocks per MCU, vertically */
  int MCU_height;

  /* MCU_width * MCU_height */
  int MCU_blocks;

  /* MCU width in samples, MCU_width*DCT_scaled_size */
  int MCU_sample_width;

  /* # of non-dummy blocks across in last MCU */
  int last_col_width;

  /* # of non-dummy blocks down in last MCU */
  int last_row_height;

  /*
    Saved quantization table for component; (void*)0 if none yet saved. See
    jdinput.c comments about the need for this information. This field is
    currently used only for decompression.
  */
  JQUANT_TBL *quant_table;

  /* Private per-component storage for DCT or IDCT subsystem. */
  void *dct_table;
} jpeg_component_info;


/*
  The script for encoding a multiple-scan file is an array of these:
*/

typedef struct {
  /* number of components encoded in this scan */
  int comps_in_scan;

  /* their SOF/comp_info[] indexes */
  int component_index[ 4 ];

  /* progressive JPEG spectral selection parms */
  int Ss, Se;

  /* progressive JPEG successive approx. parms */
  int Ah, Al;
} jpeg_scan_info;


/*
  Known color spaces.
*/

typedef enum {
  /* error/unspecified */
  JCS_UNKNOWN,

  /* monochrome */
  JCS_GRAYSCALE,

  /* red/green/blue */
  JCS_RGB,

  /* Y/Cb/Cr (also known as YUV) */
  JCS_YCbCr,

  /* C/M/Y/K */
  JCS_CMYK,

  /* Y/Cb/Cr/K */
  JCS_YCCK
} J_COLOR_SPACE;


/*
  DCT/IDCT algorithm options.
*/

typedef enum {
  /* slow but accurate integer algorithm */
  JDCT_ISLOW,

  /* faster, less accurate integer method */
  JDCT_IFAST,

  /* floating-point: accurate, fast on fast HW */
  JDCT_FLOAT
} J_DCT_METHOD;


/*
  Common fields between JPEG compression and decompression master structs.
*/

#define jpeg_common_fields \
  /* Error handler module */\
  struct jpeg_error_mgr *err; \
  /* Memory manager module */\
  struct jpeg_memory_mgr *mem; \
  /* Progress monitor, or (void*)0 if none */\
  struct jpeg_progress_mgr *progress; \
  /* Available for use by application */\
  void *client_data; \
  /* So common code can tell which is which */\
  int is_decompressor; \
  /* For checking call sequence validity */\
  int global_state


/*
  Routines that are to be used by both halves of the library are declared to
  receive a pointer to this structure. There are no actual instances of
  jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
*/

struct jpeg_common_struct {
  /* Fields common to both master struct types */
  jpeg_common_fields;

  /*
    Additional fields follow in an actual jpeg_compress_struct or
    jpeg_decompress_struct. All three structs must agree on these initial
    fields!  (This would be a lot cleaner in C++.)
  */
};

typedef struct jpeg_common_struct *j_common_ptr;
typedef struct jpeg_compress_struct *j_compress_ptr;
typedef struct jpeg_decompress_struct *j_decompress_ptr;


/*
  Master record for a compression instance
*/

struct jpeg_compress_struct {
  /* Fields shared with jpeg_decompress_struct */
  jpeg_common_fields;

  /* Destination for compressed data */
  struct jpeg_destination_mgr *dest;

  /*
    Description of source image --- these fields must be filled in by outer
    application before starting compression. in_color_space must be correct
    before you can even call jpeg_set_defaults().
  */

  /* input image width */
  unsigned int image_width;

  /* input image height */
  unsigned int image_height;

  /* # of color components in input image */
  int input_components;

  /* colorspace of input image */
  J_COLOR_SPACE in_color_space;

  /* image gamma of input image */
  double input_gamma;

  /*
    Compression parameters --- these fields must be set before calling
    jpeg_start_compress(). We recommend calling jpeg_set_defaults() to
    initialize everything to reasonable defaults, then changing anything the
    application specifically wants to change. That way you won't get burnt when
    new parameters are added. Also note that there are several helper routines
    to simplify changing parameters.
  */

  /* bits of precision in image data */
  int data_precision;

  /* # of color components in JPEG image */
  int num_components;

  /* colorspace of JPEG image */
  J_COLOR_SPACE jpeg_color_space;

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

  /* ptrs to coefficient quantization tables, or (void*)0 if not defined */
  JQUANT_TBL *quant_tbl_ptrs[ 4 ];

  /* ptrs to Huffman coding tables, or (void*)0 if not defined */
  JHUFF_TBL *dc_huff_tbl_ptrs[ 4 ];
  JHUFF_TBL *ac_huff_tbl_ptrs[ 4 ];

  /* L values for DC arith-coding tables */
  unsigned char arith_dc_L[ 16 ];

  /* U values for DC arith-coding tables */
  unsigned char arith_dc_U[ 16 ];

  /* Kx values for AC arith-coding tables */
  unsigned char arith_ac_K[ 16 ];

  /* # of entries in scan_info array */
  int num_scans;

  /*
    script for multi-scan file, or (void*)0
    The default value of scan_info is (void*)0, which causes a single-scan
    sequential JPEG file to be emitted. To create a multi-scan file, set
    num_scans and scan_info to point to an array of scan definitions.
  */
  const jpeg_scan_info *scan_info;

  /* 1=caller supplies downsampled data */
  int raw_data_in;

  /* 1=arithmetic coding, 0=Huffman */
  int arith_code;

  /* 1=optimize entropy encoding parms */
  int optimize_coding;

  /* 1=first samples are cosited */
  int CCIR601_sampling;

  /* 1..100, or 0 for no input smoothing */
  int smoothing_factor;

  /* DCT algorithm selector */
  J_DCT_METHOD dct_method;


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

  /* MCUs per restart, or 0 for no restart */
  unsigned int restart_interval;

  /* if > 0, MCU rows per restart interval */
  int restart_in_rows;


  /*
    Parameters controlling emission of special markers.
  */

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

  /* What to write for the JFIF version number */
  unsigned char JFIF_major_version;
  unsigned char JFIF_minor_version;

  /*
    These three values are not used by the JPEG code, merely 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.
  */

  /* JFIF code for pixel size units */
  unsigned char density_unit;

  /* Horizontal pixel density */
  unsigned short X_density;

  /* Vertical pixel density */
  unsigned short Y_density;

  /* should an Adobe marker be written? */
  int write_Adobe_marker;

  /*
    State variable: index of next scanline to be written to
    jpeg_write_scanlines(). Application may use this to control its processing
    loop, e.g., "while (next_scanline < image_height)".
  */

  /* 0 .. image_height-1  */
  unsigned int next_scanline;


  /*
    Remaining fields are known throughout compressor, but generally should not
    be touched by a surrounding application.
  */

  /*
    These fields are computed during compression startup
  */

  /* 1 if scan script uses progressive mode */
  int progressive_mode;

  /* largest h_samp_factor */
  int max_h_samp_factor;

  /* largest v_samp_factor */
  int max_v_samp_factor;

  /*
    # of iMCU rows to be input to coef ctlr
    The coefficient controller receives data in units of MCU rows as defined for
    fully interleaved scans (whether the JPEG file is interleaved or not). There
    are v_samp_factor * DCTSIZE sample rows of each component in an "iMCU"
    (interleaved MCU) row.
  */
  unsigned int total_iMCU_rows;

  /*
     These fields are valid during any one scan. They describe the components
     and MCUs actually appearing in the scan.
  */

  /* # of JPEG components in this scan */
  int comps_in_scan;

  /* *cur_comp_info[i] describes component that appears i'th in SOS */
  jpeg_component_info *cur_comp_info[ 4 ];

  /* # of MCUs across the image */
  unsigned int MCUs_per_row;

  /* # of MCU rows in the image */
  unsigned int MCU_rows_in_scan;

  /* # of DCT blocks per MCU */
  int blocks_in_MCU;

  /*
    MCU_membership[i] is index in cur_comp_info of component owning i'th block
    in an MCU
  */
  int MCU_membership[ 10 ];

  /* progressive JPEG parameters for scan */
  int Ss, Se, Ah, Al;

  /*
     Links to compression subobjects (methods and private variables of modules)
  */

  struct jpeg_comp_master *master;
  struct jpeg_c_main_controller *main;
  struct jpeg_c_prep_controller *prep;
  struct jpeg_c_coef_controller *coef;
  struct jpeg_marker_writer *marker;
  struct jpeg_color_converter *cconvert;
  struct jpeg_downsampler *downsample;
  struct jpeg_forward_dct *fdct;
  struct jpeg_entropy_encoder *entropy;

  /* workspace for jpeg_simple_progression */
  jpeg_scan_info *script_space;

  int script_space_size;
};


/*
  "Object" declarations for JPEG modules that may be supplied or called directly
  by the surrounding application. As with all objects in the JPEG library, these
  structs only define the publicly visible methods and state variables of a
  module. Additional private fields may exist after the public ones.
*/

/*
  Error handler object
*/

struct jpeg_error_mgr {
  /* Error exit handler: does not return to caller */
  void ( *error_exit ) ( j_common_ptr cinfo );

  /* Conditionally emit a trace or warning message */
  void ( *emit_message ) ( j_common_ptr cinfo, int msg_level );

  /* Routine that actually outputs a trace or error message */
  void ( *output_message ) ( j_common_ptr cinfo );

  /* Format a message string for the most recent JPEG error or message */
  void ( *format_message ) ( j_common_ptr cinfo, char *buffer );

  /* Reset error state variables at start of a new image */
  void ( *reset_error_mgr ) ( j_common_ptr cinfo );

  /*
    The message ID code and any parameters are saved here. A message can have
    one string parameter or up to 8 int parameters.
  */
  int msg_code;

  union {
    int i[ 8 ];
    char s[ 80 ];
  } msg_parm;


  /*
    Standard state variables for error facility
  */

  /* max msg_level that will be displayed */
  int trace_level;

  /*
    For recoverable corrupt-data errors, we emit a warning message, but keep
    going unless emit_message chooses to abort. emit_message should count
    warnings in num_warnings. The surrounding application can check for bad data
    by seeing if num_warnings is nonzero at the end of processing.
  */

  /* number of corrupt-data warnings */
  long num_warnings;

  /*
    These fields point to the table(s) of error message strings. An application
    can change the table pointer to switch to a different message list
    (typically, to change the language in which errors are reported). Some
    applications may wish to add additional error codes that will be handled by
    the JPEG library error mechanism; the second table pointer is used for this
    purpose.

     First table includes all errors generated by JPEG library itself. Error
     code 0 is reserved for a "no such error string" message.
  */

  /* Library errors */
  const char *const *jpeg_message_table;

  /* Table contains strings 0..last_jpeg_message */
  int last_jpeg_message;

  /*
    Second table can be added by application (see cjpeg/djpeg for example). It
    contains strings numbered first_addon_message..last_addon_message.
  */

  /* Non-library errors */
  const char *const *addon_message_table;

  /* code for first string in addon table */
  int first_addon_message;

  /* code for last string in addon table */
  int last_addon_message;
};


/*
  Progress monitor object
*/

struct jpeg_progress_mgr {
  void ( *progress_monitor ) ( j_common_ptr cinfo );

  /* work units completed in this pass */
  long pass_counter;

  /* total number of work units in this pass */
  long pass_limit;

  /* passes completed so far */
  int completed_passes;

  /* total number of passes expected */
  int total_passes;
};


/*
  Data destination object for compression
*/

struct jpeg_destination_mgr {
  /* => next byte to write in buffer */
  unsigned char *next_output_byte;

  /* # of byte spaces remaining in buffer */
  long unsigned int free_in_buffer;

  void ( *init_destination ) ( j_compress_ptr cinfo );
  int ( *empty_output_buffer ) ( j_compress_ptr cinfo );
  void ( *term_destination ) ( j_compress_ptr cinfo );
};


/*
  Memory manager object.
  Allocates "small" objects (a few K total), "large" objects (tens of K), and
  "really big" objects (virtual arrays with backing store if needed). The memory
  manager does not allow individual objects to be freed; rather, each created
  object is assigned to a pool, and whole pools can be freed at once. This is
  faster and more convenient than remembering exactly what to free, especially
  where malloc()/free() are not too speedy.
  NB: alloc routines never return (void*)0. They exit to error_exit if not
  successful.
*/

typedef struct jvirt_sarray_control *jvirt_sarray_ptr;
typedef struct jvirt_barray_control *jvirt_barray_ptr;

struct jpeg_memory_mgr {
  /*
    Method pointers
    */
  void *( *alloc_small ) (
    j_common_ptr cinfo, int pool_id, long unsigned int sizeofobject );

  void *( *alloc_large ) (
    j_common_ptr cinfo, int pool_id, long unsigned int sizeofobject );

  JSAMPARRAY ( *alloc_sarray ) (
    j_common_ptr cinfo, int pool_id, unsigned int samplesperrow,
    unsigned int numrows );

  JBLOCKARRAY ( *alloc_barray )(
    j_common_ptr cinfo, int pool_id, unsigned int blocksperrow,
    unsigned int numrows );

  jvirt_sarray_ptr ( *request_virt_sarray ) (
    j_common_ptr cinfo, int pool_id, int pre_zero, unsigned int samplesperrow,
    unsigned int numrows, unsigned int maxaccess );

  jvirt_barray_ptr ( *request_virt_barray ) (
    j_common_ptr cinfo, int pool_id, int pre_zero, unsigned int blocksperrow,
    unsigned int numrows, unsigned int maxaccess );

  void ( *realize_virt_arrays ) ( j_common_ptr cinfo );

  JSAMPARRAY ( *access_virt_sarray ) (
    j_common_ptr cinfo, jvirt_sarray_ptr ptr, unsigned int start_row,
    unsigned int num_rows, int writable );

  JBLOCKARRAY ( *access_virt_barray ) (
    j_common_ptr cinfo, jvirt_barray_ptr ptr, unsigned int start_row,
    unsigned int num_rows, int writable );

  void ( *free_pool ) ( j_common_ptr cinfo, int pool_id );

  void ( *self_destruct ) ( j_common_ptr cinfo );

  /*
    Limit on memory allocation for this JPEG object. (Note that this is merely
    advisory, not a guaranteed maximum; it only affects the space used for
    virtual-array buffers.) May be changed by outer application after creating
    the JPEG object.
  */
  long max_memory_to_use;

  /* Maximum allocation request accepted by alloc_large. */
  long max_alloc_chunk;
};

#endif /* JPEGLIB_H */