Back to index

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