jpeglib.h

基于Linux的ffmepg decoder

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


//pwhsu++:20031020
//EXTERN(void) __inline DMA_access JPP((unsigned int start_row, unsigned int start_col, 
//							 int blkn,int bi,int dbnum, int ci/*, int cmdidx*/));
//pwhsu++:20031020
//pwhsu++:20031029
EXTERN(void) DMA_mcu JPP((j_compress_ptr cinfo,/* JSAMPIMAGE input_buf, */unsigned int MCU_col_num, 
						  unsigned int last_MCU_col, int dbnum/*, int dmal_bnum*/));
//EXTERN(void) FDCT JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, unsigned int blkn,
//						  int dctbnum));
//EXTERN(void) DCTQ JPP((j_compress_ptr cinfo, unsigned int MCU_col_num, 
//					  unsigned int last_MCU_col, unsigned int last_iMCU_row, int dctbnum));
//pwhsu++:20031029

//pwhsu++:20031030
//EXTERN(int) SwitchBuf JPP((int innum));
EXTERN(boolean) Encode_mcu JPP((j_compress_ptr cinfo/*, int vlcnum*/));
//EXTERN(void) Encode_block JPP((working_state * state, int last_dc_val, int dc_tbln, int ac_tbln, int vlcnum));
//pwhsu++:20031030

//pwhsu++:20031112
//EXTERN(void) FDCT_C JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, unsigned int blkn,
//						  int dctbnum));
//EXTERN(void) Dodct JPP((short * block));
//pwhsu++:20031112


//pwhsu++:20040113
//EXTERN(void) emit_word JPP((j_compress_ptr cinfo,unsigned int code, int size));
//EXTERN(boolean) packing_bits JPP((unsigned int code, int size));


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

/* 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.
 */
#define jpeg_create_compress(cinfo) \
    jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
			(size_t) sizeof(struct jpeg_compress_struct))
/*
// #define jpeg_create_decompress(cinfo) \
//    jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
//			  (size_t) sizeof(struct jpeg_decompress_struct))
*/
EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
				      int version, size_t structsize));
//EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
//					int version, size_t structsize));
/* Destruction of JPEG compression objects */
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));
//EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo));
//EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo));

/* 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,
				   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 */
EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
				      boolean write_all_tables));
//EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
//					     JSAMPARRAY scanlines,
//					     JDIMENSION num_lines));
EXTERN(JDIMENSION) jpeg_write_scanlines1 JPP((j_compress_ptr cinfo/*, 
										  JDIMENSION num_lines*/));	//pwhsu++:20040120
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));

EXTERN(boolean) compress_data1 JPP((j_compress_ptr cinfo));
EXTERN(void) start_pass_huff1 JPP((j_compress_ptr cinfo));
EXTERN(void) write_file_header1 JPP((j_compress_ptr cinfo));
EXTERN(void) write_frame_header1 JPP((j_compress_ptr cinfo));
EXTERN(void) write_file_trailer1 JPP((j_compress_ptr cinfo));
EXTERN(void) write_scan_header1 JPP((j_compress_ptr cinfo));
EXTERN(void) write_marker_header1 JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));


/* 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 */
#if 0
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,
				  boolean require_image));
#endif
/* 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 */
/* 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).
 */

/* Main entry points for decompression */
EXTERN(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(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(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));

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



//pwhsu++:20040120
GLOBAL(void)  process_data_simple_main1 JPP((j_compress_ptr cinfo,
			  JDIMENSION *in_row_ctr/*, JDIMENSION in_rows_avail*/));

//GLOBAL(void)  pre_process_data1 JPP((j_compress_ptr cinfo,
//		  /*JSAMPARRAY input_buf,*/ JDIMENSION *in_row_ctr,
//		  JDIMENSION in_rows_avail,
//		  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
//		  JDIMENSION out_row_groups_avail));		  


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

#ifdef LINUX
#define FA526_DrainWriteBuffer()
#define FA526_CleanInvalidateDCacheAll()
#else
static __inline void FA526_DrainWriteBuffer(void)
{
  unsigned int tmp=0;
  __asm  { MCR  p15,0,tmp,c7,c10,4 }
}

static __inline void FA526_CleanInvalidateDCacheAll()
{
  unsigned int tmp=0;
  __asm  { MCR  p15,0,tmp,c7,c14,0 }
}
#endif
#endif
/* JPEGLIB_H */