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