jpeglib.h 49 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132
  1. /*
  2. * jpeglib.h
  3. *
  4. * This file was part of the Independent JPEG Group's software:
  5. * Copyright (C) 1991-1998, Thomas G. Lane.
  6. * Modified 2002-2009 by Guido Vollbeding.
  7. * libjpeg-turbo Modifications:
  8. * Copyright (C) 2009-2011, 2013-2014, 2016-2017, D. R. Commander.
  9. * Copyright (C) 2015, Google, Inc.
  10. * For conditions of distribution and use, see the accompanying README.ijg
  11. * file.
  12. *
  13. * This file defines the application interface for the JPEG library.
  14. * Most applications using the library need only include this file,
  15. * and perhaps jerror.h if they want to know the exact error codes.
  16. */
  17. #ifndef JPEGLIB_H
  18. #define JPEGLIB_H
  19. /*
  20. * First we include the configuration files that record how this
  21. * installation of the JPEG library is set up. jconfig.h can be
  22. * generated automatically for many systems. jmorecfg.h contains
  23. * manual configuration options that most people need not worry about.
  24. */
  25. #ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */
  26. #include "jconfig.h" /* widely used configuration options */
  27. #endif
  28. #include "jmorecfg.h" /* seldom changed options */
  29. #ifdef __cplusplus
  30. #ifndef DONT_USE_EXTERN_C
  31. extern "C" {
  32. #endif
  33. #endif
  34. /* Various constants determining the sizes of things.
  35. * All of these are specified by the JPEG standard, so don't change them
  36. * if you want to be compatible.
  37. */
  38. #define DCTSIZE 8 /* The basic DCT block is 8x8 samples */
  39. #define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */
  40. #define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */
  41. #define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */
  42. #define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */
  43. #define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */
  44. #define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */
  45. /* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
  46. * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
  47. * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
  48. * to handle it. We even let you do this from the jconfig.h file. However,
  49. * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
  50. * sometimes emits noncompliant files doesn't mean you should too.
  51. */
  52. #define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */
  53. #ifndef D_MAX_BLOCKS_IN_MCU
  54. #define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */
  55. #endif
  56. /* Data structures for images (arrays of samples and of DCT coefficients).
  57. */
  58. typedef JSAMPLE *JSAMPROW; /* ptr to one image row of pixel samples. */
  59. typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */
  60. typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
  61. typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
  62. typedef JBLOCK *JBLOCKROW; /* pointer to one row of coefficient blocks */
  63. typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */
  64. typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */
  65. typedef JCOEF *JCOEFPTR; /* useful in a couple of places */
  66. /* Types for JPEG compression parameters and working tables. */
  67. /* DCT coefficient quantization tables. */
  68. typedef struct {
  69. /* This array gives the coefficient quantizers in natural array order
  70. * (not the zigzag order in which they are stored in a JPEG DQT marker).
  71. * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
  72. */
  73. UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */
  74. /* This field is used only during compression. It's initialized FALSE when
  75. * the table is created, and set TRUE when it's been output to the file.
  76. * You could suppress output of a table by setting this to TRUE.
  77. * (See jpeg_suppress_tables for an example.)
  78. */
  79. boolean sent_table; /* TRUE when table has been output */
  80. } JQUANT_TBL;
  81. /* Huffman coding tables. */
  82. typedef struct {
  83. /* These two fields directly represent the contents of a JPEG DHT marker */
  84. UINT8 bits[17]; /* bits[k] = # of symbols with codes of */
  85. /* length k bits; bits[0] is unused */
  86. UINT8 huffval[256]; /* The symbols, in order of incr code length */
  87. /* This field is used only during compression. It's initialized FALSE when
  88. * the table is created, and set TRUE when it's been output to the file.
  89. * You could suppress output of a table by setting this to TRUE.
  90. * (See jpeg_suppress_tables for an example.)
  91. */
  92. boolean sent_table; /* TRUE when table has been output */
  93. } JHUFF_TBL;
  94. /* Basic info about one component (color channel). */
  95. typedef struct {
  96. /* These values are fixed over the whole image. */
  97. /* For compression, they must be supplied by parameter setup; */
  98. /* for decompression, they are read from the SOF marker. */
  99. int component_id; /* identifier for this component (0..255) */
  100. int component_index; /* its index in SOF or cinfo->comp_info[] */
  101. int h_samp_factor; /* horizontal sampling factor (1..4) */
  102. int v_samp_factor; /* vertical sampling factor (1..4) */
  103. int quant_tbl_no; /* quantization table selector (0..3) */
  104. /* These values may vary between scans. */
  105. /* For compression, they must be supplied by parameter setup; */
  106. /* for decompression, they are read from the SOS marker. */
  107. /* The decompressor output side may not use these variables. */
  108. int dc_tbl_no; /* DC entropy table selector (0..3) */
  109. int ac_tbl_no; /* AC entropy table selector (0..3) */
  110. /* Remaining fields should be treated as private by applications. */
  111. /* These values are computed during compression or decompression startup: */
  112. /* Component's size in DCT blocks.
  113. * Any dummy blocks added to complete an MCU are not counted; therefore
  114. * these values do not depend on whether a scan is interleaved or not.
  115. */
  116. JDIMENSION width_in_blocks;
  117. JDIMENSION height_in_blocks;
  118. /* Size of a DCT block in samples. Always DCTSIZE for compression.
  119. * For decompression this is the size of the output from one DCT block,
  120. * reflecting any scaling we choose to apply during the IDCT step.
  121. * Values from 1 to 16 are supported.
  122. * Note that different components may receive different IDCT scalings.
  123. */
  124. #if JPEG_LIB_VERSION >= 70
  125. int DCT_h_scaled_size;
  126. int DCT_v_scaled_size;
  127. #else
  128. int DCT_scaled_size;
  129. #endif
  130. /* The downsampled dimensions are the component's actual, unpadded number
  131. * of samples at the main buffer (preprocessing/compression interface), thus
  132. * downsampled_width = ceil(image_width * Hi/Hmax)
  133. * and similarly for height. For decompression, IDCT scaling is included, so
  134. * downsampled_width = ceil(image_width * Hi/Hmax * DCT_[h_]scaled_size/DCTSIZE)
  135. */
  136. JDIMENSION downsampled_width; /* actual width in samples */
  137. JDIMENSION downsampled_height; /* actual height in samples */
  138. /* This flag is used only for decompression. In cases where some of the
  139. * components will be ignored (eg grayscale output from YCbCr image),
  140. * we can skip most computations for the unused components.
  141. */
  142. boolean component_needed; /* do we need the value of this component? */
  143. /* These values are computed before starting a scan of the component. */
  144. /* The decompressor output side may not use these variables. */
  145. int MCU_width; /* number of blocks per MCU, horizontally */
  146. int MCU_height; /* number of blocks per MCU, vertically */
  147. int MCU_blocks; /* MCU_width * MCU_height */
  148. int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_[h_]scaled_size */
  149. int last_col_width; /* # of non-dummy blocks across in last MCU */
  150. int last_row_height; /* # of non-dummy blocks down in last MCU */
  151. /* Saved quantization table for component; NULL if none yet saved.
  152. * See jdinput.c comments about the need for this information.
  153. * This field is currently used only for decompression.
  154. */
  155. JQUANT_TBL *quant_table;
  156. /* Private per-component storage for DCT or IDCT subsystem. */
  157. void *dct_table;
  158. } jpeg_component_info;
  159. /* The script for encoding a multiple-scan file is an array of these: */
  160. typedef struct {
  161. int comps_in_scan; /* number of components encoded in this scan */
  162. int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
  163. int Ss, Se; /* progressive JPEG spectral selection parms */
  164. int Ah, Al; /* progressive JPEG successive approx. parms */
  165. } jpeg_scan_info;
  166. /* The decompressor can save APPn and COM markers in a list of these: */
  167. typedef struct jpeg_marker_struct *jpeg_saved_marker_ptr;
  168. struct jpeg_marker_struct {
  169. jpeg_saved_marker_ptr next; /* next in list, or NULL */
  170. UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */
  171. unsigned int original_length; /* # bytes of data in the file */
  172. unsigned int data_length; /* # bytes of data saved at data[] */
  173. JOCTET *data; /* the data contained in the marker */
  174. /* the marker length word is not counted in data_length or original_length */
  175. };
  176. /* Known color spaces. */
  177. #define JCS_EXTENSIONS 1
  178. #define JCS_ALPHA_EXTENSIONS 1
  179. typedef enum {
  180. JCS_UNKNOWN, /* error/unspecified */
  181. JCS_GRAYSCALE, /* monochrome */
  182. JCS_RGB, /* red/green/blue as specified by the RGB_RED,
  183. RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros */
  184. JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */
  185. JCS_CMYK, /* C/M/Y/K */
  186. JCS_YCCK, /* Y/Cb/Cr/K */
  187. JCS_EXT_RGB, /* red/green/blue */
  188. JCS_EXT_RGBX, /* red/green/blue/x */
  189. JCS_EXT_BGR, /* blue/green/red */
  190. JCS_EXT_BGRX, /* blue/green/red/x */
  191. JCS_EXT_XBGR, /* x/blue/green/red */
  192. JCS_EXT_XRGB, /* x/red/green/blue */
  193. /* When out_color_space it set to JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,
  194. or JCS_EXT_XRGB during decompression, the X byte is undefined, and in
  195. order to ensure the best performance, libjpeg-turbo can set that byte to
  196. whatever value it wishes. Use the following colorspace constants to
  197. ensure that the X byte is set to 0xFF, so that it can be interpreted as an
  198. opaque alpha channel. */
  199. JCS_EXT_RGBA, /* red/green/blue/alpha */
  200. JCS_EXT_BGRA, /* blue/green/red/alpha */
  201. JCS_EXT_ABGR, /* alpha/blue/green/red */
  202. JCS_EXT_ARGB, /* alpha/red/green/blue */
  203. JCS_RGB565 /* 5-bit red/6-bit green/5-bit blue */
  204. } J_COLOR_SPACE;
  205. /* DCT/IDCT algorithm options. */
  206. typedef enum {
  207. JDCT_ISLOW, /* slow but accurate integer algorithm */
  208. JDCT_IFAST, /* faster, less accurate integer method */
  209. JDCT_FLOAT /* floating-point: accurate, fast on fast HW */
  210. } J_DCT_METHOD;
  211. #ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */
  212. #define JDCT_DEFAULT JDCT_ISLOW
  213. #endif
  214. #ifndef JDCT_FASTEST /* may be overridden in jconfig.h */
  215. #define JDCT_FASTEST JDCT_IFAST
  216. #endif
  217. /* Dithering options for decompression. */
  218. typedef enum {
  219. JDITHER_NONE, /* no dithering */
  220. JDITHER_ORDERED, /* simple ordered dither */
  221. JDITHER_FS /* Floyd-Steinberg error diffusion dither */
  222. } J_DITHER_MODE;
  223. /* Common fields between JPEG compression and decompression master structs. */
  224. #define jpeg_common_fields \
  225. struct jpeg_error_mgr *err; /* Error handler module */ \
  226. struct jpeg_memory_mgr *mem; /* Memory manager module */ \
  227. struct jpeg_progress_mgr *progress; /* Progress monitor, or NULL if none */ \
  228. void *client_data; /* Available for use by application */ \
  229. boolean is_decompressor; /* So common code can tell which is which */ \
  230. int global_state /* For checking call sequence validity */
  231. /* Routines that are to be used by both halves of the library are declared
  232. * to receive a pointer to this structure. There are no actual instances of
  233. * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
  234. */
  235. struct jpeg_common_struct {
  236. jpeg_common_fields; /* Fields common to both master struct types */
  237. /* Additional fields follow in an actual jpeg_compress_struct or
  238. * jpeg_decompress_struct. All three structs must agree on these
  239. * initial fields! (This would be a lot cleaner in C++.)
  240. */
  241. };
  242. typedef struct jpeg_common_struct *j_common_ptr;
  243. typedef struct jpeg_compress_struct *j_compress_ptr;
  244. typedef struct jpeg_decompress_struct *j_decompress_ptr;
  245. /* Master record for a compression instance */
  246. struct jpeg_compress_struct {
  247. jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */
  248. /* Destination for compressed data */
  249. struct jpeg_destination_mgr *dest;
  250. /* Description of source image --- these fields must be filled in by
  251. * outer application before starting compression. in_color_space must
  252. * be correct before you can even call jpeg_set_defaults().
  253. */
  254. JDIMENSION image_width; /* input image width */
  255. JDIMENSION image_height; /* input image height */
  256. int input_components; /* # of color components in input image */
  257. J_COLOR_SPACE in_color_space; /* colorspace of input image */
  258. double input_gamma; /* image gamma of input image */
  259. /* Compression parameters --- these fields must be set before calling
  260. * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to
  261. * initialize everything to reasonable defaults, then changing anything
  262. * the application specifically wants to change. That way you won't get
  263. * burnt when new parameters are added. Also note that there are several
  264. * helper routines to simplify changing parameters.
  265. */
  266. #if JPEG_LIB_VERSION >= 70
  267. unsigned int scale_num, scale_denom; /* fraction by which to scale image */
  268. JDIMENSION jpeg_width; /* scaled JPEG image width */
  269. JDIMENSION jpeg_height; /* scaled JPEG image height */
  270. /* Dimensions of actual JPEG image that will be written to file,
  271. * derived from input dimensions by scaling factors above.
  272. * These fields are computed by jpeg_start_compress().
  273. * You can also use jpeg_calc_jpeg_dimensions() to determine these values
  274. * in advance of calling jpeg_start_compress().
  275. */
  276. #endif
  277. int data_precision; /* bits of precision in image data */
  278. int num_components; /* # of color components in JPEG image */
  279. J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
  280. jpeg_component_info *comp_info;
  281. /* comp_info[i] describes component that appears i'th in SOF */
  282. JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
  283. #if JPEG_LIB_VERSION >= 70
  284. int q_scale_factor[NUM_QUANT_TBLS];
  285. #endif
  286. /* ptrs to coefficient quantization tables, or NULL if not defined,
  287. * and corresponding scale factors (percentage, initialized 100).
  288. */
  289. JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  290. JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  291. /* ptrs to Huffman coding tables, or NULL if not defined */
  292. UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  293. UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  294. UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
  295. int num_scans; /* # of entries in scan_info array */
  296. const jpeg_scan_info *scan_info; /* script for multi-scan file, or NULL */
  297. /* The default value of scan_info is NULL, which causes a single-scan
  298. * sequential JPEG file to be emitted. To create a multi-scan file,
  299. * set num_scans and scan_info to point to an array of scan definitions.
  300. */
  301. boolean raw_data_in; /* TRUE=caller supplies downsampled data */
  302. boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
  303. boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
  304. boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  305. #if JPEG_LIB_VERSION >= 70
  306. boolean do_fancy_downsampling; /* TRUE=apply fancy downsampling */
  307. #endif
  308. int smoothing_factor; /* 1..100, or 0 for no input smoothing */
  309. J_DCT_METHOD dct_method; /* DCT algorithm selector */
  310. /* The restart interval can be specified in absolute MCUs by setting
  311. * restart_interval, or in MCU rows by setting restart_in_rows
  312. * (in which case the correct restart_interval will be figured
  313. * for each scan).
  314. */
  315. unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
  316. int restart_in_rows; /* if > 0, MCU rows per restart interval */
  317. /* Parameters controlling emission of special markers. */
  318. boolean write_JFIF_header; /* should a JFIF marker be written? */
  319. UINT8 JFIF_major_version; /* What to write for the JFIF version number */
  320. UINT8 JFIF_minor_version;
  321. /* These three values are not used by the JPEG code, merely copied */
  322. /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */
  323. /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */
  324. /* ratio is defined by X_density/Y_density even when density_unit=0. */
  325. UINT8 density_unit; /* JFIF code for pixel size units */
  326. UINT16 X_density; /* Horizontal pixel density */
  327. UINT16 Y_density; /* Vertical pixel density */
  328. boolean write_Adobe_marker; /* should an Adobe marker be written? */
  329. /* State variable: index of next scanline to be written to
  330. * jpeg_write_scanlines(). Application may use this to control its
  331. * processing loop, e.g., "while (next_scanline < image_height)".
  332. */
  333. JDIMENSION next_scanline; /* 0 .. image_height-1 */
  334. /* Remaining fields are known throughout compressor, but generally
  335. * should not be touched by a surrounding application.
  336. */
  337. /*
  338. * These fields are computed during compression startup
  339. */
  340. boolean progressive_mode; /* TRUE if scan script uses progressive mode */
  341. int max_h_samp_factor; /* largest h_samp_factor */
  342. int max_v_samp_factor; /* largest v_samp_factor */
  343. #if JPEG_LIB_VERSION >= 70
  344. int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */
  345. int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */
  346. #endif
  347. JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */
  348. /* The coefficient controller receives data in units of MCU rows as defined
  349. * for fully interleaved scans (whether the JPEG file is interleaved or not).
  350. * There are v_samp_factor * DCTSIZE sample rows of each component in an
  351. * "iMCU" (interleaved MCU) row.
  352. */
  353. /*
  354. * These fields are valid during any one scan.
  355. * They describe the components and MCUs actually appearing in the scan.
  356. */
  357. int comps_in_scan; /* # of JPEG components in this scan */
  358. jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
  359. /* *cur_comp_info[i] describes component that appears i'th in SOS */
  360. JDIMENSION MCUs_per_row; /* # of MCUs across the image */
  361. JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
  362. int blocks_in_MCU; /* # of DCT blocks per MCU */
  363. int MCU_membership[C_MAX_BLOCKS_IN_MCU];
  364. /* MCU_membership[i] is index in cur_comp_info of component owning */
  365. /* i'th block in an MCU */
  366. int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
  367. #if JPEG_LIB_VERSION >= 80
  368. int block_size; /* the basic DCT block size: 1..16 */
  369. const int *natural_order; /* natural-order position array */
  370. int lim_Se; /* min( Se, DCTSIZE2-1 ) */
  371. #endif
  372. /*
  373. * Links to compression subobjects (methods and private variables of modules)
  374. */
  375. struct jpeg_comp_master *master;
  376. struct jpeg_c_main_controller *main;
  377. struct jpeg_c_prep_controller *prep;
  378. struct jpeg_c_coef_controller *coef;
  379. struct jpeg_marker_writer *marker;
  380. struct jpeg_color_converter *cconvert;
  381. struct jpeg_downsampler *downsample;
  382. struct jpeg_forward_dct *fdct;
  383. struct jpeg_entropy_encoder *entropy;
  384. jpeg_scan_info *script_space; /* workspace for jpeg_simple_progression */
  385. int script_space_size;
  386. };
  387. /* Master record for a decompression instance */
  388. struct jpeg_decompress_struct {
  389. jpeg_common_fields; /* Fields shared with jpeg_compress_struct */
  390. /* Source of compressed data */
  391. struct jpeg_source_mgr *src;
  392. /* Basic description of image --- filled in by jpeg_read_header(). */
  393. /* Application may inspect these values to decide how to process image. */
  394. JDIMENSION image_width; /* nominal image width (from SOF marker) */
  395. JDIMENSION image_height; /* nominal image height */
  396. int num_components; /* # of color components in JPEG image */
  397. J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
  398. /* Decompression processing parameters --- these fields must be set before
  399. * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes
  400. * them to default values.
  401. */
  402. J_COLOR_SPACE out_color_space; /* colorspace for output */
  403. unsigned int scale_num, scale_denom; /* fraction by which to scale image */
  404. double output_gamma; /* image gamma wanted in output */
  405. boolean buffered_image; /* TRUE=multiple output passes */
  406. boolean raw_data_out; /* TRUE=downsampled data wanted */
  407. J_DCT_METHOD dct_method; /* IDCT algorithm selector */
  408. boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */
  409. boolean do_block_smoothing; /* TRUE=apply interblock smoothing */
  410. boolean quantize_colors; /* TRUE=colormapped output wanted */
  411. /* the following are ignored if not quantize_colors: */
  412. J_DITHER_MODE dither_mode; /* type of color dithering to use */
  413. boolean two_pass_quantize; /* TRUE=use two-pass color quantization */
  414. int desired_number_of_colors; /* max # colors to use in created colormap */
  415. /* these are significant only in buffered-image mode: */
  416. boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */
  417. boolean enable_external_quant;/* enable future use of external colormap */
  418. boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */
  419. /* Description of actual output image that will be returned to application.
  420. * These fields are computed by jpeg_start_decompress().
  421. * You can also use jpeg_calc_output_dimensions() to determine these values
  422. * in advance of calling jpeg_start_decompress().
  423. */
  424. JDIMENSION output_width; /* scaled image width */
  425. JDIMENSION output_height; /* scaled image height */
  426. int out_color_components; /* # of color components in out_color_space */
  427. int output_components; /* # of color components returned */
  428. /* output_components is 1 (a colormap index) when quantizing colors;
  429. * otherwise it equals out_color_components.
  430. */
  431. int rec_outbuf_height; /* min recommended height of scanline buffer */
  432. /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
  433. * high, space and time will be wasted due to unnecessary data copying.
  434. * Usually rec_outbuf_height will be 1 or 2, at most 4.
  435. */
  436. /* When quantizing colors, the output colormap is described by these fields.
  437. * The application can supply a colormap by setting colormap non-NULL before
  438. * calling jpeg_start_decompress; otherwise a colormap is created during
  439. * jpeg_start_decompress or jpeg_start_output.
  440. * The map has out_color_components rows and actual_number_of_colors columns.
  441. */
  442. int actual_number_of_colors; /* number of entries in use */
  443. JSAMPARRAY colormap; /* The color map as a 2-D pixel array */
  444. /* State variables: these variables indicate the progress of decompression.
  445. * The application may examine these but must not modify them.
  446. */
  447. /* Row index of next scanline to be read from jpeg_read_scanlines().
  448. * Application may use this to control its processing loop, e.g.,
  449. * "while (output_scanline < output_height)".
  450. */
  451. JDIMENSION output_scanline; /* 0 .. output_height-1 */
  452. /* Current input scan number and number of iMCU rows completed in scan.
  453. * These indicate the progress of the decompressor input side.
  454. */
  455. int input_scan_number; /* Number of SOS markers seen so far */
  456. JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */
  457. /* The "output scan number" is the notional scan being displayed by the
  458. * output side. The decompressor will not allow output scan/row number
  459. * to get ahead of input scan/row, but it can fall arbitrarily far behind.
  460. */
  461. int output_scan_number; /* Nominal scan number being displayed */
  462. JDIMENSION output_iMCU_row; /* Number of iMCU rows read */
  463. /* Current progression status. coef_bits[c][i] indicates the precision
  464. * with which component c's DCT coefficient i (in zigzag order) is known.
  465. * It is -1 when no data has yet been received, otherwise it is the point
  466. * transform (shift) value for the most recent scan of the coefficient
  467. * (thus, 0 at completion of the progression).
  468. * This pointer is NULL when reading a non-progressive file.
  469. */
  470. int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */
  471. /* Internal JPEG parameters --- the application usually need not look at
  472. * these fields. Note that the decompressor output side may not use
  473. * any parameters that can change between scans.
  474. */
  475. /* Quantization and Huffman tables are carried forward across input
  476. * datastreams when processing abbreviated JPEG datastreams.
  477. */
  478. JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
  479. /* ptrs to coefficient quantization tables, or NULL if not defined */
  480. JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  481. JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  482. /* ptrs to Huffman coding tables, or NULL if not defined */
  483. /* These parameters are never carried across datastreams, since they
  484. * are given in SOF/SOS markers or defined to be reset by SOI.
  485. */
  486. int data_precision; /* bits of precision in image data */
  487. jpeg_component_info *comp_info;
  488. /* comp_info[i] describes component that appears i'th in SOF */
  489. #if JPEG_LIB_VERSION >= 80
  490. boolean is_baseline; /* TRUE if Baseline SOF0 encountered */
  491. #endif
  492. boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */
  493. boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
  494. UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  495. UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  496. UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
  497. unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
  498. /* These fields record data obtained from optional markers recognized by
  499. * the JPEG library.
  500. */
  501. boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */
  502. /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
  503. UINT8 JFIF_major_version; /* JFIF version number */
  504. UINT8 JFIF_minor_version;
  505. UINT8 density_unit; /* JFIF code for pixel size units */
  506. UINT16 X_density; /* Horizontal pixel density */
  507. UINT16 Y_density; /* Vertical pixel density */
  508. boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */
  509. UINT8 Adobe_transform; /* Color transform code from Adobe marker */
  510. boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  511. /* Aside from the specific data retained from APPn markers known to the
  512. * library, the uninterpreted contents of any or all APPn and COM markers
  513. * can be saved in a list for examination by the application.
  514. */
  515. jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
  516. /* Remaining fields are known throughout decompressor, but generally
  517. * should not be touched by a surrounding application.
  518. */
  519. /*
  520. * These fields are computed during decompression startup
  521. */
  522. int max_h_samp_factor; /* largest h_samp_factor */
  523. int max_v_samp_factor; /* largest v_samp_factor */
  524. #if JPEG_LIB_VERSION >= 70
  525. int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */
  526. int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */
  527. #else
  528. int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */
  529. #endif
  530. JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */
  531. /* The coefficient controller's input and output progress is measured in
  532. * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows
  533. * in fully interleaved JPEG scans, but are used whether the scan is
  534. * interleaved or not. We define an iMCU row as v_samp_factor DCT block
  535. * rows of each component. Therefore, the IDCT output contains
  536. * v_samp_factor*DCT_[v_]scaled_size sample rows of a component per iMCU row.
  537. */
  538. JSAMPLE *sample_range_limit; /* table for fast range-limiting */
  539. /*
  540. * These fields are valid during any one scan.
  541. * They describe the components and MCUs actually appearing in the scan.
  542. * Note that the decompressor output side must not use these fields.
  543. */
  544. int comps_in_scan; /* # of JPEG components in this scan */
  545. jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
  546. /* *cur_comp_info[i] describes component that appears i'th in SOS */
  547. JDIMENSION MCUs_per_row; /* # of MCUs across the image */
  548. JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
  549. int blocks_in_MCU; /* # of DCT blocks per MCU */
  550. int MCU_membership[D_MAX_BLOCKS_IN_MCU];
  551. /* MCU_membership[i] is index in cur_comp_info of component owning */
  552. /* i'th block in an MCU */
  553. int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
  554. #if JPEG_LIB_VERSION >= 80
  555. /* These fields are derived from Se of first SOS marker.
  556. */
  557. int block_size; /* the basic DCT block size: 1..16 */
  558. const int *natural_order; /* natural-order position array for entropy decode */
  559. int lim_Se; /* min( Se, DCTSIZE2-1 ) for entropy decode */
  560. #endif
  561. /* This field is shared between entropy decoder and marker parser.
  562. * It is either zero or the code of a JPEG marker that has been
  563. * read from the data source, but has not yet been processed.
  564. */
  565. int unread_marker;
  566. /*
  567. * Links to decompression subobjects (methods, private variables of modules)
  568. */
  569. struct jpeg_decomp_master *master;
  570. struct jpeg_d_main_controller *main;
  571. struct jpeg_d_coef_controller *coef;
  572. struct jpeg_d_post_controller *post;
  573. struct jpeg_input_controller *inputctl;
  574. struct jpeg_marker_reader *marker;
  575. struct jpeg_entropy_decoder *entropy;
  576. struct jpeg_inverse_dct *idct;
  577. struct jpeg_upsampler *upsample;
  578. struct jpeg_color_deconverter *cconvert;
  579. struct jpeg_color_quantizer *cquantize;
  580. };
  581. /* "Object" declarations for JPEG modules that may be supplied or called
  582. * directly by the surrounding application.
  583. * As with all objects in the JPEG library, these structs only define the
  584. * publicly visible methods and state variables of a module. Additional
  585. * private fields may exist after the public ones.
  586. */
  587. /* Error handler object */
  588. struct jpeg_error_mgr {
  589. /* Error exit handler: does not return to caller */
  590. void (*error_exit) (j_common_ptr cinfo);
  591. /* Conditionally emit a trace or warning message */
  592. void (*emit_message) (j_common_ptr cinfo, int msg_level);
  593. /* Routine that actually outputs a trace or error message */
  594. void (*output_message) (j_common_ptr cinfo);
  595. /* Format a message string for the most recent JPEG error or message */
  596. void (*format_message) (j_common_ptr cinfo, char *buffer);
  597. #define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */
  598. /* Reset error state variables at start of a new image */
  599. void (*reset_error_mgr) (j_common_ptr cinfo);
  600. /* The message ID code and any parameters are saved here.
  601. * A message can have one string parameter or up to 8 int parameters.
  602. */
  603. int msg_code;
  604. #define JMSG_STR_PARM_MAX 80
  605. union {
  606. int i[8];
  607. char s[JMSG_STR_PARM_MAX];
  608. } msg_parm;
  609. /* Standard state variables for error facility */
  610. int trace_level; /* max msg_level that will be displayed */
  611. /* For recoverable corrupt-data errors, we emit a warning message,
  612. * but keep going unless emit_message chooses to abort. emit_message
  613. * should count warnings in num_warnings. The surrounding application
  614. * can check for bad data by seeing if num_warnings is nonzero at the
  615. * end of processing.
  616. */
  617. long num_warnings; /* number of corrupt-data warnings */
  618. /* These fields point to the table(s) of error message strings.
  619. * An application can change the table pointer to switch to a different
  620. * message list (typically, to change the language in which errors are
  621. * reported). Some applications may wish to add additional error codes
  622. * that will be handled by the JPEG library error mechanism; the second
  623. * table pointer is used for this purpose.
  624. *
  625. * First table includes all errors generated by JPEG library itself.
  626. * Error code 0 is reserved for a "no such error string" message.
  627. */
  628. const char * const *jpeg_message_table; /* Library errors */
  629. int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */
  630. /* Second table can be added by application (see cjpeg/djpeg for example).
  631. * It contains strings numbered first_addon_message..last_addon_message.
  632. */
  633. const char * const *addon_message_table; /* Non-library errors */
  634. int first_addon_message; /* code for first string in addon table */
  635. int last_addon_message; /* code for last string in addon table */
  636. };
  637. /* Progress monitor object */
  638. struct jpeg_progress_mgr {
  639. void (*progress_monitor) (j_common_ptr cinfo);
  640. long pass_counter; /* work units completed in this pass */
  641. long pass_limit; /* total number of work units in this pass */
  642. int completed_passes; /* passes completed so far */
  643. int total_passes; /* total number of passes expected */
  644. };
  645. /* Data destination object for compression */
  646. struct jpeg_destination_mgr {
  647. JOCTET *next_output_byte; /* => next byte to write in buffer */
  648. size_t free_in_buffer; /* # of byte spaces remaining in buffer */
  649. void (*init_destination) (j_compress_ptr cinfo);
  650. boolean (*empty_output_buffer) (j_compress_ptr cinfo);
  651. void (*term_destination) (j_compress_ptr cinfo);
  652. };
  653. /* Data source object for decompression */
  654. struct jpeg_source_mgr {
  655. const JOCTET *next_input_byte; /* => next byte to read from buffer */
  656. size_t bytes_in_buffer; /* # of bytes remaining in buffer */
  657. void (*init_source) (j_decompress_ptr cinfo);
  658. boolean (*fill_input_buffer) (j_decompress_ptr cinfo);
  659. void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
  660. boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
  661. void (*term_source) (j_decompress_ptr cinfo);
  662. };
  663. /* Memory manager object.
  664. * Allocates "small" objects (a few K total), "large" objects (tens of K),
  665. * and "really big" objects (virtual arrays with backing store if needed).
  666. * The memory manager does not allow individual objects to be freed; rather,
  667. * each created object is assigned to a pool, and whole pools can be freed
  668. * at once. This is faster and more convenient than remembering exactly what
  669. * to free, especially where malloc()/free() are not too speedy.
  670. * NB: alloc routines never return NULL. They exit to error_exit if not
  671. * successful.
  672. */
  673. #define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */
  674. #define JPOOL_IMAGE 1 /* lasts until done with image/datastream */
  675. #define JPOOL_NUMPOOLS 2
  676. typedef struct jvirt_sarray_control *jvirt_sarray_ptr;
  677. typedef struct jvirt_barray_control *jvirt_barray_ptr;
  678. struct jpeg_memory_mgr {
  679. /* Method pointers */
  680. void *(*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
  681. void *(*alloc_large) (j_common_ptr cinfo, int pool_id,
  682. size_t sizeofobject);
  683. JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id,
  684. JDIMENSION samplesperrow, JDIMENSION numrows);
  685. JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id,
  686. JDIMENSION blocksperrow, JDIMENSION numrows);
  687. jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id,
  688. boolean pre_zero,
  689. JDIMENSION samplesperrow,
  690. JDIMENSION numrows,
  691. JDIMENSION maxaccess);
  692. jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id,
  693. boolean pre_zero,
  694. JDIMENSION blocksperrow,
  695. JDIMENSION numrows,
  696. JDIMENSION maxaccess);
  697. void (*realize_virt_arrays) (j_common_ptr cinfo);
  698. JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
  699. JDIMENSION start_row, JDIMENSION num_rows,
  700. boolean writable);
  701. JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr,
  702. JDIMENSION start_row, JDIMENSION num_rows,
  703. boolean writable);
  704. void (*free_pool) (j_common_ptr cinfo, int pool_id);
  705. void (*self_destruct) (j_common_ptr cinfo);
  706. /* Limit on memory allocation for this JPEG object. (Note that this is
  707. * merely advisory, not a guaranteed maximum; it only affects the space
  708. * used for virtual-array buffers.) May be changed by outer application
  709. * after creating the JPEG object.
  710. */
  711. long max_memory_to_use;
  712. /* Maximum allocation request accepted by alloc_large. */
  713. long max_alloc_chunk;
  714. };
  715. /* Routine signature for application-supplied marker processing methods.
  716. * Need not pass marker code since it is stored in cinfo->unread_marker.
  717. */
  718. typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo);
  719. /* Originally, this macro was used as a way of defining function prototypes
  720. * for both modern compilers as well as older compilers that did not support
  721. * prototype parameters. libjpeg-turbo has never supported these older,
  722. * non-ANSI compilers, but the macro is still included because there is some
  723. * software out there that uses it.
  724. */
  725. #define JPP(arglist) arglist
  726. /* Default error-management setup */
  727. EXTERN(struct jpeg_error_mgr *) jpeg_std_error(struct jpeg_error_mgr *err);
  728. /* Initialization of JPEG compression objects.
  729. * jpeg_create_compress() and jpeg_create_decompress() are the exported
  730. * names that applications should call. These expand to calls on
  731. * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
  732. * passed for version mismatch checking.
  733. * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
  734. */
  735. #define jpeg_create_compress(cinfo) \
  736. jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
  737. (size_t)sizeof(struct jpeg_compress_struct))
  738. #define jpeg_create_decompress(cinfo) \
  739. jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
  740. (size_t)sizeof(struct jpeg_decompress_struct))
  741. EXTERN(void) jpeg_CreateCompress(j_compress_ptr cinfo, int version,
  742. size_t structsize);
  743. EXTERN(void) jpeg_CreateDecompress(j_decompress_ptr cinfo, int version,
  744. size_t structsize);
  745. /* Destruction of JPEG compression objects */
  746. EXTERN(void) jpeg_destroy_compress(j_compress_ptr cinfo);
  747. EXTERN(void) jpeg_destroy_decompress(j_decompress_ptr cinfo);
  748. /* Standard data source and destination managers: stdio streams. */
  749. /* Caller is responsible for opening the file before and closing after. */
  750. EXTERN(void) jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile);
  751. EXTERN(void) jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile);
  752. #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
  753. /* Data source and destination managers: memory buffers. */
  754. EXTERN(void) jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
  755. unsigned long *outsize);
  756. EXTERN(void) jpeg_mem_src(j_decompress_ptr cinfo,
  757. const unsigned char *inbuffer, unsigned long insize);
  758. #endif
  759. /* Default parameter setup for compression */
  760. EXTERN(void) jpeg_set_defaults(j_compress_ptr cinfo);
  761. /* Compression parameter setup aids */
  762. EXTERN(void) jpeg_set_colorspace(j_compress_ptr cinfo,
  763. J_COLOR_SPACE colorspace);
  764. EXTERN(void) jpeg_default_colorspace(j_compress_ptr cinfo);
  765. EXTERN(void) jpeg_set_quality(j_compress_ptr cinfo, int quality,
  766. boolean force_baseline);
  767. EXTERN(void) jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,
  768. boolean force_baseline);
  769. #if JPEG_LIB_VERSION >= 70
  770. EXTERN(void) jpeg_default_qtables(j_compress_ptr cinfo,
  771. boolean force_baseline);
  772. #endif
  773. EXTERN(void) jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
  774. const unsigned int *basic_table,
  775. int scale_factor, boolean force_baseline);
  776. EXTERN(int) jpeg_quality_scaling(int quality);
  777. EXTERN(void) jpeg_simple_progression(j_compress_ptr cinfo);
  778. EXTERN(void) jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress);
  779. EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table(j_common_ptr cinfo);
  780. EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table(j_common_ptr cinfo);
  781. /* Main entry points for compression */
  782. EXTERN(void) jpeg_start_compress(j_compress_ptr cinfo,
  783. boolean write_all_tables);
  784. EXTERN(JDIMENSION) jpeg_write_scanlines(j_compress_ptr cinfo,
  785. JSAMPARRAY scanlines,
  786. JDIMENSION num_lines);
  787. EXTERN(void) jpeg_finish_compress(j_compress_ptr cinfo);
  788. #if JPEG_LIB_VERSION >= 70
  789. /* Precalculate JPEG dimensions for current compression parameters. */
  790. EXTERN(void) jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo);
  791. #endif
  792. /* Replaces jpeg_write_scanlines when writing raw downsampled data. */
  793. EXTERN(JDIMENSION) jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
  794. JDIMENSION num_lines);
  795. /* Write a special marker. See libjpeg.txt concerning safe usage. */
  796. EXTERN(void) jpeg_write_marker(j_compress_ptr cinfo, int marker,
  797. const JOCTET *dataptr, unsigned int datalen);
  798. /* Same, but piecemeal. */
  799. EXTERN(void) jpeg_write_m_header(j_compress_ptr cinfo, int marker,
  800. unsigned int datalen);
  801. EXTERN(void) jpeg_write_m_byte(j_compress_ptr cinfo, int val);
  802. /* Alternate compression function: just write an abbreviated table file */
  803. EXTERN(void) jpeg_write_tables(j_compress_ptr cinfo);
  804. /* Write ICC profile. See libjpeg.txt for usage information. */
  805. EXTERN(void) jpeg_write_icc_profile(j_compress_ptr cinfo,
  806. const JOCTET *icc_data_ptr,
  807. unsigned int icc_data_len);
  808. /* Decompression startup: read start of JPEG datastream to see what's there */
  809. EXTERN(int) jpeg_read_header(j_decompress_ptr cinfo, boolean require_image);
  810. /* Return value is one of: */
  811. #define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */
  812. #define JPEG_HEADER_OK 1 /* Found valid image datastream */
  813. #define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
  814. /* If you pass require_image = TRUE (normal case), you need not check for
  815. * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
  816. * JPEG_SUSPENDED is only possible if you use a data source module that can
  817. * give a suspension return (the stdio source module doesn't).
  818. */
  819. /* Main entry points for decompression */
  820. EXTERN(boolean) jpeg_start_decompress(j_decompress_ptr cinfo);
  821. EXTERN(JDIMENSION) jpeg_read_scanlines(j_decompress_ptr cinfo,
  822. JSAMPARRAY scanlines,
  823. JDIMENSION max_lines);
  824. EXTERN(JDIMENSION) jpeg_skip_scanlines(j_decompress_ptr cinfo,
  825. JDIMENSION num_lines);
  826. EXTERN(void) jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
  827. JDIMENSION *width);
  828. EXTERN(boolean) jpeg_finish_decompress(j_decompress_ptr cinfo);
  829. /* Replaces jpeg_read_scanlines when reading raw downsampled data. */
  830. EXTERN(JDIMENSION) jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
  831. JDIMENSION max_lines);
  832. /* Additional entry points for buffered-image mode. */
  833. EXTERN(boolean) jpeg_has_multiple_scans(j_decompress_ptr cinfo);
  834. EXTERN(boolean) jpeg_start_output(j_decompress_ptr cinfo, int scan_number);
  835. EXTERN(boolean) jpeg_finish_output(j_decompress_ptr cinfo);
  836. EXTERN(boolean) jpeg_input_complete(j_decompress_ptr cinfo);
  837. EXTERN(void) jpeg_new_colormap(j_decompress_ptr cinfo);
  838. EXTERN(int) jpeg_consume_input(j_decompress_ptr cinfo);
  839. /* Return value is one of: */
  840. /* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */
  841. #define JPEG_REACHED_SOS 1 /* Reached start of new scan */
  842. #define JPEG_REACHED_EOI 2 /* Reached end of image */
  843. #define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */
  844. #define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */
  845. /* Precalculate output dimensions for current decompression parameters. */
  846. #if JPEG_LIB_VERSION >= 80
  847. EXTERN(void) jpeg_core_output_dimensions(j_decompress_ptr cinfo);
  848. #endif
  849. EXTERN(void) jpeg_calc_output_dimensions(j_decompress_ptr cinfo);
  850. /* Control saving of COM and APPn markers into marker_list. */
  851. EXTERN(void) jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
  852. unsigned int length_limit);
  853. /* Install a special processing method for COM or APPn markers. */
  854. EXTERN(void) jpeg_set_marker_processor(j_decompress_ptr cinfo,
  855. int marker_code,
  856. jpeg_marker_parser_method routine);
  857. /* Read or write raw DCT coefficients --- useful for lossless transcoding. */
  858. EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients(j_decompress_ptr cinfo);
  859. EXTERN(void) jpeg_write_coefficients(j_compress_ptr cinfo,
  860. jvirt_barray_ptr *coef_arrays);
  861. EXTERN(void) jpeg_copy_critical_parameters(j_decompress_ptr srcinfo,
  862. j_compress_ptr dstinfo);
  863. /* If you choose to abort compression or decompression before completing
  864. * jpeg_finish_(de)compress, then you need to clean up to release memory,
  865. * temporary files, etc. You can just call jpeg_destroy_(de)compress
  866. * if you're done with the JPEG object, but if you want to clean it up and
  867. * reuse it, call this:
  868. */
  869. EXTERN(void) jpeg_abort_compress(j_compress_ptr cinfo);
  870. EXTERN(void) jpeg_abort_decompress(j_decompress_ptr cinfo);
  871. /* Generic versions of jpeg_abort and jpeg_destroy that work on either
  872. * flavor of JPEG object. These may be more convenient in some places.
  873. */
  874. EXTERN(void) jpeg_abort(j_common_ptr cinfo);
  875. EXTERN(void) jpeg_destroy(j_common_ptr cinfo);
  876. /* Default restart-marker-resync procedure for use by data source modules */
  877. EXTERN(boolean) jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired);
  878. /* Read ICC profile. See libjpeg.txt for usage information. */
  879. EXTERN(boolean) jpeg_read_icc_profile(j_decompress_ptr cinfo,
  880. JOCTET **icc_data_ptr,
  881. unsigned int *icc_data_len);
  882. /* These marker codes are exported since applications and data source modules
  883. * are likely to want to use them.
  884. */
  885. #define JPEG_RST0 0xD0 /* RST0 marker code */
  886. #define JPEG_EOI 0xD9 /* EOI marker code */
  887. #define JPEG_APP0 0xE0 /* APP0 marker code */
  888. #define JPEG_COM 0xFE /* COM marker code */
  889. /* If we have a brain-damaged compiler that emits warnings (or worse, errors)
  890. * for structure definitions that are never filled in, keep it quiet by
  891. * supplying dummy definitions for the various substructures.
  892. */
  893. #ifdef INCOMPLETE_TYPES_BROKEN
  894. #ifndef JPEG_INTERNALS /* will be defined in jpegint.h */
  895. struct jvirt_sarray_control { long dummy; };
  896. struct jvirt_barray_control { long dummy; };
  897. struct jpeg_comp_master { long dummy; };
  898. struct jpeg_c_main_controller { long dummy; };
  899. struct jpeg_c_prep_controller { long dummy; };
  900. struct jpeg_c_coef_controller { long dummy; };
  901. struct jpeg_marker_writer { long dummy; };
  902. struct jpeg_color_converter { long dummy; };
  903. struct jpeg_downsampler { long dummy; };
  904. struct jpeg_forward_dct { long dummy; };
  905. struct jpeg_entropy_encoder { long dummy; };
  906. struct jpeg_decomp_master { long dummy; };
  907. struct jpeg_d_main_controller { long dummy; };
  908. struct jpeg_d_coef_controller { long dummy; };
  909. struct jpeg_d_post_controller { long dummy; };
  910. struct jpeg_input_controller { long dummy; };
  911. struct jpeg_marker_reader { long dummy; };
  912. struct jpeg_entropy_decoder { long dummy; };
  913. struct jpeg_inverse_dct { long dummy; };
  914. struct jpeg_upsampler { long dummy; };
  915. struct jpeg_color_deconverter { long dummy; };
  916. struct jpeg_color_quantizer { long dummy; };
  917. #endif /* JPEG_INTERNALS */
  918. #endif /* INCOMPLETE_TYPES_BROKEN */
  919. /*
  920. * The JPEG library modules define JPEG_INTERNALS before including this file.
  921. * The internal structure declarations are read only when that is true.
  922. * Applications using the library should not include jpegint.h, but may wish
  923. * to include jerror.h.
  924. */
  925. #ifdef JPEG_INTERNALS
  926. #include "jpegint.h" /* fetch private declarations */
  927. #include "jerror.h" /* fetch error codes too */
  928. #endif
  929. #ifdef __cplusplus
  930. #ifndef DONT_USE_EXTERN_C
  931. }
  932. #endif
  933. #endif
  934. #endif /* JPEGLIB_H */