jpeglib.h

基于Linux的ffmepg decoder

/* 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, boolean force_baseline));
EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,int scale_factor,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,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,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 */
/**
 *  @name main entry points for compression
 *
 */

//@{
/* Initialization of JPEG compression objects.
 * jpeg_create_compress() and jpeg_create_decompress() are the exported
 * names that applications should call.  These expand to calls on
 * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
 * passed for version mismatch checking.
 * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
 */

/**
 * @ingroup compression_functions_group
 * To allocate and initialize a JPEG compression object.
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @return return void.
 * @see jpeg_compress_struct
 *
 */
#define jpeg_create_compress(cinfo) \
    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
			(size_t) sizeof(struct jpeg_compress_struct))
			


/* Standard data source and destination managers: stdio streams. */
/* Caller is responsible for opening the file before and closing after. */
/**
 * @ingroup compression_functions_group
 * To specify the source of the compressed data (e.g. a file).
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @param outfile is a pointer to output file handle. 
 *        Caller is responsible for opening the file before and closing after.
 * @return return void.
 * @see jpeg_compress_struct
 *
 */
EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));

/**
 * @ingroup compression_functions_group 
 * To begin the compression cycle.
 * Before calling this function, all encoding parameters and
 * a data destination must be set up.
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @param write_all_tables indicates to write all the table to output file or not.
 *        It was used for abbreviated format especially.
 * @return return void.
 * @see jpeg_compress_struct
 *
 */
EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,boolean write_all_tables));

/**
 * @ingroup compression_functions_group
 * To write some scanlines of image data to the JPEG compressor.
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @param scanlines is the pointer to the scanline image data.
 * @param num_lines is the number of scanlines to be written.
 * @return return the number of scanlines acutally written.
 * @see jpeg_compress_struct
 *
 */
EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,JSAMPARRAY scanlines,JDIMENSION num_lines));

/**
 * @ingroup compression_functions_group
 * To end the compression cycle.
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @return return void.
 * @see jpeg_compress_struct
 *
 */
EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));

/* Destruction of JPEG compression objects */
/**
 * @ingroup compression_functions_group
 * To destroy and release JPEG compression object.
 *
 * @param cinfo is a pointer to the struct jpeg_compress_struct object. 
 * @return return void.
 * @see jpeg_compress_struct
 *
 */
EXTERN(void) jpeg_destroy_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));
/* Same, but piecemeal. */
EXTERN(void) jpeg_write_m_header JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
EXTERN(void) jpeg_write_m_byte JPP((j_compress_ptr cinfo, int val));

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


/**
 *  @name main entry points for decompression
 *
 */
//@{

/* Main entry points for decompression */

/**
 * @ingroup decompression_functions_group
 * To allocate and initialize a JPEG decompression object.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object. 
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */			   
#define jpeg_create_decompress(cinfo) \
    jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
			  (size_t) sizeof(struct jpeg_decompress_struct))

/**
 * @ingroup decompression_functions_group 
 * To specify the data source for decompression.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object.
 * @param infile is a pointer to input file handle.
 *        Caller is responsible for opening the file before and closing after. 
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));

/* Decompression startup: read start of JPEG datastream to see what's there */

/* 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).
 */
 
/**
 * @ingroup decompression_functions_group 
 * To start to read JPEG header to get image information.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object.
 * @param require_image indicate an abbreviated format or not. If require_image
 *        is true, the image data must exist.
 * @return return integer type (JPEG_REACHED_SOS,JPEG_REACHED_EOI,JPEG_SUSPENDED)
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,boolean require_image));


/**
 * @ingroup decompression_functions_group 
 * To begin the decompression cycle.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object.
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
/**
 * @ingroup decompression_functions_group 
 * To read the decompressed image data.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object.
 * @param scanlines is a pointer to working buffer for storing the decompressed image data.
 * @param max_lines is maximum number of scanlines to be read.
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,JSAMPARRAY scanlines,JDIMENSION max_lines));
/**
 * @ingroup decompression_functions_group 
 * To complete the decompression cycle.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object.
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));

/**
 * @ingroup decompression_functions_group
 * To destroy and release JPEG decompression object.
 *
 * @param cinfo is a pointer to the struct jpeg_decompress_struct object. 
 * @return return void.
 * @see jpeg_decompress_struct
 * 
 */
EXTERN(void) jpeg_destroy_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(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,int scan_number));
EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
EXTERN(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));

/* Control saving of COM and APPn markers into marker_list. */
EXTERN(void) jpeg_save_markers JPP((j_decompress_ptr cinfo, int marker_code,unsigned int length_limit));

/* 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(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


#include "ftmcp100.h"

#endif /* JPEGLIB_H */