jpeglib.h

ESS3890+SL原代码（1*16内存）

typedef JMETHOD(my_boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));


/* Declarations for routines called by application.
 * The JPP macro hides prototype parameters from compilers that can't cope.
 * Note JPP requires double parentheses.
 */

#ifdef HAVE_PROTOTYPES
#define JPP(arglist)    arglist
#else
#define JPP(arglist)    ()
#endif


/* Short forms of external names for systems with brain-damaged linkers.
 * We shorten external names to be unique in the first six letters, which
 * is good enough for all known systems.
 * (If your compiler itself needs names to be unique in less than 15 
 * characters, you are out of luck.  Get a better compiler.)
 */

#ifdef NEED_SHORT_EXTERNAL_NAMES
#define jpeg_std_error          jStdError
#define jpeg_create_compress    jCreaCompress
#define jpeg_create_decompress  jCreaDecompress
#define jpeg_destroy_compress   jDestCompress
#define jpeg_destroy_decompress jDestDecompress
#define jpeg_stdio_dest         jStdDest
#define jpeg_stdio_src          jStdSrc
#define jpeg_set_defaults       jSetDefaults
#define jpeg_set_colorspace     jSetColorspace
#define jpeg_default_colorspace jDefColorspace
#define jpeg_set_quality        jSetQuality
#define jpeg_set_linear_quality jSetLQuality
#define jpeg_add_quant_table    jAddQuantTable
#define jpeg_quality_scaling    jQualityScaling
#define jpeg_simple_progression jSimProgress
#define jpeg_suppress_tables    jSuppressTables
#define jpeg_alloc_quant_table  jAlcQTable
#define jpeg_alloc_huff_table   jAlcHTable
#define jpeg_start_compress     jStrtCompress
#define jpeg_write_scanlines    jWrtScanlines
#define jpeg_finish_compress    jFinCompress
#define jpeg_write_raw_data     jWrtRawData
#define jpeg_write_marker       jWrtMarker
#define jpeg_write_tables       jWrtTables
#define jpeg_read_header        jReadHeader
#define jpeg_start_decompress   jStrtDecompress
#define jpeg_read_scanlines     jReadScanlines
#define jpeg_finish_decompress  jFinDecompress
#define jpeg_read_raw_data      jReadRawData
#define jpeg_has_multiple_scans jHasMultScn
#define jpeg_start_output       jStrtOutput
#define jpeg_finish_output      jFinOutput
#define jpeg_input_complete     jInComplete
#define jpeg_new_colormap       jNewCMap
#define jpeg_consume_input      jConsumeInput
#define jpeg_calc_output_dimensions     jCalcDimensions
#define jpeg_set_marker_processor       jSetMarker
#define jpeg_read_coefficients  jReadCoefs
#define jpeg_write_coefficients jWrtCoefs
#define jpeg_copy_critical_parameters   jCopyCrit
#define jpeg_abort_compress     jAbrtCompress
#define jpeg_abort_decompress   jAbrtDecompress
#define jpeg_abort              jAbort
#define jpeg_destroy            jDestroy
#define jpeg_resync_to_restart  jResyncRestart
#endif /* NEED_SHORT_EXTERNAL_NAMES */


/* Default error-management setup */
EXTERN struct jpeg_error_mgr *jpeg_std_error JPP((struct jpeg_error_mgr *err));

/* Initialization and destruction of JPEG compression objects */
/* NB: you must set up the error-manager BEFORE calling jpeg_create_xxx */
EXTERN void jpeg_create_compress JPP((j_compress_ptr cinfo));
EXTERN void jpeg_create_decompress JPP((j_decompress_ptr cinfo));
EXTERN void jpeg_destroy_compress JPP((j_compress_ptr cinfo));
EXTERN void jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));

/* Standard data source and destination managers: stdio streams. */
/* Caller is responsible for opening the file before and closing after. */
EXTERN void jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
EXTERN void jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));

/* Default parameter setup for compression */
EXTERN void jpeg_set_defaults JPP((j_compress_ptr cinfo));
/* Compression parameter setup aids */
EXTERN void jpeg_set_colorspace JPP((j_compress_ptr cinfo,
                                     J_COLOR_SPACE colorspace));
EXTERN void jpeg_default_colorspace JPP((j_compress_ptr cinfo));
EXTERN void jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
                                  my_boolean force_baseline));
EXTERN void jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
                                         int scale_factor,
                                         my_boolean force_baseline));
EXTERN void jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
                                      const unsigned int *basic_table,
                                      int scale_factor,
                                      my_boolean force_baseline));
EXTERN int jpeg_quality_scaling JPP((int quality));
EXTERN void jpeg_simple_progression JPP((j_compress_ptr cinfo));
EXTERN void jpeg_suppress_tables JPP((j_compress_ptr cinfo,
                                      my_boolean suppress));
EXTERN JQUANT_TBL * jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
EXTERN JHUFF_TBL * jpeg_alloc_huff_table JPP((j_common_ptr cinfo));

/* Main entry points for compression */
EXTERN void jpeg_start_compress JPP((j_compress_ptr cinfo,
                                     my_boolean write_all_tables));
EXTERN JDIMENSION jpeg_write_scanlines JPP((j_compress_ptr cinfo,
                                            JSAMPARRAY scanlines,
                                            JDIMENSION num_lines));
EXTERN void jpeg_finish_compress JPP((j_compress_ptr cinfo));

/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
EXTERN JDIMENSION jpeg_write_raw_data JPP((j_compress_ptr cinfo,
                                           JSAMPIMAGE data,
                                           JDIMENSION num_lines));

/* Write a special marker.  See libjpeg.doc concerning safe usage. */
EXTERN void jpeg_write_marker JPP((j_compress_ptr cinfo, int marker,
                                   const JOCTET *dataptr, unsigned int datalen));

/* Alternate compression function: just write an abbreviated table file */
EXTERN void jpeg_write_tables JPP((j_compress_ptr cinfo));

/* Decompression startup: read start of JPEG datastream to see what's there */
EXTERN int jpeg_read_header JPP((j_decompress_ptr cinfo,
                                 my_boolean require_image));
/* Return value is one of: */
#define JPEG_SUSPENDED          0 /* Suspended due to lack of input data */
#define JPEG_HEADER_OK          1 /* Found valid image datastream */
#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
#define JPEG_IN_PROGRESS	3/*in the middle of decoding, but need get out*/

/* If you pass require_image = TRUE (normal case), you need not check for
 * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
 * JPEG_SUSPENDED is only possible if you use a data source module that can
 * give a suspension return (the stdio source module doesn't).
 */
/*
 * Next are some state machine which used to control the 
 * flow of the decord
 */
#define JPEG_START                 100
#define JPEG_READ_HEADER           JPEG_START+1
#define JPEG_PARAMETER_INITIALIZE  JPEG_START+2
#define JPEG_DECODE_START          JPEG_START+3
#define JPEG_SCAN_INITIALIZE       JPEG_START+4
#define JPEG_DECODING              JPEG_START+5
#define JPEG_SCAN_DEINITIALIZE     JPEG_START+6
#define JPEG_DECODE_FINISH         JPEG_START+7
#define JPEG_END                   JPEG_START+8
#define JPEG_END_DECODE            JPEG_START+9
#define JPEG_SUCCESS               JPEG_START+10


/* Main entry points for decompression */
EXTERN my_boolean jpeg_start_decompress JPP((j_decompress_ptr cinfo));
EXTERN JDIMENSION jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
                                           JSAMPARRAY scanlines,
                                           JDIMENSION max_lines));
EXTERN my_boolean jpeg_finish_decompress JPP((j_decompress_ptr cinfo));

/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
EXTERN JDIMENSION jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
                                          JSAMPIMAGE data,
                                          JDIMENSION max_lines));

/* Additional entry points for buffered-image mode. */
EXTERN my_boolean jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
EXTERN my_boolean jpeg_start_output JPP((j_decompress_ptr cinfo,
                                      int scan_number));
EXTERN my_boolean jpeg_finish_output JPP((j_decompress_ptr cinfo));
EXTERN my_boolean jpeg_input_complete JPP((j_decompress_ptr cinfo));
EXTERN void jpeg_new_colormap JPP((j_decompress_ptr cinfo));
EXTERN int jpeg_consume_input JPP((j_decompress_ptr cinfo));
/* Return value is one of: */
/* #define JPEG_SUSPENDED       0    Suspended due to lack of input data */
#define JPEG_REACHED_SOS        1 /* Reached start of new scan */
#define JPEG_REACHED_EOI        2 /* Reached end of image */
#define JPEG_ROW_COMPLETED      3 /* Completed one iMCU row */
#define JPEG_SCAN_COMPLETED     4 /* Completed last iMCU row of a scan */

/* Precalculate output dimensions for current decompression parameters. */
EXTERN void jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));

/* Install a special processing method for COM or APPn markers. */
EXTERN void jpeg_set_marker_processor JPP((j_decompress_ptr cinfo,
                                           int marker_code,
                                           jpeg_marker_parser_method routine));

/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
EXTERN jvirt_barray_ptr * jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
EXTERN void jpeg_write_coefficients JPP((j_compress_ptr cinfo,
                                         jvirt_barray_ptr * coef_arrays));
EXTERN void jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
                                               j_compress_ptr dstinfo));

/* If you choose to abort compression or decompression before completing
 * jpeg_finish_(de)compress, then you need to clean up to release memory,
 * temporary files, etc.  You can just call jpeg_destroy_(de)compress
 * if you're done with the JPEG object, but if you want to clean it up and
 * reuse it, call this:
 */
EXTERN void jpeg_abort_compress JPP((j_compress_ptr cinfo));
EXTERN void jpeg_abort_decompress JPP((j_decompress_ptr cinfo));

/* Generic versions of jpeg_abort and jpeg_destroy that work on either
 * flavor of JPEG object.  These may be more convenient in some places.
 */
EXTERN void jpeg_abort JPP((j_common_ptr cinfo));
EXTERN void jpeg_destroy JPP((j_common_ptr cinfo));

/* Default restart-marker-resync procedure for use by data source modules */
EXTERN my_boolean jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
                                           int desired));


/* These marker codes are exported since applications and data source modules
 * are likely to want to use them.
 */

#define JPEG_RST0       0xD0    /* RST0 marker code */
#define JPEG_EOI        0xD9    /* EOI marker code */
#define JPEG_APP0       0xE0    /* APP0 marker code */
#define JPEG_COM        0xFE    /* COM marker code */


/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
 * for structure definitions that are never filled in, keep it quiet by
 * supplying dummy definitions for the various substructures.
 */

#ifdef INCOMPLETE_TYPES_BROKEN
#ifndef JPEG_INTERNALS          /* will be defined in jpegint.h */
struct jvirt_sarray_control { long dummy; };
struct jvirt_barray_control { long dummy; };
struct jpeg_comp_master { long dummy; };
struct jpeg_c_main_controller { long dummy; };
struct jpeg_c_prep_controller { long dummy; };
struct jpeg_c_coef_controller { long dummy; };
struct jpeg_marker_writer { long dummy; };
struct jpeg_color_converter { long dummy; };
struct jpeg_downsampler { long dummy; };
struct jpeg_forward_dct { long dummy; };
struct jpeg_entropy_encoder { long dummy; };
struct jpeg_decomp_master { long dummy; };
struct jpeg_d_main_controller { long dummy; };
struct jpeg_d_coef_controller { long dummy; };
struct jpeg_d_post_controller { long dummy; };
struct jpeg_input_controller { long dummy; };
struct jpeg_marker_reader { long dummy; };
struct jpeg_entropy_decoder { long dummy; };
struct jpeg_inverse_dct { long dummy; };
struct jpeg_upsampler { long dummy; };
struct jpeg_color_deconverter { long dummy; };
struct jpeg_color_quantizer { long dummy; };
#endif /* JPEG_INTERNALS */
#endif /* INCOMPLETE_TYPES_BROKEN */


/*
 * The JPEG library modules define JPEG_INTERNALS before including this file.
 * The internal structure declarations are read only when that is true.
 * Applications using the library should not include jpegint.h, but may wish
 * to include jerror.h.
 */

#ifdef JPEG_INTERNALS
#include "jpegint.h"            /* fetch private declarations */
#include "jerror.h"             /* fetch error codes too */
#endif

#endif /* JPEGLIB_H */