home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / jpeg / jpegint.h < prev    next >
C/C++ Source or Header  |  2002-10-16  |  16KB  |  403 lines
  1. /*
  2.  * jpegint.h
  3.  *
  4.  * Copyright (C) 1991-1997, 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.   JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
  122.   JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
  123.   JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
  124.   JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
  125.   JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
  126.   /* These routines are exported to allow insertion of extra markers */
  127.   /* Probably only COM and APPn markers should be written this way */
  128.   JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
  129.                       unsigned int datalen));
  130.   JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
  131. };
  132.  
  133.  
  134. /* Declarations for decompression modules */
  135.  
  136. /* Master control module */
  137. struct jpeg_decomp_master {
  138.   JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
  139.   JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
  140.  
  141.   /* State variables made visible to other modules */
  142.   boolean is_dummy_pass;    /* True during 1st pass for 2-pass quant */
  143. };
  144.  
  145.  
  146. /* Input control module */
  147. struct jpeg_input_controller {
  148.   JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
  149.   JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
  150.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  151.   JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
  152.  
  153.   /* State variables made visible to other modules */
  154.   boolean has_multiple_scans;    /* True if file has multiple scans */
  155.   boolean eoi_reached;        /* True when EOI has been consumed */
  156. };
  157.  
  158.  
  159. /* Main buffer control (downsampled-data buffer) */
  160. struct jpeg_d_main_controller {
  161.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  162.   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
  163.                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  164.                    JDIMENSION out_rows_avail));
  165. };
  166.  
  167. /* Coefficient buffer control */
  168. struct jpeg_d_coef_controller {
  169. #if defined(__VISAGECPP__)
  170.   /* the start input pass in jdcoeft must have a different name than the
  171.   // one in jdtrans under VisualAge or else we get a dup symbol error
  172.   */
  173.   JMETHOD(void, start_input_pass2, (j_decompress_ptr cinfo));
  174. #else
  175.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  176. #endif
  177.  
  178.   JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
  179.   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
  180.   JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
  181.                  JSAMPIMAGE output_buf));
  182.   /* Pointer to array of coefficient virtual arrays, or NULL if none */
  183.   jvirt_barray_ptr *coef_arrays;
  184. };
  185.  
  186. /* Decompression postprocessing (color quantization buffer control) */
  187. struct jpeg_d_post_controller {
  188.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  189.   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
  190.                     JSAMPIMAGE input_buf,
  191.                     JDIMENSION *in_row_group_ctr,
  192.                     JDIMENSION in_row_groups_avail,
  193.                     JSAMPARRAY output_buf,
  194.                     JDIMENSION *out_row_ctr,
  195.                     JDIMENSION out_rows_avail));
  196. };
  197.  
  198. /* Marker reading & parsing */
  199. struct jpeg_marker_reader {
  200.   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
  201.   /* Read markers until SOS or EOI.
  202.    * Returns same codes as are defined for jpeg_consume_input:
  203.    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
  204.    */
  205.   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
  206.   /* Read a restart marker --- exported for use by entropy decoder only */
  207.   jpeg_marker_parser_method read_restart_marker;
  208.  
  209.   /* State of marker reader --- nominally internal, but applications
  210.    * supplying COM or APPn handlers might like to know the state.
  211.    */
  212.   boolean saw_SOI;        /* found SOI? */
  213.   boolean saw_SOF;        /* found SOF? */
  214.   int next_restart_num;        /* next restart number expected (0-7) */
  215.   unsigned int discarded_bytes;    /* # of bytes skipped looking for a marker */
  216. };
  217.  
  218. /* Entropy decoding */
  219. struct jpeg_entropy_decoder {
  220.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  221.   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
  222.                 JBLOCKROW *MCU_data));
  223.  
  224.   /* This is here to share code between baseline and progressive decoders; */
  225.   /* other modules probably should not use it */
  226.   boolean insufficient_data;    /* set TRUE after emitting warning */
  227. };
  228.  
  229. /* Inverse DCT (also performs dequantization) */
  230. typedef JMETHOD(void, inverse_DCT_method_ptr,
  231.         (j_decompress_ptr cinfo, jpeg_component_info * compptr,
  232.          JCOEFPTR coef_block,
  233.          JSAMPARRAY output_buf, JDIMENSION output_col));
  234.  
  235. struct jpeg_inverse_dct {
  236.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  237.   /* It is useful to allow each component to have a separate IDCT method. */
  238.   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
  239. };
  240.  
  241. /* Upsampling (note that upsampler must also call color converter) */
  242. struct jpeg_upsampler {
  243.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  244.   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
  245.                JSAMPIMAGE input_buf,
  246.                JDIMENSION *in_row_group_ctr,
  247.                JDIMENSION in_row_groups_avail,
  248.                JSAMPARRAY output_buf,
  249.                JDIMENSION *out_row_ctr,
  250.                JDIMENSION out_rows_avail));
  251.  
  252.   boolean need_context_rows;    /* TRUE if need rows above & below */
  253. };
  254.  
  255. /* Colorspace conversion */
  256. struct jpeg_color_deconverter {
  257.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  258.   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
  259.                 JSAMPIMAGE input_buf, JDIMENSION input_row,
  260.                 JSAMPARRAY output_buf, int num_rows));
  261. };
  262.  
  263. /* Color quantization or color precision reduction */
  264. struct jpeg_color_quantizer {
  265.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
  266.   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
  267.                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
  268.                  int num_rows));
  269.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  270.   JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
  271. };
  272.  
  273.  
  274. /* Miscellaneous useful macros */
  275.  
  276. #undef MAX
  277. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  278. #undef MIN
  279. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  280.  
  281.  
  282. /* We assume that right shift corresponds to signed division by 2 with
  283.  * rounding towards minus infinity.  This is correct for typical "arithmetic
  284.  * shift" instructions that shift in copies of the sign bit.  But some
  285.  * C compilers implement >> with an unsigned shift.  For these machines you
  286.  * must define RIGHT_SHIFT_IS_UNSIGNED.
  287.  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
  288.  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
  289.  * included in the variables of any routine using RIGHT_SHIFT.
  290.  */
  291.  
  292. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  293. #define SHIFT_TEMPS    JPEG_INT32 shift_temp;
  294. #define RIGHT_SHIFT(x,shft)  \
  295.     ((shift_temp = (x)) < 0 ? \
  296.      (shift_temp >> (shft)) | ((~((JPEG_INT32) 0)) << (32-(shft))) : \
  297.      (shift_temp >> (shft)))
  298. #else
  299. #define SHIFT_TEMPS
  300. #define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
  301. #endif
  302.  
  303.  
  304. /* Short forms of external names for systems with brain-damaged linkers. */
  305.  
  306. #ifdef NEED_SHORT_EXTERNAL_NAMES
  307. #define jinit_compress_master    jICompress
  308. #define jinit_c_master_control    jICMaster
  309. #define jinit_c_main_controller    jICMainC
  310. #define jinit_c_prep_controller    jICPrepC
  311. #define jinit_c_coef_controller    jICCoefC
  312. #define jinit_color_converter    jICColor
  313. #define jinit_downsampler    jIDownsampler
  314. #define jinit_forward_dct    jIFDCT
  315. #define jinit_huff_encoder    jIHEncoder
  316. #define jinit_phuff_encoder    jIPHEncoder
  317. #define jinit_marker_writer    jIMWriter
  318. #define jinit_master_decompress    jIDMaster
  319. #define jinit_d_main_controller    jIDMainC
  320. #define jinit_d_coef_controller    jIDCoefC
  321. #define jinit_d_post_controller    jIDPostC
  322. #define jinit_input_controller    jIInCtlr
  323. #define jinit_marker_reader    jIMReader
  324. #define jinit_huff_decoder    jIHDecoder
  325. #define jinit_phuff_decoder    jIPHDecoder
  326. #define jinit_inverse_dct    jIIDCT
  327. #define jinit_upsampler        jIUpsampler
  328. #define jinit_color_deconverter    jIDColor
  329. #define jinit_1pass_quantizer    jI1Quant
  330. #define jinit_2pass_quantizer    jI2Quant
  331. #define jinit_merged_upsampler    jIMUpsampler
  332. #define jinit_memory_mgr    jIMemMgr
  333. #define jdiv_round_up        jDivRound
  334. #define jround_up        jRound
  335. #define jcopy_sample_rows    jCopySamples
  336. #define jcopy_block_row        jCopyBlocks
  337. #define jzero_far        jZeroFar
  338. #define jpeg_zigzag_order    jZIGTable
  339. #define jpeg_natural_order    jZAGTable
  340. #endif /* NEED_SHORT_EXTERNAL_NAMES */
  341.  
  342.  
  343. /* Compression module initialization routines */
  344. EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
  345. EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
  346.                      boolean transcode_only));
  347. EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
  348.                       boolean need_full_buffer));
  349. EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
  350.                       boolean need_full_buffer));
  351. EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
  352.                       boolean need_full_buffer));
  353. EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
  354. EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
  355. EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
  356. EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
  357. EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
  358. EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
  359. /* Decompression module initialization routines */
  360. EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
  361. EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
  362.                       boolean need_full_buffer));
  363. EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
  364.                       boolean need_full_buffer));
  365. EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
  366.                       boolean need_full_buffer));
  367. EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
  368. EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
  369. EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
  370. EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
  371. EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
  372. EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
  373. EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
  374. EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
  375. EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
  376. EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
  377. /* Memory manager initialization */
  378. EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
  379.  
  380. /* Utility routines in jutils.c */
  381. EXTERN(long) jdiv_round_up JPP((long a, long b));
  382. EXTERN(long) jround_up JPP((long a, long b));
  383. EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
  384.                     JSAMPARRAY output_array, int dest_row,
  385.                     int num_rows, JDIMENSION num_cols));
  386. EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
  387.                   JDIMENSION num_blocks));
  388. EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
  389. /* Constant tables in jutils.c */
  390. #if 0                /* This table is not actually needed in v6a */
  391. extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
  392. #endif
  393. extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
  394.  
  395. /* Suppress undefined-structure complaints if necessary. */
  396.  
  397. #ifdef INCOMPLETE_TYPES_BROKEN
  398. #ifndef AM_MEMORY_MANAGER    /* only jmemmgr.c defines these */
  399. struct jvirt_sarray_control { long dummy; };
  400. struct jvirt_barray_control { long dummy; };
  401. #endif
  402. #endif /* INCOMPLETE_TYPES_BROKEN */
  403.