JPEGINT.h
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:16k
源码类别:

网络截获/分析

开发平台:

Visual C++

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