falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2823 Commits
17 Branches
341MB
Tree: 9fe25d90f6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9fe25d90f6'
${ noResults }
Carla/source/modules/juce_graphics/image_formats/jpglib/jpegint.h

393 lines
16KB
Raw Blame History 

  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. /* Input control module */

  146. struct jpeg_input_controller {

  147.   JMETHOD(int, consume_input, (j_decompress_ptr cinfo));

  148.   JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));

  149.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));

  150.   JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));

  151. 

  152.   /* State variables made visible to other modules */

  153.   boolean has_multiple_scans;	/* True if file has multiple scans */

  154.   boolean eoi_reached;		/* True when EOI has been consumed */

  155. };

  156. 

  157. /* Main buffer control (downsampled-data buffer) */

  158. struct jpeg_d_main_controller {

  159.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));

  160.   JMETHOD(void, process_data, (j_decompress_ptr cinfo,

  161. 			       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,

  162. 			       JDIMENSION out_rows_avail));

  163. };

  164. 

  165. /* Coefficient buffer control */

  166. struct jpeg_d_coef_controller {

  167.   JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));

  168.   JMETHOD(int, consume_data, (j_decompress_ptr cinfo));

  169.   JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));

  170.   JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,

  171. 				 JSAMPIMAGE output_buf));

  172.   /* Pointer to array of coefficient virtual arrays, or NULL if none */

  173.   jvirt_barray_ptr *coef_arrays;

  174. };

  175. 

  176. /* Decompression postprocessing (color quantization buffer control) */

  177. struct jpeg_d_post_controller {

  178.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));

  179.   JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,

  180. 				    JSAMPIMAGE input_buf,

  181. 				    JDIMENSION *in_row_group_ctr,

  182. 				    JDIMENSION in_row_groups_avail,

  183. 				    JSAMPARRAY output_buf,

  184. 				    JDIMENSION *out_row_ctr,

  185. 				    JDIMENSION out_rows_avail));

  186. };

  187. 

  188. /* Marker reading & parsing */

  189. struct jpeg_marker_reader {

  190.   JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));

  191.   /* Read markers until SOS or EOI.

  192.    * Returns same codes as are defined for jpeg_consume_input:

  193.    * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.

  194.    */

  195.   JMETHOD(int, read_markers, (j_decompress_ptr cinfo));

  196.   /* Read a restart marker --- exported for use by entropy decoder only */

  197.   jpeg_marker_parser_method read_restart_marker;

  198. 

  199.   /* State of marker reader --- nominally internal, but applications

  200.    * supplying COM or APPn handlers might like to know the state.

  201.    */

  202.   boolean saw_SOI;		/* found SOI? */

  203.   boolean saw_SOF;		/* found SOF? */

  204.   int next_restart_num;		/* next restart number expected (0-7) */

  205.   unsigned int discarded_bytes;	/* # of bytes skipped looking for a marker */

  206. };

  207. 

  208. /* Entropy decoding */

  209. struct jpeg_entropy_decoder {

  210.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));

  211.   JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,

  212. 				JBLOCKROW *MCU_data));

  213. 

  214.   /* This is here to share code between baseline and progressive decoders; */

  215.   /* other modules probably should not use it */

  216.   boolean insufficient_data;	/* set TRUE after emitting warning */

  217. };

  218. 

  219. /* Inverse DCT (also performs dequantization) */

  220. typedef JMETHOD(void, inverse_DCT_method_ptr,

  221. 		(j_decompress_ptr cinfo, jpeg_component_info * compptr,

  222. 		 JCOEFPTR coef_block,

  223. 		 JSAMPARRAY output_buf, JDIMENSION output_col));

  224. 

  225. struct jpeg_inverse_dct {

  226.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));

  227.   /* It is useful to allow each component to have a separate IDCT method. */

  228.   inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];

  229. };

  230. 

  231. /* Upsampling (note that upsampler must also call color converter) */

  232. struct jpeg_upsampler {

  233.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));

  234.   JMETHOD(void, upsample, (j_decompress_ptr cinfo,

  235. 			   JSAMPIMAGE input_buf,

  236. 			   JDIMENSION *in_row_group_ctr,

  237. 			   JDIMENSION in_row_groups_avail,

  238. 			   JSAMPARRAY output_buf,

  239. 			   JDIMENSION *out_row_ctr,

  240. 			   JDIMENSION out_rows_avail));

  241. 

  242.   boolean need_context_rows;	/* TRUE if need rows above & below */

  243. };

  244. 

  245. /* Colorspace conversion */

  246. struct jpeg_color_deconverter {

  247.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo));

  248.   JMETHOD(void, color_convert, (j_decompress_ptr cinfo,

  249. 				JSAMPIMAGE input_buf, JDIMENSION input_row,

  250. 				JSAMPARRAY output_buf, int num_rows));

  251. };

  252. 

  253. /* Color quantization or color precision reduction */

  254. struct jpeg_color_quantizer {

  255.   JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));

  256.   JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,

  257. 				 JSAMPARRAY input_buf, JSAMPARRAY output_buf,

  258. 				 int num_rows));

  259.   JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));

  260.   JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));

  261. };

  262. 

  263. 

  264. /* Miscellaneous useful macros */

  265. 

  266. #undef MAX

  267. #define MAX(a,b)	((a) > (b) ? (a) : (b))

  268. #undef MIN

  269. #define MIN(a,b)	((a) < (b) ? (a) : (b))

  270. 

  271. 

  272. /* We assume that right shift corresponds to signed division by 2 with

  273.  * rounding towards minus infinity.  This is correct for typical "arithmetic

  274.  * shift" instructions that shift in copies of the sign bit.  But some

  275.  * C compilers implement >> with an unsigned shift.  For these machines you

  276.  * must define RIGHT_SHIFT_IS_UNSIGNED.

  277.  * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.

  278.  * It is only applied with constant shift counts.  SHIFT_TEMPS must be

  279.  * included in the variables of any routine using RIGHT_SHIFT.

  280.  */

  281. 

  282. #ifdef RIGHT_SHIFT_IS_UNSIGNED

  283. #define SHIFT_TEMPS	INT32 shift_temp;

  284. #define RIGHT_SHIFT(x,shft)  \

  285. 	((shift_temp = (x)) < 0 ? \

  286. 	 (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \

  287. 	 (shift_temp >> (shft)))

  288. #else

  289. #define SHIFT_TEMPS

  290. #define RIGHT_SHIFT(x,shft)	((x) >> (shft))

  291. #endif

  292. 

  293. 

  294. /* Short forms of external names for systems with brain-damaged linkers. */

  295. 

  296. #ifdef NEED_SHORT_EXTERNAL_NAMES

  297. #define jinit_compress_master	jICompress

  298. #define jinit_c_master_control	jICMaster

  299. #define jinit_c_main_controller	jICMainC

  300. #define jinit_c_prep_controller	jICPrepC

  301. #define jinit_c_coef_controller	jICCoefC

  302. #define jinit_color_converter	jICColor

  303. #define jinit_downsampler	jIDownsampler

  304. #define jinit_forward_dct	jIFDCT

  305. #define jinit_huff_encoder	jIHEncoder

  306. #define jinit_phuff_encoder	jIPHEncoder

  307. #define jinit_marker_writer	jIMWriter

  308. #define jinit_master_decompress	jIDMaster

  309. #define jinit_d_main_controller	jIDMainC

  310. #define jinit_d_coef_controller	jIDCoefC

  311. #define jinit_d_post_controller	jIDPostC

  312. #define jinit_input_controller	jIInCtlr

  313. #define jinit_marker_reader	jIMReader

  314. #define jinit_huff_decoder	jIHDecoder

  315. #define jinit_phuff_decoder	jIPHDecoder

  316. #define jinit_inverse_dct	jIIDCT

  317. #define jinit_upsampler		jIUpsampler

  318. #define jinit_color_deconverter	jIDColor

  319. #define jinit_1pass_quantizer	jI1Quant

  320. #define jinit_2pass_quantizer	jI2Quant

  321. #define jinit_merged_upsampler	jIMUpsampler

  322. #define jinit_memory_mgr	jIMemMgr

  323. #define jdiv_round_up		jDivRound

  324. #define jround_up		jRound

  325. #define jcopy_sample_rows	jCopySamples

  326. #define jcopy_block_row		jCopyBlocks

  327. #define jzero_far		jZeroFar

  328. #define jpeg_zigzag_order	jZIGTable

  329. #define jpeg_natural_order	jZAGTable

  330. #endif /* NEED_SHORT_EXTERNAL_NAMES */

  331. 

  332. 

  333. /* Compression module initialization routines */

  334. EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));

  335. EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,

  336. 					 boolean transcode_only));

  337. EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,

  338. 					  boolean need_full_buffer));

  339. EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,

  340. 					  boolean need_full_buffer));

  341. EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,

  342. 					  boolean need_full_buffer));

  343. EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));

  344. EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));

  345. EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));

  346. EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));

  347. EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));

  348. EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));

  349. /* Decompression module initialization routines */

  350. EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));

  351. EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,

  352. 					  boolean need_full_buffer));

  353. EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,

  354. 					  boolean need_full_buffer));

  355. EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,

  356. 					  boolean need_full_buffer));

  357. EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));

  358. EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));

  359. EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));

  360. EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));

  361. EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));

  362. EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));

  363. EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));

  364. EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));

  365. EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));

  366. EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));

  367. /* Memory manager initialization */

  368. EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));

  369. 

  370. /* Utility routines in jutils.c */

  371. EXTERN(long) jdiv_round_up JPP((long a, long b));

  372. EXTERN(long) jround_up JPP((long a, long b));

  373. EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,

  374. 				    JSAMPARRAY output_array, int dest_row,

  375. 				    int num_rows, JDIMENSION num_cols));

  376. EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,

  377. 				  JDIMENSION num_blocks));

  378. EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));

  379. /* Constant tables in jutils.c */

  380. #if 0				/* This table is not actually needed in v6a */

  381. extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */

  382. #endif

  383. extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */

  384. 

  385. /* Suppress undefined-structure complaints if necessary. */

  386. 

  387. #ifdef INCOMPLETE_TYPES_BROKEN

  388. #ifndef AM_MEMORY_MANAGER	/* only jmemmgr.c defines these */

  389. struct jvirt_sarray_control { long dummy; };

  390. struct jvirt_barray_control { long dummy; };

  391. #endif

  392. #endif /* INCOMPLETE_TYPES_BROKEN */