home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Info / Extras / Jpeg / SRC / JPEGINT.H < prev    next >
C/C++ Source or Header  |  1999-08-11  |  16KB  |  396 lines
  1. /*
  2.  * jpegint.h
  3.  *
  4.  * Copyright (C) 1991-1996, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file provides common declarations for the various JPEG modules.
  9.  * These declarations are considered internal to the JPEG library; most
  10.  * applications using the library shouldn't need to include this file.
  11.  */
  12.  
  13.  
  14. /* Declarations for both compression & decompression */
  15.  
  16. typedef enum {            /* Operating modes for buffer controllers */
  17.     JBUF_PASS_THRU,        /* Plain stripwise operation */
  18.     /* Remaining modes require a full-image buffer to have been created */
  19.     JBUF_SAVE_SOURCE,    /* Run source subobject only, save output */
  20.     JBUF_CRANK_DEST,    /* Run dest subobject only, using saved data */
  21.     JBUF_SAVE_AND_PASS    /* Run both subobjects, save output */
  22. } J_BUF_MODE;
  23.  
  24. /* Values of global_state field (jdapi.c has some dependencies on ordering!) */
  25. #define CSTATE_START    100    /* after create_compress */
  26. #define CSTATE_SCANNING    101    /* start_compress done, write_scanlines OK */
  27. #define CSTATE_RAW_OK    102    /* start_compress done, write_raw_data OK */
  28. #define CSTATE_WRCOEFS    103    /* jpeg_write_coefficients done */
  29. #define DSTATE_START    200    /* after create_decompress */
  30. #define DSTATE_INHEADER    201    /* reading header markers, no SOS yet */
  31. #define DSTATE_READY    202    /* found SOS, ready for start_decompress */
  32. #define DSTATE_PRELOAD    203    /* reading multiscan file in start_decompress*/
  33. #define DSTATE_PRESCAN    204    /* performing dummy pass for 2-pass quant */
  34. #define DSTATE_SCANNING    205    /* start_decompress done, read_scanlines OK */
  35. #define DSTATE_RAW_OK    206    /* start_decompress done, read_raw_data OK */
  36. #define DSTATE_BUFIMAGE    207    /* expecting jpeg_start_output */
  37. #define DSTATE_BUFPOST    208    /* looking for SOS/EOI in jpeg_finish_output */
  38. #define DSTATE_RDCOEFS    209    /* reading file in jpeg_read_coefficients */
  39. #define DSTATE_STOPPING    210    /* looking for EOI in jpeg_finish_decompress */
  40.  
  41.  
  42. /* Declarations for compression modules */
  43.  
  44. /* Master control module */
  45. struct jpeg_comp_master {
  46.   JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
  47.   JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
  48.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  49.  
  50.   /* State variables made visible to other modules */
  51.   boolean call_pass_startup;    /* True if pass_startup must be called */
  52.   boolean is_last_pass;        /* True during last pass */
  53. };
  54.  
  55. /* Main buffer control (downsampled-data buffer) */
  56. struct jpeg_c_main_controller {
  57.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  58.   JMETHOD(void, process_data, (j_compress_ptr cinfo,
  59.                    JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
  60.                    JDIMENSION in_rows_avail));
  61. };
  62.  
  63. /* Compression preprocessing (downsampling input buffer control) */
  64. struct jpeg_c_prep_controller {
  65.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  66.   JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
  67.                    JSAMPARRAY input_buf,
  68.                    JDIMENSION *in_row_ctr,
  69.                    JDIMENSION in_rows_avail,
  70.                    JSAMPIMAGE output_buf,
  71.                    JDIMENSION *out_row_group_ctr,
  72.                    JDIMENSION out_row_groups_avail));
  73. };
  74.  
  75. /* Coefficient buffer control */
  76. struct jpeg_c_coef_controller {
  77.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  78.   JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
  79.                    JSAMPIMAGE input_buf));
  80. };
  81.  
  82. /* Colorspace conversion */
  83. struct jpeg_color_converter {
  84.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  85.   JMETHOD(void, color_convert, (j_compress_ptr cinfo,
  86.                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  87.                 JDIMENSION output_row, int num_rows));
  88. };
  89.  
  90. /* Downsampling */
  91. struct jpeg_downsampler {
  92.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  93.   JMETHOD(void, downsample, (j_compress_ptr cinfo,
  94.                  JSAMPIMAGE input_buf, JDIMENSION in_row_index,
  95.                  JSAMPIMAGE output_buf,
  96.                  JDIMENSION out_row_group_index));
  97.  
  98.   boolean need_context_rows;    /* TRUE if need rows above & below */
  99. };
  100.  
  101. /* Forward DCT (also controls coefficient quantization) */
  102. struct jpeg_forward_dct {
  103.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  104.   /* perhaps this should be an array??? */
  105.   JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
  106.                   jpeg_component_info * compptr,
  107.                   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  108.                   JDIMENSION start_row, JDIMENSION start_col,
  109.                   JDIMENSION num_blocks));
  110. };
  111.  
  112. /* Entropy encoding */
  113. struct jpeg_entropy_encoder {
  114.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
  115.   JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
  116.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  117. };
  118.  
  119. /* Marker writing */
  120. struct jpeg_marker_writer {
  121.   /* write_any_marker is exported for use by applications */
  122.   /* Probably only COM and APPn markers should be written */
  123.   JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
  124.                    const JOCTET *dataptr, unsigned int datalen));
  125.   JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
  126.   JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
  127.   JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
  128.   JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
  129.   JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
  130. };
  131.  
  132.  
  133. /* Declarations for decompression modules */
  134.  
  135. /* Master control module */
  136. struct jpeg_decomp_master {
  137.   JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
  138.   JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
  139.  
  140.   /* State variables made visible to other modules */
  141.   boolean is_dummy_pass;    /* True during 1st pass for 2-pass quant */
  142. };
  143.  
  144. /* Input control module */
  145. struct jpeg_input_controller {
  146.   JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
  147.   JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
  148.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  149.   JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
  150.  
  151.   /* State variables made visible to other modules */
  152.   boolean has_multiple_scans;    /* True if file has multiple scans */
  153.   boolean eoi_reached;        /* True when EOI has been consumed */
  154. };
  155.  
  156. /* Main buffer control (downsampled-data buffer) */
  157. struct jpeg_d_main_controller {
  158.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  159.   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
  160.                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  161.                    JDIMENSION out_rows_avail));
  162. };
  163.  
  164. /* Coefficient buffer control */
  165. struct jpeg_d_coef_controller {
  166.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  167.   JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
  168.   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
  169.   JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
  170.                  JSAMPIMAGE output_buf));
  171.   /* Pointer to array of coefficient virtual arrays, or NULL if none */
  172.   jvirt_barray_ptr *coef_arrays;
  173. };
  174.  
  175. /* Decompression postprocessing (color quantization buffer control) */
  176. struct jpeg_d_post_controller {
  177.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  178.   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
  179.                     JSAMPIMAGE input_buf,
  180.                     JDIMENSION *in_row_group_ctr,
  181.                     JDIMENSION in_row_groups_avail,
  182.                     JSAMPARRAY output_buf,
  183.                     JDIMENSION *out_row_ctr,
  184.                     JDIMENSION out_rows_avail));
  185. };
  186.  
  187. /* Marker reading & parsing */
  188. struct jpeg_marker_reader {
  189.   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
  190.   /* Read markers until SOS or EOI.
  191.    * Returns same codes as are defined for jpeg_consume_input:
  192.    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
  193.    */
  194.   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
  195.   /* Read a restart marker --- exported for use by entropy decoder only */
  196.   jpeg_marker_parser_method read_restart_marker;
  197.   /* Application-overridable marker processing methods */
  198.   jpeg_marker_parser_method process_COM;
  199.   jpeg_marker_parser_method process_APPn[16];
  200.  
  201.   /* State of marker reader --- nominally internal, but applications
  202.    * supplying COM or APPn handlers might like to know the state.
  203.    */
  204.   boolean saw_SOI;        /* found SOI? */
  205.   boolean saw_SOF;        /* found SOF? */
  206.   int next_restart_num;        /* next restart number expected (0-7) */
  207.   unsigned int discarded_bytes;    /* # of bytes skipped looking for a marker */
  208. };
  209.  
  210. /* Entropy decoding */
  211. struct jpeg_entropy_decoder {
  212.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  213.   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
  214.                 JBLOCKROW *MCU_data));
  215. };
  216.  
  217. /* Inverse DCT (also performs dequantization) */
  218. typedef JMETHOD(void, inverse_DCT_method_ptr,
  219.         (j_decompress_ptr cinfo, jpeg_component_info * compptr,
  220.          JCOEFPTR coef_block,
  221.          JSAMPARRAY output_buf, JDIMENSION output_col));
  222.  
  223. struct jpeg_inverse_dct {
  224.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  225.   /* It is useful to allow each component to have a separate IDCT method. */
  226.   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
  227. };
  228.  
  229. /* Upsampling (note that upsampler must also call color converter) */
  230. struct jpeg_upsampler {
  231.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  232.   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
  233.                JSAMPIMAGE input_buf,
  234.                JDIMENSION *in_row_group_ctr,
  235.                JDIMENSION in_row_groups_avail,
  236.                JSAMPARRAY output_buf,
  237.                JDIMENSION *out_row_ctr,
  238.                JDIMENSION out_rows_avail));
  239.  
  240.   boolean need_context_rows;    /* TRUE if need rows above & below */
  241. };
  242.  
  243. /* Colorspace conversion */
  244. struct jpeg_color_deconverter {
  245.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  246.   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
  247.                 JSAMPIMAGE input_buf, JDIMENSION input_row,
  248.                 JSAMPARRAY output_buf, int num_rows));
  249. };
  250.  
  251. /* Color quantization or color precision reduction */
  252. struct jpeg_color_quantizer {
  253.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
  254.   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
  255.                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
  256.                  int num_rows));
  257.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  258.   JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
  259. };
  260.  
  261.  
  262. /* Miscellaneous useful macros */
  263.  
  264. #undef MAX
  265. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  266. #undef MIN
  267. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  268.  
  269.  
  270. /* We assume that right shift corresponds to signed division by 2 with
  271.  * rounding towards minus infinity.  This is correct for typical "arithmetic
  272.  * shift" instructions that shift in copies of the sign bit.  But some
  273.  * C compilers implement >> with an unsigned shift.  For these machines you
  274.  * must define RIGHT_SHIFT_IS_UNSIGNED.
  275.  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
  276.  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
  277.  * included in the variables of any routine using RIGHT_SHIFT.
  278.  */
  279.  
  280. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  281. #define SHIFT_TEMPS    INT32 shift_temp;
  282. #define RIGHT_SHIFT(x,shft)  \
  283.     ((shift_temp = (x)) < 0 ? \
  284.      (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
  285.      (shift_temp >> (shft)))
  286. #else
  287. #define SHIFT_TEMPS
  288. #define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
  289. #endif
  290.  
  291.  
  292. /* Short forms of external names for systems with brain-damaged linkers. */
  293.  
  294. #ifdef NEED_SHORT_EXTERNAL_NAMES
  295. #define jinit_compress_master    jICompress
  296. #define jinit_c_master_control    jICMaster
  297. #define jinit_c_main_controller    jICMainC
  298. #define jinit_c_prep_controller    jICPrepC
  299. #define jinit_c_coef_controller    jICCoefC
  300. #define jinit_color_converter    jICColor
  301. #define jinit_downsampler    jIDownsampler
  302. #define jinit_forward_dct    jIFDCT
  303. #define jinit_huff_encoder    jIHEncoder
  304. #define jinit_phuff_encoder    jIPHEncoder
  305. #define jinit_marker_writer    jIMWriter
  306. #define jinit_master_decompress    jIDMaster
  307. #define jinit_d_main_controller    jIDMainC
  308. #define jinit_d_coef_controller    jIDCoefC
  309. #define jinit_d_post_controller    jIDPostC
  310. #define jinit_input_controller    jIInCtlr
  311. #define jinit_marker_reader    jIMReader
  312. #define jinit_huff_decoder    jIHDecoder
  313. #define jinit_phuff_decoder    jIPHDecoder
  314. #define jinit_inverse_dct    jIIDCT
  315. #define jinit_upsampler        jIUpsampler
  316. #define jinit_color_deconverter    jIDColor
  317. #define jinit_1pass_quantizer    jI1Quant
  318. #define jinit_2pass_quantizer    jI2Quant
  319. #define jinit_merged_upsampler    jIMUpsampler
  320. #define jinit_memory_mgr    jIMemMgr
  321. #define jdiv_round_up        jDivRound
  322. #define jround_up        jRound
  323. #define jcopy_sample_rows    jCopySamples
  324. #define jcopy_block_row        jCopyBlocks
  325. #define jzero_far        jZeroFar
  326. #define jpeg_zigzag_order    jZIGTable
  327. #define jpeg_natural_order    jZAGTable
  328. #endif /* NEED_SHORT_EXTERNAL_NAMES */
  329.  
  330.  
  331. /* Compression module initialization routines */
  332. EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
  333. EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
  334.                      boolean transcode_only));
  335. EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
  336.                       boolean need_full_buffer));
  337. EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
  338.                       boolean need_full_buffer));
  339. EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
  340.                       boolean need_full_buffer));
  341. EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
  342. EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
  343. EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
  344. EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
  345. EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
  346. EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
  347. /* Decompression module initialization routines */
  348. EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
  349. EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
  350.                       boolean need_full_buffer));
  351. EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
  352.                       boolean need_full_buffer));
  353. EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
  354.                       boolean need_full_buffer));
  355. EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
  356. EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
  357. EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
  358. EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
  359. EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
  360. EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
  361. EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
  362. EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
  363. EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
  364. EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
  365. /* Memory manager initialization */
  366. EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
  367.  
  368. /* Utility routines in jutils.c */
  369. #ifdef MACRO_JUTILS
  370. #define jdiv_round_up(a, b)  (((a) + (b) - 1L) / (b))
  371. #define jzero_far  MEMZERO
  372. #else
  373. EXTERN(long) jdiv_round_up JPP((long a, long b));
  374. EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
  375. #endif
  376.  
  377. EXTERN(long) jround_up JPP((long a, long b));
  378. EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
  379.                     JSAMPARRAY output_array, int dest_row,
  380.                     int num_rows, JDIMENSION num_cols));
  381. EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
  382.                   JDIMENSION num_blocks));
  383.  
  384. /* Constant tables in jutils.c */
  385. extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
  386. extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
  387.  
  388. /* Suppress undefined-structure complaints if necessary. */
  389.  
  390. #ifdef INCOMPLETE_TYPES_BROKEN
  391. #ifndef AM_MEMORY_MANAGER    /* only jmemmgr.c defines these */
  392. struct jvirt_sarray_control { long dummy; };
  393. struct jvirt_barray_control { long dummy; };
  394. #endif
  395. #endif /* INCOMPLETE_TYPES_BROKEN */
  396.