home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 5 / ctrom5b.zip / ctrom5b / DOS / GRAFISCH / JPGSRC5A / JPEGINT.H < prev    next >
C/C++ Source or Header  |  1994-07-07  |  14KB  |  362 lines
  1. /*
  2.  * jpegint.h
  3.  *
  4.  * Copyright (C) 1991-1994, 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.     JBUF_CRANK_SOURCE,    /* Run source subobject, no output expected */
  19.     /* Remaining modes require a full-image buffer to have been created */
  20.     JBUF_SAVE_SOURCE,    /* Run source subobject only, save output */
  21.     JBUF_CRANK_DEST,    /* Run dest subobject only, using saved data */
  22.     JBUF_SAVE_AND_PASS    /* Run both subobjects, save output */
  23. } J_BUF_MODE;
  24.  
  25. /* Values of global_state field */
  26. #define CSTATE_START    100    /* after create_compress */
  27. #define CSTATE_SCANNING    101    /* start_compress done, write_scanlines OK */
  28. #define CSTATE_RAW_OK    102    /* start_compress done, write_raw_data OK */
  29. #define DSTATE_START    200    /* after create_decompress */
  30. #define DSTATE_INHEADER    201    /* read_header initialized but not done */
  31. #define DSTATE_READY    202    /* read_header done, found image */
  32. #define DSTATE_SCANNING    203    /* start_decompress done, read_scanlines OK */
  33. #define DSTATE_RAW_OK    204    /* start_decompress done, read_raw_data OK */
  34. #define DSTATE_STOPPING    205    /* done reading data, looking for EOI */
  35.  
  36.  
  37. /* Declarations for compression modules */
  38.  
  39. /* Master control module */
  40. struct jpeg_comp_master {
  41.   JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
  42.   JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
  43.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  44.  
  45.   /* State variables made visible to other modules */
  46.   boolean call_pass_startup;    /* True if pass_startup must be called */
  47.   boolean is_last_pass;        /* True during last pass */
  48. };
  49.  
  50. /* Main buffer control (downsampled-data buffer) */
  51. struct jpeg_c_main_controller {
  52.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  53.   JMETHOD(void, process_data, (j_compress_ptr cinfo,
  54.                    JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
  55.                    JDIMENSION in_rows_avail));
  56. };
  57.  
  58. /* Compression preprocessing (downsampling input buffer control) */
  59. struct jpeg_c_prep_controller {
  60.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  61.   JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
  62.                    JSAMPARRAY input_buf,
  63.                    JDIMENSION *in_row_ctr,
  64.                    JDIMENSION in_rows_avail,
  65.                    JSAMPIMAGE output_buf,
  66.                    JDIMENSION *out_row_group_ctr,
  67.                    JDIMENSION out_row_groups_avail));
  68. };
  69.  
  70. /* Coefficient buffer control */
  71. struct jpeg_c_coef_controller {
  72.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
  73.   JMETHOD(void, compress_data, (j_compress_ptr cinfo,
  74.                 JSAMPIMAGE input_buf,
  75.                 JDIMENSION *in_mcu_ctr));
  76. };
  77.  
  78. /* Colorspace conversion */
  79. struct jpeg_color_converter {
  80.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  81.   JMETHOD(void, color_convert, (j_compress_ptr cinfo,
  82.                 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
  83.                 JDIMENSION output_row, int num_rows));
  84. };
  85.  
  86. /* Downsampling */
  87. struct jpeg_downsampler {
  88.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  89.   JMETHOD(void, downsample, (j_compress_ptr cinfo,
  90.                  JSAMPIMAGE input_buf, JDIMENSION in_row_index,
  91.                  JSAMPIMAGE output_buf,
  92.                  JDIMENSION out_row_group_index));
  93.  
  94.   boolean need_context_rows;    /* TRUE if need rows above & below */
  95. };
  96.  
  97. /* Forward DCT (also controls coefficient quantization) */
  98. struct jpeg_forward_dct {
  99.   JMETHOD(void, start_pass, (j_compress_ptr cinfo));
  100.   /* perhaps this should be an array??? */
  101.   JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
  102.                   jpeg_component_info * compptr,
  103.                   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
  104.                   JDIMENSION start_row, JDIMENSION start_col,
  105.                   JDIMENSION num_blocks));
  106. };
  107.  
  108. /* Entropy encoding */
  109. struct jpeg_entropy_encoder {
  110.   JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
  111.   JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
  112.   JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
  113. };
  114.  
  115. /* Marker writing */
  116. struct jpeg_marker_writer {
  117.   /* write_any_marker is exported for use by applications */
  118.   /* Probably only COM and APPn markers should be written */
  119.   JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
  120.                    const JOCTET *dataptr, unsigned int datalen));
  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. };
  127.  
  128.  
  129. /* Declarations for decompression modules */
  130.  
  131. /* Master control module */
  132. struct jpeg_decomp_master {
  133.   JMETHOD(void, prepare_for_pass, (j_decompress_ptr cinfo));
  134.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  135.  
  136.   /* State variables made visible to other modules */
  137.   boolean is_last_pass;        /* True during last pass */
  138.   boolean eoi_processed;    /* True if EOI marker already read */
  139. };
  140.  
  141. /* Main buffer control (downsampled-data buffer) */
  142. struct jpeg_d_main_controller {
  143.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  144.   JMETHOD(void, process_data, (j_decompress_ptr cinfo,
  145.                    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
  146.                    JDIMENSION out_rows_avail));
  147.   /* During input-only passes, output_buf and out_rows_avail are ignored.
  148.    * out_row_ctr is incremented towards the limit num_chunks.
  149.    */
  150.   JDIMENSION num_chunks;    /* number of chunks to be processed in pass */
  151. };
  152.  
  153. /* Coefficient buffer control */
  154. struct jpeg_d_coef_controller {
  155.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  156.   JMETHOD(boolean, decompress_data, (j_decompress_ptr cinfo,
  157.                      JSAMPIMAGE output_buf));
  158. };
  159.  
  160. /* Decompression postprocessing (color quantization buffer control) */
  161. struct jpeg_d_post_controller {
  162.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
  163.   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
  164.                     JSAMPIMAGE input_buf,
  165.                     JDIMENSION *in_row_group_ctr,
  166.                     JDIMENSION in_row_groups_avail,
  167.                     JSAMPARRAY output_buf,
  168.                     JDIMENSION *out_row_ctr,
  169.                     JDIMENSION out_rows_avail));
  170. };
  171.  
  172. /* Marker reading & parsing */
  173. struct jpeg_marker_reader {
  174.   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
  175.   /* Read markers until SOS or EOI.
  176.    * Returns same codes as are defined for jpeg_read_header,
  177.    * but HEADER_OK and HEADER_TABLES_ONLY merely indicate which marker type
  178.    * stopped the scan --- further validation is needed to declare file OK.
  179.    */
  180.   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
  181.   /* Read a restart marker --- exported for use by entropy decoder only */
  182.   jpeg_marker_parser_method read_restart_marker;
  183.   /* Application-overridable marker processing methods */
  184.   jpeg_marker_parser_method process_COM;
  185.   jpeg_marker_parser_method process_APPn[16];
  186.  
  187.   /* State of marker reader --- nominally internal, but applications
  188.    * supplying COM or APPn handlers might like to know the state.
  189.    */
  190.   boolean saw_SOI;        /* found SOI? */
  191.   boolean saw_SOF;        /* found SOF? */
  192.   int next_restart_num;        /* next restart number expected (0-7) */
  193.   unsigned int discarded_bytes;    /* # of bytes skipped looking for a marker */
  194. };
  195.  
  196. /* Entropy decoding */
  197. struct jpeg_entropy_decoder {
  198.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  199.   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
  200.                 JBLOCKROW *MCU_data));
  201. };
  202.  
  203. /* Inverse DCT (also performs dequantization) */
  204. typedef JMETHOD(void, inverse_DCT_method_ptr,
  205.         (j_decompress_ptr cinfo, jpeg_component_info * compptr,
  206.          JCOEFPTR coef_block,
  207.          JSAMPARRAY output_buf, JDIMENSION output_col));
  208.  
  209. struct jpeg_inverse_dct {
  210.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
  211.   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
  212.   /* It is useful to allow each component to have a separate IDCT method. */
  213.   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
  214. };
  215.  
  216. /* Upsampling (note that upsampler must also call color converter) */
  217. struct jpeg_upsampler {
  218.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  219.   JMETHOD(void, upsample, (j_decompress_ptr cinfo,
  220.                JSAMPIMAGE input_buf,
  221.                JDIMENSION *in_row_group_ctr,
  222.                JDIMENSION in_row_groups_avail,
  223.                JSAMPARRAY output_buf,
  224.                JDIMENSION *out_row_ctr,
  225.                JDIMENSION out_rows_avail));
  226.  
  227.   boolean need_context_rows;    /* TRUE if need rows above & below */
  228. };
  229.  
  230. /* Colorspace conversion */
  231. struct jpeg_color_deconverter {
  232.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
  233.   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
  234.                 JSAMPIMAGE input_buf, JDIMENSION input_row,
  235.                 JSAMPARRAY output_buf, int num_rows));
  236. };
  237.  
  238. /* Color quantization or color precision reduction */
  239. struct jpeg_color_quantizer {
  240.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
  241.   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
  242.                  JSAMPARRAY input_buf, JSAMPARRAY output_buf,
  243.                  int num_rows));
  244.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
  245. };
  246.  
  247.  
  248. /* Miscellaneous useful macros */
  249.  
  250. #undef MAX
  251. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  252. #undef MIN
  253. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  254.  
  255.  
  256. /* We assume that right shift corresponds to signed division by 2 with
  257.  * rounding towards minus infinity.  This is correct for typical "arithmetic
  258.  * shift" instructions that shift in copies of the sign bit.  But some
  259.  * C compilers implement >> with an unsigned shift.  For these machines you
  260.  * must define RIGHT_SHIFT_IS_UNSIGNED.
  261.  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
  262.  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
  263.  * included in the variables of any routine using RIGHT_SHIFT.
  264.  */
  265.  
  266. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  267. #define SHIFT_TEMPS    INT32 shift_temp;
  268. #define RIGHT_SHIFT(x,shft)  \
  269.     ((shift_temp = (x)) < 0 ? \
  270.      (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
  271.      (shift_temp >> (shft)))
  272. #else
  273. #define SHIFT_TEMPS
  274. #define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
  275. #endif
  276.  
  277.  
  278. /* Short forms of external names for systems with brain-damaged linkers. */
  279.  
  280. #ifdef NEED_SHORT_EXTERNAL_NAMES
  281. #define jinit_master_compress    jICMaster
  282. #define jinit_c_main_controller    jICMainC
  283. #define jinit_c_prep_controller    jICPrepC
  284. #define jinit_c_coef_controller    jICCoefC
  285. #define jinit_color_converter    jICColor
  286. #define jinit_downsampler    jIDownsampler
  287. #define jinit_forward_dct    jIFDCT
  288. #define jinit_huff_encoder    jIHEncoder
  289. #define jinit_marker_writer    jIMWriter
  290. #define jinit_master_decompress    jIDMaster
  291. #define jinit_d_main_controller    jIDMainC
  292. #define jinit_d_coef_controller    jIDCoefC
  293. #define jinit_d_post_controller    jIDPostC
  294. #define jinit_marker_reader    jIMReader
  295. #define jinit_huff_decoder    jIHDecoder
  296. #define jinit_inverse_dct    jIIDCT
  297. #define jinit_upsampler        jIUpsampler
  298. #define jinit_color_deconverter    jIDColor
  299. #define jinit_1pass_quantizer    jI1Quant
  300. #define jinit_2pass_quantizer    jI2Quant
  301. #define jinit_merged_upsampler    jIMUpsampler
  302. #define jinit_memory_mgr    jIMemMgr
  303. #define jdiv_round_up        jDivRound
  304. #define jround_up        jRound
  305. #define jcopy_sample_rows    jCopySamples
  306. #define jcopy_block_row        jCopyBlocks
  307. #define jzero_far        jZeroFar
  308. #endif /* NEED_SHORT_EXTERNAL_NAMES */
  309.  
  310.  
  311. /* Compression module initialization routines */
  312. EXTERN void jinit_master_compress JPP((j_compress_ptr cinfo));
  313. EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo,
  314.                      boolean need_full_buffer));
  315. EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo,
  316.                      boolean need_full_buffer));
  317. EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo,
  318.                      boolean need_full_buffer));
  319. EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo));
  320. EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo));
  321. EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo));
  322. EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo));
  323. EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo));
  324. /* Decompression module initialization routines */
  325. EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo));
  326. EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo,
  327.                      boolean need_full_buffer));
  328. EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
  329.                      boolean need_full_buffer));
  330. EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo,
  331.                      boolean need_full_buffer));
  332. EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo));
  333. EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo));
  334. EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo));
  335. EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo));
  336. EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo));
  337. EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
  338. EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
  339. EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
  340. /* Memory manager initialization */
  341. EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo));
  342.  
  343. /* Utility routines in jutils.c */
  344. EXTERN long jdiv_round_up JPP((long a, long b));
  345. EXTERN long jround_up JPP((long a, long b));
  346. EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
  347.                    JSAMPARRAY output_array, int dest_row,
  348.                    int num_rows, JDIMENSION num_cols));
  349. EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
  350.                  JDIMENSION num_blocks));
  351. EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero));
  352.  
  353.  
  354. /* Suppress undefined-structure complaints if necessary. */
  355.  
  356. #ifdef INCOMPLETE_TYPES_BROKEN
  357. #ifndef AM_MEMORY_MANAGER    /* only jmemmgr.c defines these */
  358. struct jvirt_sarray_control { long dummy; };
  359. struct jvirt_barray_control { long dummy; };
  360. #endif
  361. #endif /* INCOMPLETE_TYPES_BROKEN */
  362.