jpegint.h

Go to the documentation of this file.
00001 /*
00002  * jpegint.h
00003  *
00004  * Copyright (C) 1991-1997, Thomas G. Lane.
00005  * This file is part of the Independent JPEG Group's software.
00006  * For conditions of distribution and use, see the accompanying README file.
00007  *
00008  * This file provides common declarations for the various JPEG modules.
00009  * These declarations are considered internal to the JPEG library; most
00010  * applications using the library shouldn't need to include this file.
00011  */
00012 
00013 
00017 
00018 /* Declarations for both compression & decompression */
00019 
00020 typedef enum {          /* Operating modes for buffer controllers */
00021     JBUF_PASS_THRU,     /* Plain stripwise operation */
00022     /* Remaining modes require a full-image buffer to have been created */
00023     JBUF_SAVE_SOURCE,   /* Run source subobject only, save output */
00024     JBUF_CRANK_DEST,    /* Run dest subobject only, using saved data */
00025     JBUF_SAVE_AND_PASS  /* Run both subobjects, save output */
00026 } J_BUF_MODE;
00027 
00028 /* Values of global_state field (jdapi.c has some dependencies on ordering!) */
00029 #define CSTATE_START    100 /* after create_compress */
00030 #define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */
00031 #define CSTATE_RAW_OK   102 /* start_compress done, write_raw_data OK */
00032 #define CSTATE_WRCOEFS  103 /* jpeg_write_coefficients done */
00033 #define DSTATE_START    200 /* after create_decompress */
00034 #define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */
00035 #define DSTATE_READY    202 /* found SOS, ready for start_decompress */
00036 #define DSTATE_PRELOAD  203 /* reading multiscan file in start_decompress*/
00037 #define DSTATE_PRESCAN  204 /* performing dummy pass for 2-pass quant */
00038 #define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */
00039 #define DSTATE_RAW_OK   206 /* start_decompress done, read_raw_data OK */
00040 #define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */
00041 #define DSTATE_BUFPOST  208 /* looking for SOS/EOI in jpeg_finish_output */
00042 #define DSTATE_RDCOEFS  209 /* reading file in jpeg_read_coefficients */
00043 #define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */
00044 
00045 
00046 /* Declarations for compression modules */
00047 
00048 /* Master control module */
00049 struct jpeg_comp_master {
00050   JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
00051   JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
00052   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
00053 
00054   /* State variables made visible to other modules */
00055   boolean call_pass_startup;    /* True if pass_startup must be called */
00056   boolean is_last_pass;     /* True during last pass */
00057 };
00058 
00059 /* Main buffer control (downsampled-data buffer) */
00060 struct jpeg_c_main_controller {
00061   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
00062   JMETHOD(void, process_data, (j_compress_ptr cinfo,
00063                    JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
00064                    JDIMENSION in_rows_avail));
00065 };
00066 
00067 /* Compression preprocessing (downsampling input buffer control) */
00068 struct jpeg_c_prep_controller {
00069   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
00070   JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
00071                    JSAMPARRAY input_buf,
00072                    JDIMENSION *in_row_ctr,
00073                    JDIMENSION in_rows_avail,
00074                    JSAMPIMAGE output_buf,
00075                    JDIMENSION *out_row_group_ctr,
00076                    JDIMENSION out_row_groups_avail));
00077 };
00078 
00079 /* Coefficient buffer control */
00080 struct jpeg_c_coef_controller {
00081   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
00082   JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
00083                    JSAMPIMAGE input_buf));
00084 };
00085 
00086 /* Colorspace conversion */
00087 struct jpeg_color_converter {
00088   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
00089   JMETHOD(void, color_convert, (j_compress_ptr cinfo,
00090                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
00091                 JDIMENSION output_row, int num_rows));
00092 };
00093 
00094 /* Downsampling */
00095 struct jpeg_downsampler {
00096   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
00097   JMETHOD(void, downsample, (j_compress_ptr cinfo,
00098                  JSAMPIMAGE input_buf, JDIMENSION in_row_index,
00099                  JSAMPIMAGE output_buf,
00100                  JDIMENSION out_row_group_index));
00101 
00102   boolean need_context_rows;    /* TRUE if need rows above & below */
00103 };
00104 
00105 /* Forward DCT (also controls coefficient quantization) */
00106 struct jpeg_forward_dct {
00107   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
00108   /* perhaps this should be an array??? */
00109   JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
00110                   jpeg_component_info * compptr,
00111                   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
00112                   JDIMENSION start_row, JDIMENSION start_col,
00113                   JDIMENSION num_blocks));
00114 };
00115 
00116 /* Entropy encoding */
00117 struct jpeg_entropy_encoder {
00118   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
00119   JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
00120   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
00121 };
00122 
00123 /* Marker writing */
00124 struct jpeg_marker_writer {
00125   JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
00126   JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
00127   JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
00128   JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
00129   JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
00130   /* These routines are exported to allow insertion of extra markers */
00131   /* Probably only COM and APPn markers should be written this way */
00132   JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
00133                       unsigned int datalen));
00134   JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
00135 };
00136 
00137 
00138 /* Declarations for decompression modules */
00139 
00140 /* Master control module */
00141 struct jpeg_decomp_master {
00142   JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
00143   JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
00144 
00145   /* State variables made visible to other modules */
00146   boolean is_dummy_pass;    /* True during 1st pass for 2-pass quant */
00147 };
00148 
00149 /* Input control module */
00150 struct jpeg_input_controller {
00151   JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
00152   JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
00153   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
00154   JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
00155 
00156   /* State variables made visible to other modules */
00157   boolean has_multiple_scans;   /* True if file has multiple scans */
00158   boolean eoi_reached;      /* True when EOI has been consumed */
00159 };
00160 
00161 /* Main buffer control (downsampled-data buffer) */
00162 struct jpeg_d_main_controller {
00163   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
00164   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
00165                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
00166                    JDIMENSION out_rows_avail));
00167 };
00168 
00169 /* Coefficient buffer control */
00170 struct jpeg_d_coef_controller {
00171   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
00172   JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
00173   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
00174   JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
00175                  JSAMPIMAGE output_buf));
00176   /* Pointer to array of coefficient virtual arrays, or NULL if none */
00177   jvirt_barray_ptr *coef_arrays;
00178 };
00179 
00180 /* Decompression postprocessing (color quantization buffer control) */
00181 struct jpeg_d_post_controller {
00182   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
00183   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
00184                     JSAMPIMAGE input_buf,
00185                     JDIMENSION *in_row_group_ctr,
00186                     JDIMENSION in_row_groups_avail,
00187                     JSAMPARRAY output_buf,
00188                     JDIMENSION *out_row_ctr,
00189                     JDIMENSION out_rows_avail));
00190 };
00191 
00192 /* Marker reading & parsing */
00193 struct jpeg_marker_reader {
00194   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
00195   /* Read markers until SOS or EOI.
00196    * Returns same codes as are defined for jpeg_consume_input:
00197    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
00198    */
00199   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
00200   /* Read a restart marker --- exported for use by entropy decoder only */
00201   jpeg_marker_parser_method read_restart_marker;
00202 
00203   /* State of marker reader --- nominally internal, but applications
00204    * supplying COM or APPn handlers might like to know the state.
00205    */
00206   boolean saw_SOI;      /* found SOI? */
00207   boolean saw_SOF;      /* found SOF? */
00208   int next_restart_num;     /* next restart number expected (0-7) */
00209   unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
00210 };
00211 
00212 /* Entropy decoding */
00213 struct jpeg_entropy_decoder {
00214   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
00215   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
00216                 JBLOCKROW *MCU_data));
00217 
00218   /* This is here to share code between baseline and progressive decoders; */
00219   /* other modules probably should not use it */
00220   boolean insufficient_data;    /* set TRUE after emitting warning */
00221 };
00222 
00223 /* Inverse DCT (also performs dequantization) */
00224 typedef JMETHOD(void, inverse_DCT_method_ptr,
00225         (j_decompress_ptr cinfo, jpeg_component_info * compptr,
00226          JCOEFPTR coef_block,
00227          JSAMPARRAY output_buf, JDIMENSION output_col));
00228 
00229 struct jpeg_inverse_dct {
00230   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
00231   /* It is useful to allow each component to have a separate IDCT method. */
00232   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
00233 };
00234 
00235 /* Upsampling (note that upsampler must also call color converter) */
00236 struct jpeg_upsampler {
00237   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
00238   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
00239                JSAMPIMAGE input_buf,
00240                JDIMENSION *in_row_group_ctr,
00241                JDIMENSION in_row_groups_avail,
00242                JSAMPARRAY output_buf,
00243                JDIMENSION *out_row_ctr,
00244                JDIMENSION out_rows_avail));
00245 
00246   boolean need_context_rows;    /* TRUE if need rows above & below */
00247 };
00248 
00249 /* Colorspace conversion */
00250 struct jpeg_color_deconverter {
00251   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
00252   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
00253                 JSAMPIMAGE input_buf, JDIMENSION input_row,
00254                 JSAMPARRAY output_buf, int num_rows));
00255 };
00256 
00257 /* Color quantization or color precision reduction */
00258 struct jpeg_color_quantizer {
00259   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
00260   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
00261                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
00262                  int num_rows));
00263   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
00264   JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
00265 };
00266 
00267 
00268 /* Miscellaneous useful macros */
00269 
00270 #undef MAX
00271 #define MAX(a,b)    ((a) > (b) ? (a) : (b))
00272 #undef MIN
00273 #define MIN(a,b)    ((a) < (b) ? (a) : (b))
00274 
00275 
00276 /* We assume that right shift corresponds to signed division by 2 with
00277  * rounding towards minus infinity.  This is correct for typical "arithmetic
00278  * shift" instructions that shift in copies of the sign bit.  But some
00279  * C compilers implement >> with an unsigned shift.  For these machines you
00280  * must define RIGHT_SHIFT_IS_UNSIGNED.
00281  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
00282  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
00283  * included in the variables of any routine using RIGHT_SHIFT.
00284  */
00285 
00286 #ifdef RIGHT_SHIFT_IS_UNSIGNED
00287 #define SHIFT_TEMPS INT32 shift_temp;
00288 #define RIGHT_SHIFT(x,shft)  \
00289     ((shift_temp = (x)) < 0 ? \
00290      (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
00291      (shift_temp >> (shft)))
00292 #else
00293 #define SHIFT_TEMPS
00294 #define RIGHT_SHIFT(x,shft) ((x) >> (shft))
00295 #endif
00296 
00297 
00298 /* Short forms of external names for systems with brain-damaged linkers. */
00299 
00300 #ifdef NEED_SHORT_EXTERNAL_NAMES
00301 #define jinit_compress_master   jICompress
00302 #define jinit_c_master_control  jICMaster
00303 #define jinit_c_main_controller jICMainC
00304 #define jinit_c_prep_controller jICPrepC
00305 #define jinit_c_coef_controller jICCoefC
00306 #define jinit_color_converter   jICColor
00307 #define jinit_downsampler   jIDownsampler
00308 #define jinit_forward_dct   jIFDCT
00309 #define jinit_huff_encoder  jIHEncoder
00310 #define jinit_phuff_encoder jIPHEncoder
00311 #define jinit_marker_writer jIMWriter
00312 #define jinit_master_decompress jIDMaster
00313 #define jinit_d_main_controller jIDMainC
00314 #define jinit_d_coef_controller jIDCoefC
00315 #define jinit_d_post_controller jIDPostC
00316 #define jinit_input_controller  jIInCtlr
00317 #define jinit_marker_reader jIMReader
00318 #define jinit_huff_decoder  jIHDecoder
00319 #define jinit_phuff_decoder jIPHDecoder
00320 #define jinit_inverse_dct   jIIDCT
00321 #define jinit_upsampler     jIUpsampler
00322 #define jinit_color_deconverter jIDColor
00323 #define jinit_1pass_quantizer   jI1Quant
00324 #define jinit_2pass_quantizer   jI2Quant
00325 #define jinit_merged_upsampler  jIMUpsampler
00326 #define jinit_memory_mgr    jIMemMgr
00327 #define jdiv_round_up       jDivRound
00328 #define jround_up       jRound
00329 #define jcopy_sample_rows   jCopySamples
00330 #define jcopy_block_row     jCopyBlocks
00331 #define jzero_far       jZeroFar
00332 #define jpeg_zigzag_order   jZIGTable
00333 #define jpeg_natural_order  jZAGTable
00334 #endif /* NEED_SHORT_EXTERNAL_NAMES */
00335 
00336 
00337 /* Compression module initialization routines */
00338 EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
00339 EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
00340                      boolean transcode_only));
00341 EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
00342                       boolean need_full_buffer));
00343 EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
00344                       boolean need_full_buffer));
00345 EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
00346                       boolean need_full_buffer));
00347 EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
00348 EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
00349 EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
00350 EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
00351 EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
00352 EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
00353 /* Decompression module initialization routines */
00354 EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
00355 EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
00356                       boolean need_full_buffer));
00357 EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
00358                       boolean need_full_buffer));
00359 EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
00360                       boolean need_full_buffer));
00361 EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
00362 EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
00363 EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
00364 EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
00365 EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
00366 EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
00367 EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
00368 EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
00369 EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
00370 EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
00371 /* Memory manager initialization */
00372 EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
00373 
00374 /* Utility routines in jutils.c */
00375 EXTERN(long) jdiv_round_up JPP((long a, long b));
00376 EXTERN(long) jround_up JPP((long a, long b));
00377 EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
00378                     JSAMPARRAY output_array, int dest_row,
00379                     int num_rows, JDIMENSION num_cols));
00380 EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
00381                   JDIMENSION num_blocks));
00382 EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
00383 /* Constant tables in jutils.c */
00384 #if 0               /* This table is not actually needed in v6a */
00385 extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
00386 #endif
00387 extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
00388 
00389 /* Suppress undefined-structure complaints if necessary. */
00390 
00391 #ifdef INCOMPLETE_TYPES_BROKEN
00392 #ifndef AM_MEMORY_MANAGER   /* only jmemmgr.c defines these */
00393 struct jvirt_sarray_control { long dummy; };
00394 struct jvirt_barray_control { long dummy; };
00395 #endif
00396 #endif /* INCOMPLETE_TYPES_BROKEN */

Generated on Tue Jan 6 22:41:37 2009 for Autodesk DWF 3D Toolkit by  doxygen 1.4.5