/media/libpng/pngpriv.h

http://github.com/zpao/v8monkey · C Header · 1012 lines · 715 code · 149 blank · 148 comment · 29 complexity · 526eb06276468e25d9e325d42492a4b6 MD5 · raw file 

    

  1. /* pngpriv.h - private declarations for use inside libpng
    2. 

  2.  *
    3. 

  3.  * libpng version 1.4.8 - July 7, 2011
    4. 

  4.  * For conditions of distribution and use, see copyright notice in png.h
    5. 

  5.  * Copyright (c) 1998-2011 Glenn Randers-Pehrson
    6. 

  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    7. 

  7.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    8. 

  8.  *
    9. 

  9.  * This code is released under the libpng license.
    10. 

  10.  * For conditions of distribution and use, see the disclaimer
    11. 

  11.  * and license in png.h
    12. 

  12.  */
    13. 

  13. 

  14. /* The symbols declared in this file (including the functions declared
    15. 

  15.  * as PNG_EXTERN) are PRIVATE.  They are not part of the libpng public
    16. 

  16.  * interface, and are not recommended for use by regular applications.
    17. 

  17.  * Some of them may become public in the future; others may stay private,
    18. 

  18.  * change in an incompatible way, or even disappear.
    19. 

  19.  * Although the libpng users are not forbidden to include this header,
    20. 

  20.  * they should be well aware of the issues that may arise from doing so.
    21. 

  21.  */
    22. 

  22. 

  23. #ifndef PNGPRIV_H
    24. 

  24. #define PNGPRIV_H
    25. 

  25. 

  26. #ifndef PNG_VERSION_INFO_ONLY
    27. 

  27. 

  28. #if defined(_AIX) && defined(_ALL_SOURCE)
    29. 

  29.    /* On AIX if _ALL_SOURCE is defined standard header files (including
    30. 

  30.     * stdlib.h) define identifiers that are not permitted by the ANSI and
    31. 

  31.     * POSIX standards.  In particular 'jmpbuf' is #defined and this will
    32. 

  32.     * prevent compilation of libpng.  The following prevents this:
    33. 

  33.     */
    34. 

  34. #  undef _ALL_SOURCE
    35. 

  35. #endif
    36. 

  36. 

  37. #include <stdlib.h>
    38. 

  38. 

  39. #ifndef PNG_EXTERN
    40. 

  40. /* The functions exported by PNG_EXTERN are internal functions, which
    41. 

  41.  * aren't usually used outside the library (as far as I know), so it is
    42. 

  42.  * debatable if they should be exported at all.  In the future, when it
    43. 

  43.  * is possible to have run-time registry of chunk-handling functions,
    44. 

  44.  * some of these will be made available again.
    45. 

  45. #  define PNG_EXTERN extern
    46. 

  46.  */
    47. 

  47. #  define PNG_EXTERN
    48. 

  48. #endif
    49. 

  49. 

  50. /* Other defines specific to compilers can go here.  Try to keep
    51. 

  51.  * them inside an appropriate ifdef/endif pair for portability.
    52. 

  52.  */
    53. 

  53. 

  54. #ifdef PNG_FLOATING_POINT_SUPPORTED
    55. 

  55. #  ifdef MACOS
    56. 

  56.      /* We need to check that <math.h> hasn't already been included earlier
    57. 

  57.       * as it seems it doesn't agree with <fp.h>, yet we should really use
    58. 

  58.       * <fp.h> if possible.
    59. 

  59.       */
    60. 

  60. #    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
    61. 

  61. #      include <fp.h>
    62. 

  62. #    endif
    63. 

  63. #  else
    64. 

  64. #    include <math.h>
    65. 

  65. #  endif
    66. 

  66. #  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
    67. 

  67.      /* Amiga SAS/C: We must include builtin FPU functions when compiling using
    68. 

  68.       * MATH=68881
    69. 

  69.       */
    70. 

  70. #    include <m68881.h>
    71. 

  71. #  endif
    72. 

  72. #endif
    73. 

  73. 

  74. /* Codewarrior on NT has linking problems without this. */
    75. 

  75. #if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)
    76. 

  76. #  define PNG_ALWAYS_EXTERN
    77. 

  77. #endif
    78. 

  78. 

  79. /* This provides the non-ANSI (far) memory allocation routines. */
    80. 

  80. #if defined(__TURBOC__) && defined(__MSDOS__)
    81. 

  81. #  include <mem.h>
    82. 

  82. #  include <alloc.h>
    83. 

  83. #endif
    84. 

  84. 

  85. #if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
    86. 

  86.     defined(_WIN32) || defined(__WIN32__)
    87. 

  87. #  include <windows.h>  /* defines _WINDOWS_ macro */
    88. 

  88. #endif
    89. 

  89. 

  90. /* Various modes of operation.  Note that after an init, mode is set to
    91. 

  91.  * zero automatically when the structure is created.
    92. 

  92.  */
    93. 

  93. #define PNG_HAVE_IHDR               0x01
    94. 

  94. #define PNG_HAVE_PLTE               0x02
    95. 

  95. #define PNG_HAVE_IDAT               0x04
    96. 

  96. #define PNG_AFTER_IDAT              0x08 /* Have complete zlib datastream */
    97. 

  97. #define PNG_HAVE_IEND               0x10
    98. 

  98. #define PNG_HAVE_gAMA               0x20
    99. 

  99. #define PNG_HAVE_cHRM               0x40
    100. 

  100. #define PNG_HAVE_sRGB               0x80
    101. 

  101. #define PNG_HAVE_CHUNK_HEADER      0x100
    102. 

  102. #define PNG_WROTE_tIME             0x200
    103. 

  103. #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
    104. 

  104. #define PNG_BACKGROUND_IS_GRAY     0x800
    105. 

  105. #define PNG_HAVE_PNG_SIGNATURE    0x1000
    106. 

  106. #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
    107. 

  107. #ifdef PNG_APNG_SUPPORTED
    108. 

  108. #define PNG_HAVE_acTL             0x4000
    109. 

  109. #define PNG_HAVE_fcTL             0x8000L
    110. 

  110. #endif
    111. 

  111. 

  112. /* Flags for the transformations the PNG library does on the image data */
    113. 

  113. #define PNG_BGR                 0x0001
    114. 

  114. #define PNG_INTERLACE           0x0002
    115. 

  115. #define PNG_PACK                0x0004
    116. 

  116. #define PNG_SHIFT               0x0008
    117. 

  117. #define PNG_SWAP_BYTES          0x0010
    118. 

  118. #define PNG_INVERT_MONO         0x0020
    119. 

  119. #define PNG_QUANTIZE            0x0040 /* formerly PNG_DITHER */
    120. 

  120. #define PNG_BACKGROUND          0x0080
    121. 

  121. #define PNG_BACKGROUND_EXPAND   0x0100
    122. 

  122.                           /*    0x0200 unused */
    123. 

  123. #define PNG_16_TO_8             0x0400
    124. 

  124. #define PNG_RGBA                0x0800
    125. 

  125. #define PNG_EXPAND              0x1000
    126. 

  126. #define PNG_GAMMA               0x2000
    127. 

  127. #define PNG_GRAY_TO_RGB         0x4000
    128. 

  128. #define PNG_FILLER              0x8000L
    129. 

  129. #define PNG_PACKSWAP           0x10000L
    130. 

  130. #define PNG_SWAP_ALPHA         0x20000L
    131. 

  131. #define PNG_STRIP_ALPHA        0x40000L
    132. 

  132. #define PNG_INVERT_ALPHA       0x80000L
    133. 

  133. #define PNG_USER_TRANSFORM    0x100000L
    134. 

  134. #define PNG_RGB_TO_GRAY_ERR   0x200000L
    135. 

  135. #define PNG_RGB_TO_GRAY_WARN  0x400000L
    136. 

  136. #define PNG_RGB_TO_GRAY       0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */
    137. 

  137.                        /*     0x800000L     Unused */
    138. 

  138. #define PNG_ADD_ALPHA         0x1000000L  /* Added to libpng-1.2.7 */
    139. 

  139. #define PNG_EXPAND_tRNS       0x2000000L  /* Added to libpng-1.2.9 */
    140. 

  140.                        /*   0x4000000L  unused */
    141. 

  141.                        /*   0x8000000L  unused */
    142. 

  142.                        /*  0x10000000L  unused */
    143. 

  143.                        /*  0x20000000L  unused */
    144. 

  144.                        /*  0x40000000L  unused */
    145. 

  145. 

  146. /* Flags for png_create_struct */
    147. 

  147. #define PNG_STRUCT_PNG   0x0001
    148. 

  148. #define PNG_STRUCT_INFO  0x0002
    149. 

  149. 

  150. /* Scaling factor for filter heuristic weighting calculations */
    151. 

  151. #define PNG_WEIGHT_SHIFT 8
    152. 

  152. #define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
    153. 

  153. #define PNG_COST_SHIFT 3
    154. 

  154. #define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
    155. 

  155. 

  156. /* Flags for the png_ptr->flags rather than declaring a byte for each one */
    157. 

  157. #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001
    158. 

  158. #define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0002
    159. 

  159. #define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0004
    160. 

  160. #define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0008
    161. 

  161. #define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0010
    162. 

  162. #define PNG_FLAG_ZLIB_FINISHED            0x0020
    163. 

  163. #define PNG_FLAG_ROW_INIT                 0x0040
    164. 

  164. #define PNG_FLAG_FILLER_AFTER             0x0080
    165. 

  165. #define PNG_FLAG_CRC_ANCILLARY_USE        0x0100
    166. 

  166. #define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200
    167. 

  167. #define PNG_FLAG_CRC_CRITICAL_USE         0x0400
    168. 

  168. #define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800
    169. 

  169.                                 /*        0x1000  unused */
    170. 

  170.                                 /*        0x2000  unused */
    171. 

  171.                                 /*        0x4000  unused */
    172. 

  172. #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L
    173. 

  173. #define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L
    174. 

  174. #define PNG_FLAG_LIBRARY_MISMATCH         0x20000L
    175. 

  175. #define PNG_FLAG_STRIP_ERROR_NUMBERS      0x40000L
    176. 

  176. #define PNG_FLAG_STRIP_ERROR_TEXT         0x80000L
    177. 

  177. #define PNG_FLAG_MALLOC_NULL_MEM_OK       0x100000L
    178. 

  178. #define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */
    179. 

  179. #define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */
    180. 

  180. #define PNG_FLAG_BENIGN_ERRORS_WARN       0x800000L  /* Added to libpng-1.4.0 */
    181. 

  181.                                   /*     0x1000000L  unused */
    182. 

  182.                                   /*     0x2000000L  unused */
    183. 

  183.                                   /*     0x4000000L  unused */
    184. 

  184.                                   /*     0x8000000L  unused */
    185. 

  185.                                   /*    0x10000000L  unused */
    186. 

  186.                                   /*    0x20000000L  unused */
    187. 

  187.                                   /*    0x40000000L  unused */
    188. 

  188. 

  189. #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
    190. 

  190.                                      PNG_FLAG_CRC_ANCILLARY_NOWARN)
    191. 

  191. 

  192. #define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | \
    193. 

  193.                                      PNG_FLAG_CRC_CRITICAL_IGNORE)
    194. 

  194. 

  195. #define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | \
    196. 

  196.                                      PNG_FLAG_CRC_CRITICAL_MASK)
    197. 

  197. 

  198. /* Save typing and make code easier to understand */
    199. 

  199. 

  200. #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
    201. 

  201.    abs((int)((c1).green) - (int)((c2).green)) + \
    202. 

  202.    abs((int)((c1).blue) - (int)((c2).blue)))
    203. 

  203. 

  204. /* Added to libpng-1.2.6 JB */
    205. 

  205. #define PNG_ROWBYTES(pixel_bits, width) \
    206. 

  206.     ((pixel_bits) >= 8 ? \
    207. 

  207.     ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
    208. 

  208.     (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
    209. 

  209. 

  210. /* PNG_OUT_OF_RANGE returns true if value is outside the range
    211. 

  211.  * ideal-delta..ideal+delta.  Each argument is evaluated twice.
    212. 

  212.  * "ideal" and "delta" should be constants, normally simple
    213. 

  213.  * integers, "value" a variable. Added to libpng-1.2.6 JB
    214. 

  214.  */
    215. 

  215. #define PNG_OUT_OF_RANGE(value, ideal, delta) \
    216. 

  216.         ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
    217. 

  217. 

  218. /* Constant strings for known chunk types.  If you need to add a chunk,
    219. 

  219.  * define the name here, and add an invocation of the macro wherever it's
    220. 

  220.  * needed.
    221. 

  221.  */
    222. 

  222. #define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73,  72,  68,  82, '\0'}
    223. 

  223. #define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73,  68,  65,  84, '\0'}
    224. 

  224. #define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73,  69,  78,  68, '\0'}
    225. 

  225. #define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80,  76,  84,  69, '\0'}
    226. 

  226. #define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98,  75,  71,  68, '\0'}
    227. 

  227. #define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99,  72,  82,  77, '\0'}
    228. 

  228. #define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103,  65,  77,  65, '\0'}
    229. 

  229. #define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104,  73,  83,  84, '\0'}
    230. 

  230. #define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105,  67,  67,  80, '\0'}
    231. 

  231. #define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105,  84,  88, 116, '\0'}
    232. 

  232. #define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111,  70,  70, 115, '\0'}
    233. 

  233. #define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112,  67,  65,  76, '\0'}
    234. 

  234. #define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115,  67,  65,  76, '\0'}
    235. 

  235. #define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112,  72,  89, 115, '\0'}
    236. 

  236. #define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115,  66,  73,  84, '\0'}
    237. 

  237. #define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115,  80,  76,  84, '\0'}
    238. 

  238. #define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115,  82,  71,  66, '\0'}
    239. 

  239. #define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115,  84,  69,  82, '\0'}
    240. 

  240. #define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116,  69,  88, 116, '\0'}
    241. 

  241. #define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116,  73,  77,  69, '\0'}
    242. 

  242. #define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116,  82,  78,  83, '\0'}
    243. 

  243. #define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122,  84,  88, 116, '\0'}
    244. 

  244. #ifdef PNG_APNG_SUPPORTED
    245. 

  245. #define PNG_acTL PNG_CONST png_byte png_acTL[5] = { 97,  99,  84,  76, '\0'}
    246. 

  246. #define PNG_fcTL PNG_CONST png_byte png_fcTL[5] = {102,  99,  84,  76, '\0'}
    247. 

  247. #define PNG_fdAT PNG_CONST png_byte png_fdAT[5] = {102, 100,  65,  84, '\0'}
    248. 

  248. #endif
    249. 

  249. 

  250. 

  251. /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
    252. 

  252. #ifdef __cplusplus
    253. 

  253. extern "C" {
    254. 

  254. #endif /* __cplusplus */
    255. 

  255. 

  256. /* These functions are used internally in the code.  They generally
    257. 

  257.  * shouldn't be used unless you are writing code to add or replace some
    258. 

  258.  * functionality in libpng.  More information about most functions can
    259. 

  259.  * be found in the files where the functions are located.
    260. 

  260.  */
    261. 

  261. 

  262. /* Allocate memory for an internal libpng struct */
    263. 

  263. PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
    264. 

  264. 

  265. /* Free memory from internal libpng struct */
    266. 

  266. PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
    267. 

  267. 

  268. PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr
    269. 

  269.   malloc_fn, png_voidp mem_ptr));
    270. 

  270. PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
    271. 

  271.    png_free_ptr free_fn, png_voidp mem_ptr));
    272. 

  272. 

  273. /* Free any memory that info_ptr points to and reset struct. */
    274. 

  274. PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
    275. 

  275.    png_infop info_ptr));
    276. 

  276. 

  277. /* Function to allocate memory for zlib.  PNGAPI is disallowed. */
    278. 

  278. PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));
    279. 

  279. 

  280. /* Function to free memory for zlib.  PNGAPI is disallowed. */
    281. 

  281. PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
    282. 

  282. 

  283. /* Next four functions are used internally as callbacks.  PNGAPI is required
    284. 

  284.  * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3. */
    285. 

  285. 

  286. PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,
    287. 

  287.    png_bytep data, png_size_t length));
    288. 

  288. 

  289. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
    290. 

  290. PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,
    291. 

  291.    png_bytep buffer, png_size_t length));
    292. 

  292. #endif
    293. 

  293. 

  294. PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,
    295. 

  295.    png_bytep data, png_size_t length));
    296. 

  296. 

  297. #ifdef PNG_WRITE_FLUSH_SUPPORTED
    298. 

  298. #ifdef PNG_STDIO_SUPPORTED
    299. 

  299. PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));
    300. 

  300. #endif
    301. 

  301. #endif
    302. 

  302. 

  303. /* Reset the CRC variable */
    304. 

  304. PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
    305. 

  305. 

  306. /* Write the "data" buffer to whatever output you are using */
    307. 

  307. PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,
    308. 

  308.    png_size_t length));
    309. 

  309. 

  310. /* Read and check the PNG file signature */
    311. 

  311. PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr));
    312. 

  312. 

  313. /* Read the chunk header (length + type name) */
    314. 

  314. PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
    315. 

  315. 

  316. /* Read data from whatever input you are using into the "data" buffer */
    317. 

  317. PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
    318. 

  318.    png_size_t length));
    319. 

  319. 

  320. /* Read bytes into buf, and update png_ptr->crc */
    321. 

  321. PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
    322. 

  322.    png_size_t length));
    323. 

  323. 

  324. /* Decompress data in a chunk that uses compression */
    325. 

  325. #if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \
    326. 

  326.     defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
    327. 

  327. PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,
    328. 

  328.    int comp_type, png_size_t chunklength, png_size_t prefix_length,
    329. 

  329.    png_size_t *data_length));
    330. 

  330. #endif
    331. 

  331. 

  332. /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
    333. 

  333. PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));
    334. 

  334. 

  335. /* Read the CRC from the file and compare it to the libpng calculated CRC */
    336. 

  336. PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));
    337. 

  337. 

  338. /* Calculate the CRC over a section of data.  Note that we are only
    339. 

  339.  * passing a maximum of 64K on systems that have this as a memory limit,
    340. 

  340.  * since this is the maximum buffer size we can specify.
    341. 

  341.  */
    342. 

  342. PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,
    343. 

  343.    png_size_t length));
    344. 

  344. 

  345. #ifdef PNG_WRITE_FLUSH_SUPPORTED
    346. 

  346. PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
    347. 

  347. #endif
    348. 

  348. 

  349. /* Write various chunks */
    350. 

  350. 

  351. /* Write the IHDR chunk, and update the png_struct with the necessary
    352. 

  352.  * information.
    353. 

  353.  */
    354. 

  354. PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
    355. 

  355.    png_uint_32 height,
    356. 

  356.    int bit_depth, int color_type, int compression_method, int filter_method,
    357. 

  357.    int interlace_method));
    358. 

  358. 

  359. PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,
    360. 

  360.    png_uint_32 num_pal));
    361. 

  361. 

  362. PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
    363. 

  363.    png_size_t length));
    364. 

  364. 

  365. PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
    366. 

  366. 

  367. #ifdef PNG_WRITE_gAMA_SUPPORTED
    368. 

  368. #ifdef PNG_FLOATING_POINT_SUPPORTED
    369. 

  369. PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
    370. 

  370. #endif
    371. 

  371. #ifdef PNG_FIXED_POINT_SUPPORTED
    372. 

  372. PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,
    373. 

  373.     png_fixed_point file_gamma));
    374. 

  374. #endif
    375. 

  375. #endif
    376. 

  376. 

  377. #ifdef PNG_WRITE_sBIT_SUPPORTED
    378. 

  378. PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,
    379. 

  379.    int color_type));
    380. 

  380. #endif
    381. 

  381. 

  382. #ifdef PNG_WRITE_cHRM_SUPPORTED
    383. 

  383. #ifdef PNG_FLOATING_POINT_SUPPORTED
    384. 

  384. PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
    385. 

  385.    double white_x, double white_y,
    386. 

  386.    double red_x, double red_y, double green_x, double green_y,
    387. 

  387.    double blue_x, double blue_y));
    388. 

  388. #endif
    389. 

  389. PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
    390. 

  390.    png_fixed_point int_white_x, png_fixed_point int_white_y,
    391. 

  391.    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
    392. 

  392.    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
    393. 

  393.    png_fixed_point int_blue_y));
    394. 

  394. #endif
    395. 

  395. 

  396. #ifdef PNG_WRITE_sRGB_SUPPORTED
    397. 

  397. PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
    398. 

  398.    int intent));
    399. 

  399. #endif
    400. 

  400. 

  401. #ifdef PNG_WRITE_iCCP_SUPPORTED
    402. 

  402. PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
    403. 

  403.    png_charp name, int compression_type,
    404. 

  404.    png_charp profile, int proflen));
    405. 

  405.    /* Note to maintainer: profile should be png_bytep */
    406. 

  406. #endif
    407. 

  407. 

  408. #ifdef PNG_WRITE_sPLT_SUPPORTED
    409. 

  409. PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
    410. 

  410.    png_sPLT_tp palette));
    411. 

  411. #endif
    412. 

  412. 

  413. #ifdef PNG_WRITE_tRNS_SUPPORTED
    414. 

  414. PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
    415. 

  415.    png_color_16p values, int number, int color_type));
    416. 

  416. #endif
    417. 

  417. 

  418. #ifdef PNG_WRITE_bKGD_SUPPORTED
    419. 

  419. PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
    420. 

  420.    png_color_16p values, int color_type));
    421. 

  421. #endif
    422. 

  422. 

  423. #ifdef PNG_WRITE_hIST_SUPPORTED
    424. 

  424. PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
    425. 

  425.    int num_hist));
    426. 

  426. #endif
    427. 

  427. 

  428. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
    429. 

  429.     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
    430. 

  430. PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
    431. 

  431.    png_charp key, png_charpp new_key));
    432. 

  432. #endif
    433. 

  433. 

  434. #ifdef PNG_WRITE_tEXt_SUPPORTED
    435. 

  435. PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,
    436. 

  436.    png_charp text, png_size_t text_len));
    437. 

  437. #endif
    438. 

  438. 

  439. #ifdef PNG_WRITE_zTXt_SUPPORTED
    440. 

  440. PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,
    441. 

  441.    png_charp text, png_size_t text_len, int compression));
    442. 

  442. #endif
    443. 

  443. 

  444. #ifdef PNG_WRITE_iTXt_SUPPORTED
    445. 

  445. PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
    446. 

  446.    int compression, png_charp key, png_charp lang, png_charp lang_key,
    447. 

  447.    png_charp text));
    448. 

  448. #endif
    449. 

  449. 

  450. #ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */
    451. 

  451. PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
    452. 

  452.    png_infop info_ptr, png_textp text_ptr, int num_text));
    453. 

  453. #endif
    454. 

  454. 

  455. #ifdef PNG_WRITE_oFFs_SUPPORTED
    456. 

  456. PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
    457. 

  457.    png_int_32 x_offset, png_int_32 y_offset, int unit_type));
    458. 

  458. #endif
    459. 

  459. 

  460. #ifdef PNG_WRITE_pCAL_SUPPORTED
    461. 

  461. PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
    462. 

  462.    png_int_32 X0, png_int_32 X1, int type, int nparams,
    463. 

  463.    png_charp units, png_charpp params));
    464. 

  464. #endif
    465. 

  465. 

  466. #ifdef PNG_WRITE_pHYs_SUPPORTED
    467. 

  467. PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
    468. 

  468.    png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
    469. 

  469.    int unit_type));
    470. 

  470. #endif
    471. 

  471. 

  472. #ifdef PNG_WRITE_tIME_SUPPORTED
    473. 

  473. PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
    474. 

  474.    png_timep mod_time));
    475. 

  475. #endif
    476. 

  476. 

  477. #ifdef PNG_WRITE_sCAL_SUPPORTED
    478. 

  478. #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
    479. 

  479. PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,
    480. 

  480.    int unit, double width, double height));
    481. 

  481. #else
    482. 

  482. #ifdef PNG_FIXED_POINT_SUPPORTED
    483. 

  483. PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
    484. 

  484.    int unit, png_charp width, png_charp height));
    485. 

  485. #endif
    486. 

  486. #endif
    487. 

  487. #endif
    488. 

  488. 

  489. #ifdef PNG_WRITE_APNG_SUPPORTED
    490. 

  490. PNG_EXTERN void png_write_acTL PNGARG((png_structp png_ptr,
    491. 

  491.    png_uint_32 num_frames, png_uint_32 num_plays));
    492. 

  492. 

  493. PNG_EXTERN void png_write_fcTL PNGARG((png_structp png_ptr,
    494. 

  494.    png_uint_32 width, png_uint_32 height,
    495. 

  495.    png_uint_32 x_offset, png_uint_32 y_offset,
    496. 

  496.    png_uint_16 delay_num, png_uint_16 delay_den,
    497. 

  497.    png_byte dispose_op, png_byte blend_op));
    498. 

  498. #endif
    499. 

  499. 

  500. /* Called when finished processing a row of data */
    501. 

  501. PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
    502. 

  502. 

  503. /* Internal use only.   Called before first row of data */
    504. 

  504. PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
    505. 

  505. 

  506. #ifdef PNG_READ_GAMMA_SUPPORTED
    507. 

  507. PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr,
    508. 

  508.    png_byte bit_depth));
    509. 

  509. #endif
    510. 

  510. 

  511. /* Combine a row of data, dealing with alpha, etc. if requested */
    512. 

  512. PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
    513. 

  513.    int mask));
    514. 

  514. 

  515. #ifdef PNG_READ_INTERLACING_SUPPORTED
    516. 

  516. /* Expand an interlaced row */
    517. 

  517. /* OLD pre-1.0.9 interface:
    518. 

  518. PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,
    519. 

  519.    png_bytep row, int pass, png_uint_32 transformations));
    520. 

  520.  */
    521. 

  521. PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
    522. 

  522. #endif
    523. 

  523. 

  524. /* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */
    525. 

  525. 

  526. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    527. 

  527. /* Grab pixels out of a row for an interlaced pass */
    528. 

  528. PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,
    529. 

  529.    png_bytep row, int pass));
    530. 

  530. #endif
    531. 

  531. 

  532. /* Unfilter a row */
    533. 

  533. PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,
    534. 

  534.    png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));
    535. 

  535. 

  536. /* Choose the best filter to use and filter the row data */
    537. 

  537. PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,
    538. 

  538.    png_row_infop row_info));
    539. 

  539. 

  540. /* Write out the filtered row. */
    541. 

  541. PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,
    542. 

  542.    png_bytep filtered_row));
    543. 

  543. /* Finish a row while reading, dealing with interlacing passes, etc. */
    544. 

  544. PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));
    545. 

  545. 

  546. /* Initialize the row buffers, etc. */
    547. 

  547. PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));
    548. 

  548. /* Optional call to update the users info structure */
    549. 

  549. PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
    550. 

  550.    png_infop info_ptr));
    551. 

  551. 

  552. #ifdef PNG_READ_APNG_SUPPORTED
    553. 

  553. /* Private, reset some things to become ready for reading next frame */
    554. 

  554. PNG_EXTERN void png_read_reset PNGARG((png_structp png_ptr));
    555. 

  555. PNG_EXTERN void png_read_reinit PNGARG((png_structp png_ptr,
    556. 

  556.    png_infop info_ptr));
    557. 

  557. PNG_EXTERN void png_progressive_read_reset PNGARG((png_structp png_ptr));
    558. 

  558. #endif
    559. 

  559. #ifdef PNG_WRITE_APNG_SUPPORTED
    560. 

  560. /* Private, reset some things to become ready for writing next frame */
    561. 

  561. PNG_EXTERN void png_write_reset PNGARG((png_structp png_ptr));
    562. 

  562. PNG_EXTERN void png_write_reinit PNGARG((png_structp png_ptr,
    563. 

  563.    png_infop info_ptr, png_uint_32 width, png_uint_32 height));
    564. 

  564. #endif
    565. 

  565. 

  566. /* These are the functions that do the transformations */
    567. 

  567. #ifdef PNG_READ_FILLER_SUPPORTED
    568. 

  568. PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,
    569. 

  569.    png_bytep row, png_uint_32 filler, png_uint_32 flags));
    570. 

  570. #endif
    571. 

  571. 

  572. #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
    573. 

  573. PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
    574. 

  574.    png_bytep row));
    575. 

  575. #endif
    576. 

  576. 

  577. #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
    578. 

  578. PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
    579. 

  579.    png_bytep row));
    580. 

  580. #endif
    581. 

  581. 

  582. #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
    583. 

  583. PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
    584. 

  584.    png_bytep row));
    585. 

  585. #endif
    586. 

  586. 

  587. #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
    588. 

  588. PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
    589. 

  589.    png_bytep row));
    590. 

  590. #endif
    591. 

  591. 

  592. #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
    593. 

  593.     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
    594. 

  594. PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
    595. 

  595.    png_bytep row, png_uint_32 flags));
    596. 

  596. #endif
    597. 

  597. 

  598. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
    599. 

  599. PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));
    600. 

  600. #endif
    601. 

  601. 

  602. #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
    603. 

  603.     defined(PNG_WRITE_PACKSWAP_SUPPORTED)
    604. 

  604. PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));
    605. 

  605. #endif
    606. 

  606. 

  607. #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    608. 

  608. PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop
    609. 

  609.    row_info, png_bytep row));
    610. 

  610. #endif
    611. 

  611. 

  612. #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    613. 

  613. PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
    614. 

  614.    png_bytep row));
    615. 

  615. #endif
    616. 

  616. 

  617. #ifdef PNG_READ_PACK_SUPPORTED
    618. 

  618. PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));
    619. 

  619. #endif
    620. 

  620. 

  621. #ifdef PNG_READ_SHIFT_SUPPORTED
    622. 

  622. PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,
    623. 

  623.    png_color_8p sig_bits));
    624. 

  624. #endif
    625. 

  625. 

  626. #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
    627. 

  627. PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));
    628. 

  628. #endif
    629. 

  629. 

  630. #ifdef PNG_READ_16_TO_8_SUPPORTED
    631. 

  631. PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));
    632. 

  632. #endif
    633. 

  633. 

  634. #ifdef PNG_READ_QUANTIZE_SUPPORTED
    635. 

  635. PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,
    636. 

  636.    png_bytep row, png_bytep palette_lookup, png_bytep quantize_lookup));
    637. 

  637. 

  638. #  ifdef PNG_CORRECT_PALETTE_SUPPORTED
    639. 

  639. PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
    640. 

  640.    png_colorp palette, int num_palette));
    641. 

  641. #  endif
    642. 

  642. #endif
    643. 

  643. 

  644. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
    645. 

  645. PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));
    646. 

  646. #endif
    647. 

  647. 

  648. #ifdef PNG_WRITE_PACK_SUPPORTED
    649. 

  649. PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
    650. 

  650.    png_bytep row, png_uint_32 bit_depth));
    651. 

  651. #endif
    652. 

  652. 

  653. #ifdef PNG_WRITE_SHIFT_SUPPORTED
    654. 

  654. PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,
    655. 

  655.    png_color_8p bit_depth));
    656. 

  656. #endif
    657. 

  657. 

  658. #ifdef PNG_READ_BACKGROUND_SUPPORTED
    659. 

  659. #ifdef PNG_READ_GAMMA_SUPPORTED
    660. 

  660. PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
    661. 

  661.    png_color_16p trans_color, png_color_16p background,
    662. 

  662.    png_color_16p background_1,
    663. 

  663.    png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
    664. 

  664.    png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
    665. 

  665.    png_uint_16pp gamma_16_to_1, int gamma_shift));
    666. 

  666. #else
    667. 

  667. PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
    668. 

  668.    png_color_16p trans_color, png_color_16p background));
    669. 

  669. #endif
    670. 

  670. #endif
    671. 

  671. 

  672. #ifdef PNG_READ_GAMMA_SUPPORTED
    673. 

  673. PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,
    674. 

  674.    png_bytep gamma_table, png_uint_16pp gamma_16_table,
    675. 

  675.    int gamma_shift));
    676. 

  676. #endif
    677. 

  677. 

  678. #ifdef PNG_READ_EXPAND_SUPPORTED
    679. 

  679. PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,
    680. 

  680.    png_bytep row, png_colorp palette, png_bytep trans, int num_trans));
    681. 

  681. PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
    682. 

  682.    png_bytep row, png_color_16p trans_value));
    683. 

  683. #endif
    684. 

  684. 

  685. /* The following decodes the appropriate chunks, and does error correction,
    686. 

  686.  * then calls the appropriate callback for the chunk if it is valid.
    687. 

  687.  */
    688. 

  688. 

  689. /* Decode the IHDR chunk */
    690. 

  690. PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
    691. 

  691.    png_uint_32 length));
    692. 

  692. PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
    693. 

  693.    png_uint_32 length));
    694. 

  694. PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
    695. 

  695.    png_uint_32 length));
    696. 

  696. 

  697. #ifdef PNG_READ_bKGD_SUPPORTED
    698. 

  698. PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
    699. 

  699.    png_uint_32 length));
    700. 

  700. #endif
    701. 

  701. 

  702. #ifdef PNG_READ_cHRM_SUPPORTED
    703. 

  703. PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
    704. 

  704.    png_uint_32 length));
    705. 

  705. #endif
    706. 

  706. 

  707. #ifdef PNG_READ_gAMA_SUPPORTED
    708. 

  708. PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
    709. 

  709.    png_uint_32 length));
    710. 

  710. #endif
    711. 

  711. 

  712. #ifdef PNG_READ_hIST_SUPPORTED
    713. 

  713. PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
    714. 

  714.    png_uint_32 length));
    715. 

  715. #endif
    716. 

  716. 

  717. #ifdef PNG_READ_iCCP_SUPPORTED
    718. 

  718. PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
    719. 

  719.    png_uint_32 length));
    720. 

  720. #endif /* PNG_READ_iCCP_SUPPORTED */
    721. 

  721. 

  722. #ifdef PNG_READ_iTXt_SUPPORTED
    723. 

  723. PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
    724. 

  724.    png_uint_32 length));
    725. 

  725. #endif
    726. 

  726. 

  727. #ifdef PNG_READ_oFFs_SUPPORTED
    728. 

  728. PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
    729. 

  729.    png_uint_32 length));
    730. 

  730. #endif
    731. 

  731. 

  732. #ifdef PNG_READ_pCAL_SUPPORTED
    733. 

  733. PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
    734. 

  734.    png_uint_32 length));
    735. 

  735. #endif
    736. 

  736. 

  737. #ifdef PNG_READ_pHYs_SUPPORTED
    738. 

  738. PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
    739. 

  739.    png_uint_32 length));
    740. 

  740. #endif
    741. 

  741. 

  742. #ifdef PNG_READ_sBIT_SUPPORTED
    743. 

  743. PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
    744. 

  744.    png_uint_32 length));
    745. 

  745. #endif
    746. 

  746. 

  747. #ifdef PNG_READ_sCAL_SUPPORTED
    748. 

  748. PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
    749. 

  749.    png_uint_32 length));
    750. 

  750. #endif
    751. 

  751. 

  752. #ifdef PNG_READ_sPLT_SUPPORTED
    753. 

  753. PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
    754. 

  754.    png_uint_32 length));
    755. 

  755. #endif /* PNG_READ_sPLT_SUPPORTED */
    756. 

  756. 

  757. #ifdef PNG_READ_sRGB_SUPPORTED
    758. 

  758. PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
    759. 

  759.    png_uint_32 length));
    760. 

  760. #endif
    761. 

  761. 

  762. #ifdef PNG_READ_tEXt_SUPPORTED
    763. 

  763. PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
    764. 

  764.    png_uint_32 length));
    765. 

  765. #endif
    766. 

  766. 

  767. #ifdef PNG_READ_tIME_SUPPORTED
    768. 

  768. PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
    769. 

  769.    png_uint_32 length));
    770. 

  770. #endif
    771. 

  771. 

  772. #ifdef PNG_READ_tRNS_SUPPORTED
    773. 

  773. PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
    774. 

  774.    png_uint_32 length));
    775. 

  775. #endif
    776. 

  776. 

  777. #ifdef PNG_READ_zTXt_SUPPORTED
    778. 

  778. PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
    779. 

  779.    png_uint_32 length));
    780. 

  780. #endif
    781. 

  781. 

  782. #ifdef PNG_READ_APNG_SUPPORTED
    783. 

  783. PNG_EXTERN void png_handle_acTL PNGARG((png_structp png_ptr, png_infop info_ptr,
    784. 

  784.    png_uint_32 length));
    785. 

  785. PNG_EXTERN void png_handle_fcTL PNGARG((png_structp png_ptr, png_infop info_ptr,
    786. 

  786.    png_uint_32 length));
    787. 

  787. PNG_EXTERN void png_have_info PNGARG((png_structp png_ptr, png_infop info_ptr));
    788. 

  788. PNG_EXTERN void png_handle_fdAT PNGARG((png_structp png_ptr, png_infop info_ptr,
    789. 

  789.    png_uint_32 length));
    790. 

  790. PNG_EXTERN void png_ensure_sequence_number PNGARG((png_structp png_ptr,
    791. 

  791.    png_uint_32 length));
    792. 

  792. #endif
    793. 

  793. 

  794. PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
    795. 

  795.    png_infop info_ptr, png_uint_32 length));
    796. 

  796. 

  797. PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
    798. 

  798.    png_bytep chunk_name));
    799. 

  799. 

  800. /* Handle the transformations for reading and writing */
    801. 

  801. PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
    802. 

  802. PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
    803. 

  803. 

  804. PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
    805. 

  805. 

  806. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
    807. 

  807. PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
    808. 

  808.    png_infop info_ptr));
    809. 

  809. PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
    810. 

  810.    png_infop info_ptr));
    811. 

  811. PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
    812. 

  812. PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
    813. 

  813.    png_uint_32 length));
    814. 

  814. PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
    815. 

  815. PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
    816. 

  816. PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
    817. 

  817.    png_bytep buffer, png_size_t buffer_length));
    818. 

  818. PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
    819. 

  819. PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
    820. 

  820.    png_bytep buffer, png_size_t buffer_length));
    821. 

  821. PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
    822. 

  822. PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
    823. 

  823.    png_infop info_ptr, png_uint_32 length));
    824. 

  824. PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
    825. 

  825.    png_infop info_ptr));
    826. 

  826. PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
    827. 

  827.    png_infop info_ptr));
    828. 

  828. PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
    829. 

  829. PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
    830. 

  830.    png_infop info_ptr));
    831. 

  831. PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
    832. 

  832.    png_infop info_ptr));
    833. 

  833. PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
    834. 

  834. #ifdef PNG_READ_tEXt_SUPPORTED
    835. 

  835. PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,
    836. 

  836.    png_infop info_ptr, png_uint_32 length));
    837. 

  837. PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
    838. 

  838.    png_infop info_ptr));
    839. 

  839. #endif
    840. 

  840. #ifdef PNG_READ_zTXt_SUPPORTED
    841. 

  841. PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,
    842. 

  842.    png_infop info_ptr, png_uint_32 length));
    843. 

  843. PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
    844. 

  844.    png_infop info_ptr));
    845. 

  845. #endif
    846. 

  846. #ifdef PNG_READ_iTXt_SUPPORTED
    847. 

  847. PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,
    848. 

  848.    png_infop info_ptr, png_uint_32 length));
    849. 

  849. PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
    850. 

  850.    png_infop info_ptr));
    851. 

  851. #endif
    852. 

  852. 

  853. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
    854. 

  854. 

  855. #ifdef PNG_MNG_FEATURES_SUPPORTED
    856. 

  856. PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,
    857. 

  857.    png_bytep row));
    858. 

  858. PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
    859. 

  859.    png_bytep row));
    860. 

  860. #endif
    861. 

  861. 

  862. /* Added at libpng version 1.4.0 */
    863. 

  863. #ifdef PNG_cHRM_SUPPORTED
    864. 

  864. PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,
    865. 

  865.    png_fixed_point int_white_x, png_fixed_point int_white_y,
    866. 

  866.    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
    867. 

  867.    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
    868. 

  868.    png_fixed_point int_blue_y));
    869. 

  869. #endif
    870. 

  870. 

  871. #ifdef PNG_cHRM_SUPPORTED
    872. 

  872. #ifdef PNG_CHECK_cHRM_SUPPORTED
    873. 

  873. /* Added at libpng version 1.2.34 and 1.4.0 */
    874. 

  874. PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,
    875. 

  875.    unsigned long *hi_product, unsigned long *lo_product));
    876. 

  876. #endif
    877. 

  877. #endif
    878. 

  878. 

  879. /* Added at libpng version 1.4.0 */
    880. 

  880. PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,
    881. 

  881.    png_uint_32 width, png_uint_32 height, int bit_depth,
    882. 

  882.    int color_type, int interlace_type, int compression_type,
    883. 

  883.    int filter_type));
    884. 

  884. 

  885. /* Free all memory used by the read (old method - NOT DLL EXPORTED) */
    886. 

  886. PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,
    887. 

  887.    png_infop end_info_ptr));
    888. 

  888. 

  889. /* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
    890. 

  890. PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr));
    891. 

  891. 

  892. #ifdef USE_FAR_KEYWORD  /* memory model conversion function */
    893. 

  893. PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
    894. 

  894.    int check));
    895. 

  895. #endif /* USE_FAR_KEYWORD */
    896. 

  896. 

  897. /* Define PNG_DEBUG at compile time for debugging information.  Higher
    898. 

  898.  * numbers for PNG_DEBUG mean more debugging information.  This has
    899. 

  899.  * only been added since version 0.95 so it is not implemented throughout
    900. 

  900.  * libpng yet, but more support will be added as needed.
    901. 

  901.  */
    902. 

  902. #ifdef PNG_DEBUG
    903. 

  903. #if (PNG_DEBUG > 0)
    904. 

  904. #if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
    905. 

  905. #include <crtdbg.h>
    906. 

  906. #if (PNG_DEBUG > 1)
    907. 

  907. #ifndef _DEBUG
    908. 

  908. #  define _DEBUG
    909. 

  909. #endif
    910. 

  910. #ifndef png_debug
    911. 

  911. #define png_debug(l,m)  _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE)
    912. 

  912. #endif
    913. 

  913. #ifndef png_debug1
    914. 

  914. #define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1)
    915. 

  915. #endif
    916. 

  916. #ifndef png_debug2
    917. 

  917. #define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2)
    918. 

  918. #endif
    919. 

  919. #endif
    920. 

  920. #else /* PNG_DEBUG_FILE || !_MSC_VER */
    921. 

  921. #ifndef PNG_DEBUG_FILE
    922. 

  922. #define PNG_DEBUG_FILE stderr
    923. 

  923. #endif /* PNG_DEBUG_FILE */
    924. 

  924. 

  925. #if (PNG_DEBUG > 1)
    926. 

  926. /* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
    927. 

  927.  * non-ISO compilers
    928. 

  928.  */
    929. 

  929. #  ifdef __STDC__
    930. 

  930. #    ifndef png_debug
    931. 

  931. #      define png_debug(l,m) \
    932. 

  932.        { \
    933. 

  933.        int num_tabs=l; \
    934. 

  934.        fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
    935. 

  935.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
    936. 

  936.        }
    937. 

  937. #    endif
    938. 

  938. #    ifndef png_debug1
    939. 

  939. #      define png_debug1(l,m,p1) \
    940. 

  940.        { \
    941. 

  941.        int num_tabs=l; \
    942. 

  942.        fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
    943. 

  943.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
    944. 

  944.        }
    945. 

  945. #    endif
    946. 

  946. #    ifndef png_debug2
    947. 

  947. #      define png_debug2(l,m,p1,p2) \
    948. 

  948.        { \
    949. 

  949.        int num_tabs=l; \
    950. 

  950.        fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
    951. 

  951.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
    952. 

  952.        }
    953. 

  953. #    endif
    954. 

  954. #  else /* __STDC __ */
    955. 

  955. #    ifndef png_debug
    956. 

  956. #      define png_debug(l,m) \
    957. 

  957.        { \
    958. 

  958.        int num_tabs=l; \
    959. 

  959.        char format[256]; \
    960. 

  960.        snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
    961. 

  961.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
    962. 

  962.          m,PNG_STRING_NEWLINE); \
    963. 

  963.        fprintf(PNG_DEBUG_FILE,format); \
    964. 

  964.        }
    965. 

  965. #    endif
    966. 

  966. #    ifndef png_debug1
    967. 

  967. #      define png_debug1(l,m,p1) \
    968. 

  968.        { \
    969. 

  969.        int num_tabs=l; \
    970. 

  970.        char format[256]; \
    971. 

  971.        snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
    972. 

  972.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
    973. 

  973.          m,PNG_STRING_NEWLINE); \
    974. 

  974.        fprintf(PNG_DEBUG_FILE,format,p1); \
    975. 

  975.        }
    976. 

  976. #    endif
    977. 

  977. #    ifndef png_debug2
    978. 

  978. #      define png_debug2(l,m,p1,p2) \
    979. 

  979.        { \
    980. 

  980.        int num_tabs=l; \
    981. 

  981.        char format[256]; \
    982. 

  982.        snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
    983. 

  983.          (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
    984. 

  984.          m,PNG_STRING_NEWLINE); \
    985. 

  985.        fprintf(PNG_DEBUG_FILE,format,p1,p2); \
    986. 

  986.        }
    987. 

  987. #    endif
    988. 

  988. #  endif /* __STDC __ */
    989. 

  989. #endif /* (PNG_DEBUG > 1) */
    990. 

  990. 

  991. #endif /* _MSC_VER */
    992. 

  992. #endif /* (PNG_DEBUG > 0) */
    993. 

  993. #endif /* PNG_DEBUG */
    994. 

  994. #ifndef png_debug
    995. 

  995. #define png_debug(l, m)
    996. 

  996. #endif
    997. 

  997. #ifndef png_debug1
    998. 

  998. #define png_debug1(l, m, p1)
    999. 

  999. #endif
    1000. 

  1000. #ifndef png_debug2
    1001. 

  1001. #define png_debug2(l, m, p1, p2)
    1002. 

  1002. #endif
    1003. 

  1003. 

  1004. /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
    1005. 

  1005. 

  1006. #ifdef __cplusplus
    1007. 

  1007. }
    1008. 

  1008. #endif
    1009. 

  1009. 

  1010. #endif /* PNG_VERSION_INFO_ONLY */
    1011. 

  1011. #endif /* PNGPRIV_H */
    1012.