开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
png.h
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：149k
源码类别：

OpenGL

开发平台：

Visual C++

png.h：源码内容
  1. extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,
  2.    int crit_action, int ancil_action));
  4. /* Values for png_set_crc_action() to say how to handle CRC errors in
  5.  * ancillary and critical chunks, and whether to use the data contained
  6.  * therein.  Note that it is impossible to "discard" data in a critical
  7.  * chunk.  For versions prior to 0.90, the action was always error/quit,
  8.  * whereas in version 0.90 and later, the action for CRC errors in ancillary
  9.  * chunks is warn/discard.  These values should NOT be changed.
  10.  *
  11.  *      value                       action:critical     action:ancillary
  12.  */
  13. #define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */
  14. #define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */
  15. #define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */
  16. #define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */
  17. #define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */
  18. #define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */
  20. /* These functions give the user control over the scan-line filtering in
  21.  * libpng and the compression methods used by zlib.  These functions are
  22.  * mainly useful for testing, as the defaults should work with most users.
  23.  * Those users who are tight on memory or want faster performance at the
  24.  * expense of compression can modify them.  See the compression library
  25.  * header file (zlib.h) for an explination of the compression functions.
  26.  */
  28. /* set the filtering method(s) used by libpng.  Currently, the only valid
  29.  * value for "method" is 0.
  30.  */
  31. extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,
  32.    int filters));
  34. /* Flags for png_set_filter() to say which filters to use.  The flags
  35.  * are chosen so that they don't conflict with real filter types
  36.  * below, in case they are supplied instead of the #defined constants.
  37.  * These values should NOT be changed.
  38.  */
  39. #define PNG_NO_FILTERS     0x00
  40. #define PNG_FILTER_NONE    0x08
  41. #define PNG_FILTER_SUB     0x10
  42. #define PNG_FILTER_UP      0x20
  43. #define PNG_FILTER_AVG     0x40
  44. #define PNG_FILTER_PAETH   0x80
  45. #define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | 
  46.                          PNG_FILTER_AVG | PNG_FILTER_PAETH)
  48. /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
  49.  * These defines should NOT be changed.
  50.  */
  51. #define PNG_FILTER_VALUE_NONE  0
  52. #define PNG_FILTER_VALUE_SUB   1
  53. #define PNG_FILTER_VALUE_UP    2
  54. #define PNG_FILTER_VALUE_AVG   3
  55. #define PNG_FILTER_VALUE_PAETH 4
  56. #define PNG_FILTER_VALUE_LAST  5
  58. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */
  59. /* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_
  60.  * defines, either the default (minimum-sum-of-absolute-differences), or
  61.  * the experimental method (weighted-minimum-sum-of-absolute-differences).
  62.  *
  63.  * Weights are factors >= 1.0, indicating how important it is to keep the
  64.  * filter type consistent between rows.  Larger numbers mean the current
  65.  * filter is that many times as likely to be the same as the "num_weights"
  66.  * previous filters.  This is cumulative for each previous row with a weight.
  67.  * There needs to be "num_weights" values in "filter_weights", or it can be
  68.  * NULL if the weights aren't being specified.  Weights have no influence on
  69.  * the selection of the first row filter.  Well chosen weights can (in theory)
  70.  * improve the compression for a given image.
  71.  *
  72.  * Costs are factors >= 1.0 indicating the relative decoding costs of a
  73.  * filter type.  Higher costs indicate more decoding expense, and are
  74.  * therefore less likely to be selected over a filter with lower computational
  75.  * costs.  There needs to be a value in "filter_costs" for each valid filter
  76.  * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't
  77.  * setting the costs.  Costs try to improve the speed of decompression without
  78.  * unduly increasing the compressed image size.
  79.  *
  80.  * A negative weight or cost indicates the default value is to be used, and
  81.  * values in the range [0.0, 1.0) indicate the value is to remain unchanged.
  82.  * The default values for both weights and costs are currently 1.0, but may
  83.  * change if good general weighting/cost heuristics can be found.  If both
  84.  * the weights and costs are set to 1.0, this degenerates the WEIGHTED method
  85.  * to the UNWEIGHTED method, but with added encoding time/computation.
  86.  */
  87. #ifdef PNG_FLOATING_POINT_SUPPORTED
  88. extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,
  89.    int heuristic_method, int num_weights, png_doublep filter_weights,
  90.    png_doublep filter_costs));
  91. #endif
  92. #endif /*  PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
  94. /* Heuristic used for row filter selection.  These defines should NOT be
  95.  * changed.
  96.  */
  97. #define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */
  98. #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */
  99. #define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */
  100. #define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */
  102. /* Set the library compression level.  Currently, valid values range from
  103.  * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
  104.  * (0 - no compression, 9 - "maximal" compression).  Note that tests have
  105.  * shown that zlib compression levels 3-6 usually perform as well as level 9
  106.  * for PNG images, and do considerably fewer caclulations.  In the future,
  107.  * these values may not correspond directly to the zlib compression levels.
  108.  */
  109. extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,
  110.    int level));
  112. extern PNG_EXPORT(void,png_set_compression_mem_level)
  113.    PNGARG((png_structp png_ptr, int mem_level));
  115. extern PNG_EXPORT(void,png_set_compression_strategy)
  116.    PNGARG((png_structp png_ptr, int strategy));
  118. extern PNG_EXPORT(void,png_set_compression_window_bits)
  119.    PNGARG((png_structp png_ptr, int window_bits));
  121. extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,
  122.    int method));
  124. /* These next functions are called for input/output, memory, and error
  125.  * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,
  126.  * and call standard C I/O routines such as fread(), fwrite(), and
  127.  * fprintf().  These functions can be made to use other I/O routines
  128.  * at run time for those applications that need to handle I/O in a
  129.  * different manner by calling png_set_???_fn().  See libpng.txt for
  130.  * more information.
  131.  */
  133. #if !defined(PNG_NO_STDIO)
  134. /* Initialize the input/output for the PNG file to the default functions. */
  135. extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));
  136. #endif
  138. /* Replace the (error and abort), and warning functions with user
  139.  * supplied functions.  If no messages are to be printed you must still
  140.  * write and use replacement functions. The replacement error_fn should
  141.  * still do a longjmp to the last setjmp location if you are using this
  142.  * method of error handling.  If error_fn or warning_fn is NULL, the
  143.  * default function will be used.
  144.  */
  146. extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,
  147.    png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
  149. /* Return the user pointer associated with the error functions */
  150. extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));
  152. /* Replace the default data output functions with a user supplied one(s).
  153.  * If buffered output is not used, then output_flush_fn can be set to NULL.
  154.  * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
  155.  * output_flush_fn will be ignored (and thus can be NULL).
  156.  */
  157. extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,
  158.    png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
  160. /* Replace the default data input function with a user supplied one. */
  161. extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,
  162.    png_voidp io_ptr, png_rw_ptr read_data_fn));
  164. /* Return the user pointer associated with the I/O functions */
  165. extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));
  167. extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,
  168.    png_read_status_ptr read_row_fn));
  170. extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,
  171.    png_write_status_ptr write_row_fn));
  173. #ifdef PNG_USER_MEM_SUPPORTED
  174. /* Replace the default memory allocation functions with user supplied one(s). */
  175. extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,
  176.    png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));
  177. /* Return the user pointer associated with the memory functions */
  178. extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));
  179. #endif
  181. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || 
  182.     defined(PNG_LEGACY_SUPPORTED)
  183. extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp
  184.    png_ptr, png_user_transform_ptr read_user_transform_fn));
  185. #endif
  187. #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || 
  188.     defined(PNG_LEGACY_SUPPORTED)
  189. extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp
  190.    png_ptr, png_user_transform_ptr write_user_transform_fn));
  191. #endif
  193. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || 
  194.     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || 
  195.     defined(PNG_LEGACY_SUPPORTED)
  196. extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp
  197.    png_ptr, png_voidp user_transform_ptr, int user_transform_depth,
  198.    int user_transform_channels));
  199. /* Return the user pointer associated with the user transform functions */
  200. extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)
  201.    PNGARG((png_structp png_ptr));
  202. #endif
  204. #ifdef PNG_USER_CHUNKS_SUPPORTED
  205. extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,
  206.    png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
  207. extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp
  208.    png_ptr));
  209. #endif
  211. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  212. /* Sets the function callbacks for the push reader, and a pointer to a
  213.  * user-defined structure available to the callback functions.
  214.  */
  215. extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,
  216.    png_voidp progressive_ptr,
  217.    png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
  218.    png_progressive_end_ptr end_fn));
  220. /* returns the user pointer associated with the push read functions */
  221. extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)
  222.    PNGARG((png_structp png_ptr));
  224. /* function to be called when data becomes available */
  225. extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,
  226.    png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));
  228. /* function that combines rows.  Not very much different than the
  229.  * png_combine_row() call.  Is this even used?????
  230.  */
  231. extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,
  232.    png_bytep old_row, png_bytep new_row));
  233. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
  235. extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,
  236.    png_uint_32 size));
  238. #if defined(PNG_1_0_X)
  239. #  define png_malloc_warn png_malloc
  240. #else
  241. /* Added at libpng version 1.2.4 */
  242. extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,
  243.    png_uint_32 size));
  244. #endif
  246. /* frees a pointer allocated by png_malloc() */
  247. extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));
  249. #if defined(PNG_1_0_X)
  250. /* Function to allocate memory for zlib. */
  251. extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items,
  252.    uInt size));
  254. /* Function to free memory for zlib */
  255. extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr));
  256. #endif
  258. /* Free data that was allocated internally */
  259. extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,
  260.    png_infop info_ptr, png_uint_32 free_me, int num));
  261. #ifdef PNG_FREE_ME_SUPPORTED
  262. /* Reassign responsibility for freeing existing data, whether allocated
  263.  * by libpng or by the application */
  264. extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,
  265.    png_infop info_ptr, int freer, png_uint_32 mask));
  266. #endif
  267. /* assignments for png_data_freer */
  268. #define PNG_DESTROY_WILL_FREE_DATA 1
  269. #define PNG_SET_WILL_FREE_DATA 1
  270. #define PNG_USER_WILL_FREE_DATA 2
  271. /* Flags for png_ptr->free_me and info_ptr->free_me */
  272. #define PNG_FREE_HIST 0x0008
  273. #define PNG_FREE_ICCP 0x0010
  274. #define PNG_FREE_SPLT 0x0020
  275. #define PNG_FREE_ROWS 0x0040
  276. #define PNG_FREE_PCAL 0x0080
  277. #define PNG_FREE_SCAL 0x0100
  278. #define PNG_FREE_UNKN 0x0200
  279. #define PNG_FREE_LIST 0x0400
  280. #define PNG_FREE_PLTE 0x1000
  281. #define PNG_FREE_TRNS 0x2000
  282. #define PNG_FREE_TEXT 0x4000
  283. #define PNG_FREE_ALL  0x7fff
  284. #define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
  286. #ifdef PNG_USER_MEM_SUPPORTED
  287. extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,
  288.    png_uint_32 size));
  289. extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,
  290.    png_voidp ptr));
  291. #endif
  293. extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,
  294.    png_voidp s1, png_voidp s2, png_uint_32 size));
  296. extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,
  297.    png_voidp s1, int value, png_uint_32 size));
  299. #if defined(USE_FAR_KEYWORD)  /* memory model conversion function */
  300. extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,
  301.    int check));
  302. #endif /* USE_FAR_KEYWORD */
  304. #ifndef PNG_NO_ERROR_TEXT
  305. /* Fatal error in PNG image of libpng - can't continue */
  306. extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,
  307.    png_const_charp error_message));
  309. /* The same, but the chunk name is prepended to the error string. */
  310. extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,
  311.    png_const_charp error_message));
  312. #else
  313. /* Fatal error in PNG image of libpng - can't continue */
  314. extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr));
  315. #endif
  317. #ifndef PNG_NO_WARNINGS
  318. /* Non-fatal error in libpng.  Can continue, but may have a problem. */
  319. extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,
  320.    png_const_charp warning_message));
  322. #ifdef PNG_READ_SUPPORTED
  323. /* Non-fatal error in libpng, chunk name is prepended to message. */
  324. extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,
  325.    png_const_charp warning_message));
  326. #endif /* PNG_READ_SUPPORTED */
  327. #endif /* PNG_NO_WARNINGS */
  329. /* The png_set_<chunk> functions are for storing values in the png_info_struct.
  330.  * Similarly, the png_get_<chunk> calls are used to read values from the
  331.  * png_info_struct, either storing the parameters in the passed variables, or
  332.  * setting pointers into the png_info_struct where the data is stored.  The
  333.  * png_get_<chunk> functions return a non-zero value if the data was available
  334.  * in info_ptr, or return zero and do not change any of the parameters if the
  335.  * data was not available.
  336.  *
  337.  * These functions should be used instead of directly accessing png_info
  338.  * to avoid problems with future changes in the size and internal layout of
  339.  * png_info_struct.
  340.  */
  341. /* Returns "flag" if chunk data is valid in info_ptr. */
  342. extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,
  343. png_infop info_ptr, png_uint_32 flag));
  345. /* Returns number of bytes needed to hold a transformed row. */
  346. extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,
  347. png_infop info_ptr));
  349. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  350. /* Returns row_pointers, which is an array of pointers to scanlines that was
  351. returned from png_read_png(). */
  352. extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,
  353. png_infop info_ptr));
  354. /* Set row_pointers, which is an array of pointers to scanlines for use
  355. by png_write_png(). */
  356. extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,
  357.    png_infop info_ptr, png_bytepp row_pointers));
  358. #endif
  360. /* Returns number of color channels in image. */
  361. extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,
  362. png_infop info_ptr));
  364. #ifdef PNG_EASY_ACCESS_SUPPORTED
  365. /* Returns image width in pixels. */
  366. extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp
  367. png_ptr, png_infop info_ptr));
  369. /* Returns image height in pixels. */
  370. extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp
  371. png_ptr, png_infop info_ptr));
  373. /* Returns image bit_depth. */
  374. extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp
  375. png_ptr, png_infop info_ptr));
  377. /* Returns image color_type. */
  378. extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp
  379. png_ptr, png_infop info_ptr));
  381. /* Returns image filter_type. */
  382. extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp
  383. png_ptr, png_infop info_ptr));
  385. /* Returns image interlace_type. */
  386. extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp
  387. png_ptr, png_infop info_ptr));
  389. /* Returns image compression_type. */
  390. extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp
  391. png_ptr, png_infop info_ptr));
  393. /* Returns image resolution in pixels per meter, from pHYs chunk data. */
  394. extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp
  395. png_ptr, png_infop info_ptr));
  396. extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp
  397. png_ptr, png_infop info_ptr));
  398. extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp
  399. png_ptr, png_infop info_ptr));
  401. /* Returns pixel aspect ratio, computed from pHYs chunk data.  */
  402. #ifdef PNG_FLOATING_POINT_SUPPORTED
  403. extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp
  404. png_ptr, png_infop info_ptr));
  405. #endif
  407. /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
  408. extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp
  409. png_ptr, png_infop info_ptr));
  410. extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp
  411. png_ptr, png_infop info_ptr));
  412. extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp
  413. png_ptr, png_infop info_ptr));
  414. extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp
  415. png_ptr, png_infop info_ptr));
  417. #endif /* PNG_EASY_ACCESS_SUPPORTED */
  419. /* Returns pointer to signature string read from PNG header */
  420. extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,
  421. png_infop info_ptr));
  423. #if defined(PNG_bKGD_SUPPORTED)
  424. extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,
  425.    png_infop info_ptr, png_color_16p *background));
  426. #endif
  428. #if defined(PNG_bKGD_SUPPORTED)
  429. extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,
  430.    png_infop info_ptr, png_color_16p background));
  431. #endif
  433. #if defined(PNG_cHRM_SUPPORTED)
  434. #ifdef PNG_FLOATING_POINT_SUPPORTED
  435. extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,
  436.    png_infop info_ptr, double *white_x, double *white_y, double *red_x,
  437.    double *red_y, double *green_x, double *green_y, double *blue_x,
  438.    double *blue_y));
  439. #endif
  440. #ifdef PNG_FIXED_POINT_SUPPORTED
  441. extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,
  442.    png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point
  443.    *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,
  444.    png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point
  445.    *int_blue_x, png_fixed_point *int_blue_y));
  446. #endif
  447. #endif
  449. #if defined(PNG_cHRM_SUPPORTED)
  450. #ifdef PNG_FLOATING_POINT_SUPPORTED
  451. extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,
  452.    png_infop info_ptr, double white_x, double white_y, double red_x,
  453.    double red_y, double green_x, double green_y, double blue_x, double blue_y));
  454. #endif
  455. #ifdef PNG_FIXED_POINT_SUPPORTED
  456. extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,
  457.    png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,
  458.    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
  459.    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
  460.    png_fixed_point int_blue_y));
  461. #endif
  462. #endif
  464. #if defined(PNG_gAMA_SUPPORTED)
  465. #ifdef PNG_FLOATING_POINT_SUPPORTED
  466. extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,
  467.    png_infop info_ptr, double *file_gamma));
  468. #endif
  469. extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,
  470.    png_infop info_ptr, png_fixed_point *int_file_gamma));
  471. #endif
  473. #if defined(PNG_gAMA_SUPPORTED)
  474. #ifdef PNG_FLOATING_POINT_SUPPORTED
  475. extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,
  476.    png_infop info_ptr, double file_gamma));
  477. #endif
  478. extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,
  479.    png_infop info_ptr, png_fixed_point int_file_gamma));
  480. #endif
  482. #if defined(PNG_hIST_SUPPORTED)
  483. extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,
  484.    png_infop info_ptr, png_uint_16p *hist));
  485. #endif
  487. #if defined(PNG_hIST_SUPPORTED)
  488. extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,
  489.    png_infop info_ptr, png_uint_16p hist));
  490. #endif
  492. extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,
  493.    png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,
  494.    int *bit_depth, int *color_type, int *interlace_method,
  495.    int *compression_method, int *filter_method));
  497. extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,
  498.    png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
  499.    int color_type, int interlace_method, int compression_method,
  500.    int filter_method));
  502. #if defined(PNG_oFFs_SUPPORTED)
  503. extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,
  504.    png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
  505.    int *unit_type));
  506. #endif
  508. #if defined(PNG_oFFs_SUPPORTED)
  509. extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,
  510.    png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,
  511.    int unit_type));
  512. #endif
  514. #if defined(PNG_pCAL_SUPPORTED)
  515. extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,
  516.    png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,
  517.    int *type, int *nparams, png_charp *units, png_charpp *params));
  518. #endif
  520. #if defined(PNG_pCAL_SUPPORTED)
  521. extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,
  522.    png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,
  523.    int type, int nparams, png_charp units, png_charpp params));
  524. #endif
  526. #if defined(PNG_pHYs_SUPPORTED)
  527. extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,
  528.    png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
  529. #endif
  531. #if defined(PNG_pHYs_SUPPORTED)
  532. extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,
  533.    png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
  534. #endif
  536. extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,
  537.    png_infop info_ptr, png_colorp *palette, int *num_palette));
  539. extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,
  540.    png_infop info_ptr, png_colorp palette, int num_palette));
  542. #if defined(PNG_sBIT_SUPPORTED)
  543. extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,
  544.    png_infop info_ptr, png_color_8p *sig_bit));
  545. #endif
  547. #if defined(PNG_sBIT_SUPPORTED)
  548. extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,
  549.    png_infop info_ptr, png_color_8p sig_bit));
  550. #endif
  552. #if defined(PNG_sRGB_SUPPORTED)
  553. extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,
  554.    png_infop info_ptr, int *intent));
  555. #endif
  557. #if defined(PNG_sRGB_SUPPORTED)
  558. extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,
  559.    png_infop info_ptr, int intent));
  560. extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,
  561.    png_infop info_ptr, int intent));
  562. #endif
  564. #if defined(PNG_iCCP_SUPPORTED)
  565. extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,
  566.    png_infop info_ptr, png_charpp name, int *compression_type,
  567.    png_charpp profile, png_uint_32 *proflen));
  568.    /* Note to maintainer: profile should be png_bytepp */
  569. #endif
  571. #if defined(PNG_iCCP_SUPPORTED)
  572. extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,
  573.    png_infop info_ptr, png_charp name, int compression_type,
  574.    png_charp profile, png_uint_32 proflen));
  575.    /* Note to maintainer: profile should be png_bytep */
  576. #endif
  578. #if defined(PNG_sPLT_SUPPORTED)
  579. extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,
  580.    png_infop info_ptr, png_sPLT_tpp entries));
  581. #endif
  583. #if defined(PNG_sPLT_SUPPORTED)
  584. extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,
  585.    png_infop info_ptr, png_sPLT_tp entries, int nentries));
  586. #endif
  588. #if defined(PNG_TEXT_SUPPORTED)
  589. /* png_get_text also returns the number of text chunks in *num_text */
  590. extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,
  591.    png_infop info_ptr, png_textp *text_ptr, int *num_text));
  592. #endif
  594. /*
  595.  *  Note while png_set_text() will accept a structure whose text,
  596.  *  language, and  translated keywords are NULL pointers, the structure
  597.  *  returned by png_get_text will always contain regular
  598.  *  zero-terminated C strings.  They might be empty strings but
  599.  *  they will never be NULL pointers.
  600.  */
  602. #if defined(PNG_TEXT_SUPPORTED)
  603. extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,
  604.    png_infop info_ptr, png_textp text_ptr, int num_text));
  605. #endif
  607. #if defined(PNG_tIME_SUPPORTED)
  608. extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,
  609.    png_infop info_ptr, png_timep *mod_time));
  610. #endif
  612. #if defined(PNG_tIME_SUPPORTED)
  613. extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,
  614.    png_infop info_ptr, png_timep mod_time));
  615. #endif
  617. #if defined(PNG_tRNS_SUPPORTED)
  618. extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,
  619.    png_infop info_ptr, png_bytep *trans, int *num_trans,
  620.    png_color_16p *trans_values));
  621. #endif
  623. #if defined(PNG_tRNS_SUPPORTED)
  624. extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,
  625.    png_infop info_ptr, png_bytep trans, int num_trans,
  626.    png_color_16p trans_values));
  627. #endif
  629. #if defined(PNG_tRNS_SUPPORTED)
  630. #endif
  632. #if defined(PNG_sCAL_SUPPORTED)
  633. #ifdef PNG_FLOATING_POINT_SUPPORTED
  634. extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,
  635.    png_infop info_ptr, int *unit, double *width, double *height));
  636. #else
  637. #ifdef PNG_FIXED_POINT_SUPPORTED
  638. extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,
  639.    png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));
  640. #endif
  641. #endif
  642. #endif /* PNG_sCAL_SUPPORTED */
  644. #if defined(PNG_sCAL_SUPPORTED)
  645. #ifdef PNG_FLOATING_POINT_SUPPORTED
  646. extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,
  647.    png_infop info_ptr, int unit, double width, double height));
  648. #else
  649. #ifdef PNG_FIXED_POINT_SUPPORTED
  650. extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,
  651.    png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));
  652. #endif
  653. #endif
  654. #endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */
  656. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  657. /* provide a list of chunks and how they are to be handled, if the built-in
  658.    handling or default unknown chunk handling is not desired.  Any chunks not
  659.    listed will be handled in the default manner.  The IHDR and IEND chunks
  660.    must not be listed.
  661.       keep = 0: follow default behaviour
  662.            = 1: do not keep
  663.            = 2: keep only if safe-to-copy
  664.            = 3: keep even if unsafe-to-copy
  665. */
  666. extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp
  667.    png_ptr, int keep, png_bytep chunk_list, int num_chunks));
  668. extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,
  669.    png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));
  670. extern PNG_EXPORT(void, png_set_unknown_chunk_location)
  671.    PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));
  672. extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp
  673.    png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));
  674. #endif
  675. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  676. PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep
  677.    chunk_name));
  678. #endif
  680. /* Png_free_data() will turn off the "valid" flag for anything it frees.
  681.    If you need to turn it off for a chunk that your application has freed,
  682.    you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */
  683. extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,
  684.    png_infop info_ptr, int mask));
  686. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  687. /* The "params" pointer is currently not used and is for future expansion. */
  688. extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,
  689.                         png_infop info_ptr,
  690.                         int transforms,
  691.                         png_voidp params));
  692. extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
  693.                         png_infop info_ptr,
  694.                         int transforms,
  695.                         png_voidp params));
  696. #endif
  698. /* Define PNG_DEBUG at compile time for debugging information.  Higher
  699.  * numbers for PNG_DEBUG mean more debugging information.  This has
  700.  * only been added since version 0.95 so it is not implemented throughout
  701.  * libpng yet, but more support will be added as needed.
  702.  */
  703. #ifdef PNG_DEBUG
  704. #if (PNG_DEBUG > 0)
  705. #if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
  706. #include <crtdbg.h>
  707. #if (PNG_DEBUG > 1)
  708. #ifndef _DEBUG
  709. #  define _DEBUG
  710. #endif
  711. #ifndef png_debug
  712. #define png_debug(l,m)  _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE)
  713. #endif
  714. #ifndef png_debug1
  715. #define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1)
  716. #endif
  717. #ifndef png_debug2
  718. #define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2)
  719. #endif
  720. #endif
  721. #else /* PNG_DEBUG_FILE || !_MSC_VER */
  722. #ifndef PNG_DEBUG_FILE
  723. #define PNG_DEBUG_FILE stderr
  724. #endif /* PNG_DEBUG_FILE */
  725. #if (PNG_DEBUG > 1)
  726. #ifndef png_debug
  727. /* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
  728.  * non-ISO compilers */
  729. #ifdef __STDC__
  730. #define png_debug(l,m) 
  731. { 
  732.      int num_tabs=l; 
  733.      fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "t" : 
  734.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":"")))); 
  735. }
  736. #endif
  737. #ifndef png_debug1
  738. #define png_debug1(l,m,p1) 
  739. { 
  740.      int num_tabs=l; 
  741.      fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "t" : 
  742.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":""))),p1); 
  743. }
  744. #endif
  745. #ifndef png_debug2
  746. #define png_debug2(l,m,p1,p2) 
  747. { 
  748.      int num_tabs=l; 
  749.      fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "t" : 
  750.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":""))),p1,p2); 
  751. }
  752. #endif
  753. #else /* __STDC __ */
  754. #ifndef png_debug
  755. #define png_debug(l,m) 
  756.      int num_tabs=l; 
  757.      char format[256]; 
  758.      snprintf(format,256,"%s%s%s",(num_tabs==1 ? "t" : 
  759.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":""))), 
  760.        m,PNG_STRING_NEWLINE); 
  761.      fprintf(PNG_DEBUG_FILE,format);
  762. #endif
  763. #ifndef png_debug1
  764. #define png_debug1(l,m,p1) 
  765.      int num_tabs=l; 
  766.      char format[256]; 
  767.      snprintf(format,256,"%s%s%s",(num_tabs==1 ? "t" : 
  768.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":""))), 
  769.        m,PNG_STRING_NEWLINE); 
  770.      fprintf(PNG_DEBUG_FILE,format,p1);
  771. #endif
  772. #ifndef png_debug2
  773. #define png_debug2(l,m,p1,p2) 
  774.      int num_tabs=l; 
  775.      char format[256]; 
  776.      snprintf(format,256,"%s%s%s",(num_tabs==1 ? "t" : 
  777.        (num_tabs==2 ? "tt":(num_tabs>2 ? "ttt":""))), 
  778.        m,PNG_STRING_NEWLINE); 
  779.      fprintf(PNG_DEBUG_FILE,format,p1,p2);
  780. #endif
  781. #endif /* __STDC __ */
  782. #endif /* (PNG_DEBUG > 1) */
  783. #endif /* _MSC_VER */
  784. #endif /* (PNG_DEBUG > 0) */
  785. #endif /* PNG_DEBUG */
  786. #ifndef png_debug
  787. #define png_debug(l, m)
  788. #endif
  789. #ifndef png_debug1
  790. #define png_debug1(l, m, p1)
  791. #endif
  792. #ifndef png_debug2
  793. #define png_debug2(l, m, p1, p2)
  794. #endif
  796. extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));
  797. extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));
  798. extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));
  799. extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
  801. #ifdef PNG_MNG_FEATURES_SUPPORTED
  802. extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp
  803.    png_ptr, png_uint_32 mng_features_permitted));
  804. #endif
  806. /* For use in png_set_keep_unknown, added to version 1.2.6 */
  807. #define PNG_HANDLE_CHUNK_AS_DEFAULT   0
  808. #define PNG_HANDLE_CHUNK_NEVER        1
  809. #define PNG_HANDLE_CHUNK_IF_SAFE      2
  810. #define PNG_HANDLE_CHUNK_ALWAYS       3
  812. /* Added to version 1.2.0 */
  813. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
  814. #if defined(PNG_MMX_CODE_SUPPORTED)
  815. #define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED  0x01  /* not user-settable */
  816. #define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU    0x02  /* not user-settable */
  817. #define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  0x04
  818. #define PNG_ASM_FLAG_MMX_READ_INTERLACE    0x08
  819. #define PNG_ASM_FLAG_MMX_READ_FILTER_SUB   0x10
  820. #define PNG_ASM_FLAG_MMX_READ_FILTER_UP    0x20
  821. #define PNG_ASM_FLAG_MMX_READ_FILTER_AVG   0x40
  822. #define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80
  823. #define PNG_ASM_FLAGS_INITIALIZED          0x80000000  /* not user-settable */
  825. #define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  
  826.                            | PNG_ASM_FLAG_MMX_READ_INTERLACE    
  827.                            | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   
  828.                            | PNG_ASM_FLAG_MMX_READ_FILTER_UP    
  829.                            | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   
  830.                            | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH )
  831. #define PNG_MMX_WRITE_FLAGS ( 0 )
  833. #define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 
  834.                       | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU   
  835.                       | PNG_MMX_READ_FLAGS                
  836.                       | PNG_MMX_WRITE_FLAGS )
  838. #define PNG_SELECT_READ   1
  839. #define PNG_SELECT_WRITE  2
  840. #endif /* PNG_MMX_CODE_SUPPORTED */
  842. #if !defined(PNG_1_0_X)
  843. /* pngget.c */
  844. extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask)
  845.    PNGARG((int flag_select, int *compilerID));
  847. /* pngget.c */
  848. extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask)
  849.    PNGARG((int flag_select));
  851. /* pngget.c */
  852. extern PNG_EXPORT(png_uint_32,png_get_asm_flags)
  853.    PNGARG((png_structp png_ptr));
  855. /* pngget.c */
  856. extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold)
  857.    PNGARG((png_structp png_ptr));
  859. /* pngget.c */
  860. extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold)
  861.    PNGARG((png_structp png_ptr));
  863. /* pngset.c */
  864. extern PNG_EXPORT(void,png_set_asm_flags)
  865.    PNGARG((png_structp png_ptr, png_uint_32 asm_flags));
  867. /* pngset.c */
  868. extern PNG_EXPORT(void,png_set_mmx_thresholds)
  869.    PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,
  870.    png_uint_32 mmx_rowbytes_threshold));
  872. #endif /* PNG_1_0_X */
  874. #if !defined(PNG_1_0_X)
  875. /* png.c, pnggccrd.c, or pngvcrd.c */
  876. extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));
  877. #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
  879. /* Strip the prepended error numbers ("#nnn ") from error and warning
  880.  * messages before passing them to the error or warning handler. */
  881. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  882. extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp
  883.    png_ptr, png_uint_32 strip_mode));
  884. #endif
  886. #endif /* PNG_1_0_X */
  888. /* Added at libpng-1.2.6 */
  889. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  890. extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp
  891.    png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));
  892. extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp
  893.    png_ptr));
  894. extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp
  895.    png_ptr));
  896. #endif
  899. /* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */
  901. #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
  902. /* With these routines we avoid an integer divide, which will be slower on
  903.  * most machines.  However, it does take more operations than the corresponding
  904.  * divide method, so it may be slower on a few RISC systems.  There are two
  905.  * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
  906.  *
  907.  * Note that the rounding factors are NOT supposed to be the same!  128 and
  908.  * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
  909.  * standard method.
  910.  *
  911.  * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
  912.  */
  914.  /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */
  916. #  define png_composite(composite, fg, alpha, bg)                            
  917.      { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) 
  918.                         +        (png_uint_16)(bg)*(png_uint_16)(255 -       
  919.                         (png_uint_16)(alpha)) + (png_uint_16)128);           
  920.        (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
  922. #  define png_composite_16(composite, fg, alpha, bg)                         
  923.      { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) 
  924.                         + (png_uint_32)(bg)*(png_uint_32)(65535L -           
  925.                         (png_uint_32)(alpha)) + (png_uint_32)32768L);        
  926.        (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
  928. #else  /* standard method using integer division */
  930. #  define png_composite(composite, fg, alpha, bg)                            
  931.      (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) +    
  932.        (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) +       
  933.        (png_uint_16)127) / 255)
  935. #  define png_composite_16(composite, fg, alpha, bg)                         
  936.      (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + 
  937.        (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) +      
  938.        (png_uint_32)32767) / (png_uint_32)65535L)
  940. #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
  942. /* Inline macros to do direct reads of bytes from the input buffer.  These
  943.  * require that you are using an architecture that uses PNG byte ordering
  944.  * (MSB first) and supports unaligned data storage.  I think that PowerPC
  945.  * in big-endian mode and 680x0 are the only ones that will support this.
  946.  * The x86 line of processors definitely do not.  The png_get_int_32()
  947.  * routine also assumes we are using two's complement format for negative
  948.  * values, which is almost certainly true.
  949.  */
  950. #if defined(PNG_READ_BIG_ENDIAN_SUPPORTED)
  951. #  define png_get_uint_32(buf) ( *((png_uint_32p) (buf)))
  952. #  define png_get_uint_16(buf) ( *((png_uint_16p) (buf)))
  953. #  define png_get_int_32(buf)  ( *((png_int_32p)  (buf)))
  954. #else
  955. extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));
  956. extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));
  957. extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));
  958. #endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */
  959. extern PNG_EXPORT(png_uint_32,png_get_uint_31)
  960.   PNGARG((png_structp png_ptr, png_bytep buf));
  961. /* No png_get_int_16 -- may be added if there's a real need for it. */
  963. /* Place a 32-bit number into a buffer in PNG byte order (big-endian).
  964.  */
  965. extern PNG_EXPORT(void,png_save_uint_32)
  966.    PNGARG((png_bytep buf, png_uint_32 i));
  967. extern PNG_EXPORT(void,png_save_int_32)
  968.    PNGARG((png_bytep buf, png_int_32 i));
  970. /* Place a 16-bit number into a buffer in PNG byte order.
  971.  * The parameter is declared unsigned int, not png_uint_16,
  972.  * just to avoid potential problems on pre-ANSI C compilers.
  973.  */
  974. extern PNG_EXPORT(void,png_save_uint_16)
  975.    PNGARG((png_bytep buf, unsigned int i));
  976. /* No png_save_int_16 -- may be added if there's a real need for it. */
  978. /* ************************************************************************* */
  980. /* These next functions are used internally in the code.  They generally
  981.  * shouldn't be used unless you are writing code to add or replace some
  982.  * functionality in libpng.  More information about most functions can
  983.  * be found in the files where the functions are located.
  984.  */
  987. /* Various modes of operation, that are visible to applications because
  988.  * they are used for unknown chunk location.
  989.  */
  990. #define PNG_HAVE_IHDR               0x01
  991. #define PNG_HAVE_PLTE               0x02
  992. #define PNG_HAVE_IDAT               0x04
  993. #define PNG_AFTER_IDAT              0x08 /* Have complete zlib datastream */
  994. #define PNG_HAVE_IEND               0x10
  996. #if defined(PNG_INTERNAL)
  998. /* More modes of operation.  Note that after an init, mode is set to
  999.  * zero automatically when the structure is created.
  1000.  */
  1001. #define PNG_HAVE_gAMA               0x20
  1002. #define PNG_HAVE_cHRM               0x40
  1003. #define PNG_HAVE_sRGB               0x80
  1004. #define PNG_HAVE_CHUNK_HEADER      0x100
  1005. #define PNG_WROTE_tIME             0x200
  1006. #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
  1007. #define PNG_BACKGROUND_IS_GRAY     0x800
  1008. #define PNG_HAVE_PNG_SIGNATURE    0x1000
  1009. #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
  1011. /* flags for the transformations the PNG library does on the image data */
  1012. #define PNG_BGR                0x0001
  1013. #define PNG_INTERLACE          0x0002
  1014. #define PNG_PACK               0x0004
  1015. #define PNG_SHIFT              0x0008
  1016. #define PNG_SWAP_BYTES         0x0010
  1017. #define PNG_INVERT_MONO        0x0020
  1018. #define PNG_DITHER             0x0040
  1019. #define PNG_BACKGROUND         0x0080
  1020. #define PNG_BACKGROUND_EXPAND  0x0100
  1021.                           /*   0x0200 unused */
  1022. #define PNG_16_TO_8            0x0400
  1023. #define PNG_RGBA               0x0800
  1024. #define PNG_EXPAND             0x1000
  1025. #define PNG_GAMMA              0x2000
  1026. #define PNG_GRAY_TO_RGB        0x4000
  1027. #define PNG_FILLER             0x8000L
  1028. #define PNG_PACKSWAP          0x10000L
  1029. #define PNG_SWAP_ALPHA        0x20000L
  1030. #define PNG_STRIP_ALPHA       0x40000L
  1031. #define PNG_INVERT_ALPHA      0x80000L
  1032. #define PNG_USER_TRANSFORM   0x100000L
  1033. #define PNG_RGB_TO_GRAY_ERR  0x200000L
  1034. #define PNG_RGB_TO_GRAY_WARN 0x400000L
  1035. #define PNG_RGB_TO_GRAY      0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */
  1036.                        /*    0x800000L     Unused */
  1037. #define PNG_ADD_ALPHA       0x1000000L  /* Added to libpng-1.2.7 */
  1038. #define PNG_EXPAND_tRNS     0x2000000L  /* Added to libpng-1.2.9 */
  1039.                        /*   0x4000000L  unused */
  1040.                        /*   0x8000000L  unused */
  1041.                        /*  0x10000000L  unused */
  1042.                        /*  0x20000000L  unused */
  1043.                        /*  0x40000000L  unused */
  1045. /* flags for png_create_struct */
  1046. #define PNG_STRUCT_PNG   0x0001
  1047. #define PNG_STRUCT_INFO  0x0002
  1049. /* Scaling factor for filter heuristic weighting calculations */
  1050. #define PNG_WEIGHT_SHIFT 8
  1051. #define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
  1052. #define PNG_COST_SHIFT 3
  1053. #define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
  1055. /* flags for the png_ptr->flags rather than declaring a byte for each one */
  1056. #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001
  1057. #define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0002
  1058. #define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0004
  1059. #define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0008
  1060. #define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0010
  1061. #define PNG_FLAG_ZLIB_FINISHED            0x0020
  1062. #define PNG_FLAG_ROW_INIT                 0x0040
  1063. #define PNG_FLAG_FILLER_AFTER             0x0080
  1064. #define PNG_FLAG_CRC_ANCILLARY_USE        0x0100
  1065. #define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200
  1066. #define PNG_FLAG_CRC_CRITICAL_USE         0x0400
  1067. #define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800
  1068. #define PNG_FLAG_FREE_PLTE                0x1000
  1069. #define PNG_FLAG_FREE_TRNS                0x2000
  1070. #define PNG_FLAG_FREE_HIST                0x4000
  1071. #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L
  1072. #define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L
  1073. #define PNG_FLAG_LIBRARY_MISMATCH         0x20000L
  1074. #define PNG_FLAG_STRIP_ERROR_NUMBERS      0x40000L
  1075. #define PNG_FLAG_STRIP_ERROR_TEXT         0x80000L
  1076. #define PNG_FLAG_MALLOC_NULL_MEM_OK       0x100000L
  1077. #define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */
  1078. #define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */
  1079.                                   /*      0x800000L  unused */
  1080.                                   /*     0x1000000L  unused */
  1081.                                   /*     0x2000000L  unused */
  1082.                                   /*     0x4000000L  unused */
  1083.                                   /*     0x8000000L  unused */
  1084.                                   /*    0x10000000L  unused */
  1085.                                   /*    0x20000000L  unused */
  1086.                                   /*    0x40000000L  unused */
  1088. #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | 
  1089.                                      PNG_FLAG_CRC_ANCILLARY_NOWARN)
  1091. #define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | 
  1092.                                      PNG_FLAG_CRC_CRITICAL_IGNORE)
  1094. #define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | 
  1095.                                      PNG_FLAG_CRC_CRITICAL_MASK)
  1097. /* save typing and make code easier to understand */
  1099. #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + 
  1100.    abs((int)((c1).green) - (int)((c2).green)) + 
  1101.    abs((int)((c1).blue) - (int)((c2).blue)))
  1103. /* Added to libpng-1.2.6 JB */
  1104. #define PNG_ROWBYTES(pixel_bits, width) 
  1105.     ((pixel_bits) >= 8 ? 
  1106.     ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : 
  1107.     (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) )
  1109. /* PNG_OUT_OF_RANGE returns true if value is outside the range
  1110.    ideal-delta..ideal+delta.  Each argument is evaluated twice.
  1111.    "ideal" and "delta" should be constants, normally simple
  1112.    integers, "value" a variable. Added to libpng-1.2.6 JB */
  1113. #define PNG_OUT_OF_RANGE(value, ideal, delta) 
  1114.         ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
  1116. /* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
  1117. #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
  1118. /* place to hold the signature string for a PNG file. */
  1119. #ifdef PNG_USE_GLOBAL_ARRAYS
  1120.    PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8];
  1121. #else
  1122. #endif
  1123. #endif /* PNG_NO_EXTERN */
  1125. /* Constant strings for known chunk types.  If you need to add a chunk,
  1126.  * define the name here, and add an invocation of the macro in png.c and
  1127.  * wherever it's needed.
  1128.  */
  1129. #define PNG_IHDR png_byte png_IHDR[5] = { 73,  72,  68,  82, ''}
  1130. #define PNG_IDAT png_byte png_IDAT[5] = { 73,  68,  65,  84, ''}
  1131. #define PNG_IEND png_byte png_IEND[5] = { 73,  69,  78,  68, ''}
  1132. #define PNG_PLTE png_byte png_PLTE[5] = { 80,  76,  84,  69, ''}
  1133. #define PNG_bKGD png_byte png_bKGD[5] = { 98,  75,  71,  68, ''}
  1134. #define PNG_cHRM png_byte png_cHRM[5] = { 99,  72,  82,  77, ''}
  1135. #define PNG_gAMA png_byte png_gAMA[5] = {103,  65,  77,  65, ''}
  1136. #define PNG_hIST png_byte png_hIST[5] = {104,  73,  83,  84, ''}
  1137. #define PNG_iCCP png_byte png_iCCP[5] = {105,  67,  67,  80, ''}
  1138. #define PNG_iTXt png_byte png_iTXt[5] = {105,  84,  88, 116, ''}
  1139. #define PNG_oFFs png_byte png_oFFs[5] = {111,  70,  70, 115, ''}
  1140. #define PNG_pCAL png_byte png_pCAL[5] = {112,  67,  65,  76, ''}
  1141. #define PNG_sCAL png_byte png_sCAL[5] = {115,  67,  65,  76, ''}
  1142. #define PNG_pHYs png_byte png_pHYs[5] = {112,  72,  89, 115, ''}
  1143. #define PNG_sBIT png_byte png_sBIT[5] = {115,  66,  73,  84, ''}
  1144. #define PNG_sPLT png_byte png_sPLT[5] = {115,  80,  76,  84, ''}
  1145. #define PNG_sRGB png_byte png_sRGB[5] = {115,  82,  71,  66, ''}
  1146. #define PNG_tEXt png_byte png_tEXt[5] = {116,  69,  88, 116, ''}
  1147. #define PNG_tIME png_byte png_tIME[5] = {116,  73,  77,  69, ''}
  1148. #define PNG_tRNS png_byte png_tRNS[5] = {116,  82,  78,  83, ''}
  1149. #define PNG_zTXt png_byte png_zTXt[5] = {122,  84,  88, 116, ''}
  1151. #ifdef PNG_USE_GLOBAL_ARRAYS
  1152. PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5];
  1153. PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5];
  1154. PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5];
  1155. PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5];
  1156. PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5];
  1157. PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5];
  1158. PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5];
  1159. PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5];
  1160. PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5];
  1161. PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5];
  1162. PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5];
  1163. PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5];
  1164. PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5];
  1165. PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5];
  1166. PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5];
  1167. PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5];
  1168. PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5];
  1169. PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5];
  1170. PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5];
  1171. PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5];
  1172. PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5];
  1173. #endif /* PNG_USE_GLOBAL_ARRAYS */
  1175. #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
  1176. /* Initialize png_ptr struct for reading, and allocate any other memory.
  1177.  * (old interface - DEPRECATED - use png_create_read_struct instead).
  1178.  */
  1179. extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));
  1180. #undef png_read_init
  1181. #define png_read_init(png_ptr) png_read_init_3(&png_ptr, 
  1182.     PNG_LIBPNG_VER_STRING,  png_sizeof(png_struct));
  1183. #endif
  1185. extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr,
  1186.     png_const_charp user_png_ver, png_size_t png_struct_size));
  1187. #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
  1188. extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,
  1189.     png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
  1190.     png_info_size));
  1191. #endif
  1193. #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
  1194. /* Initialize png_ptr struct for writing, and allocate any other memory.
  1195.  * (old interface - DEPRECATED - use png_create_write_struct instead).
  1196.  */
  1197. extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));
  1198. #undef png_write_init
  1199. #define png_write_init(png_ptr) png_write_init_3(&png_ptr, 
  1200.     PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));
  1201. #endif
  1203. extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr,
  1204.     png_const_charp user_png_ver, png_size_t png_struct_size));
  1205. extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,
  1206.     png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
  1207.     png_info_size));
  1209. /* Allocate memory for an internal libpng struct */
  1210. PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
  1212. /* Free memory from internal libpng struct */
  1213. PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
  1215. PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr
  1216.   malloc_fn, png_voidp mem_ptr));
  1217. PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
  1218.    png_free_ptr free_fn, png_voidp mem_ptr));
  1220. /* Free any memory that info_ptr points to and reset struct. */
  1221. PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
  1222.    png_infop info_ptr));
  1224. #ifndef PNG_1_0_X
  1225. /* Function to allocate memory for zlib. */
  1226. PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));
  1228. /* Function to free memory for zlib */
  1229. PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
  1231. #ifdef PNG_SIZE_T
  1232. /* Function to convert a sizeof an item to png_sizeof item */
  1233.    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
  1234. #endif
  1236. /* Next four functions are used internally as callbacks.  PNGAPI is required
  1237.  * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3. */
  1239. PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,
  1240.    png_bytep data, png_size_t length));
  1242. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  1243. PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,
  1244.    png_bytep buffer, png_size_t length));
  1245. #endif
  1247. PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,
  1248.    png_bytep data, png_size_t length));
  1250. #if defined(PNG_WRITE_FLUSH_SUPPORTED)
  1251. #if !defined(PNG_NO_STDIO)
  1252. PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));
  1253. #endif
  1254. #endif
  1255. #else /* PNG_1_0_X */
  1256. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  1257. PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr,
  1258.    png_bytep buffer, png_size_t length));
  1259. #endif
  1260. #endif /* PNG_1_0_X */
  1262. /* Reset the CRC variable */
  1263. PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
  1265. /* Write the "data" buffer to whatever output you are using. */
  1266. PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,
  1267.    png_size_t length));
  1269. /* Read data from whatever input you are using into the "data" buffer */
  1270. PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
  1271.    png_size_t length));
  1273. /* Read bytes into buf, and update png_ptr->crc */
  1274. PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
  1275.    png_size_t length));
  1277. /* Decompress data in a chunk that uses compression */
  1278. #if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || 
  1279.     defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
  1280. PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,
  1281.    int comp_type, png_size_t chunklength,
  1282.    png_size_t prefix_length, png_size_t *data_length));
  1283. #endif
  1285. /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
  1286. PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));
  1288. /* Read the CRC from the file and compare it to the libpng calculated CRC */
  1289. PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));
  1291. /* Calculate the CRC over a section of data.  Note that we are only
  1292.  * passing a maximum of 64K on systems that have this as a memory limit,
  1293.  * since this is the maximum buffer size we can specify.
  1294.  */
  1295. PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,
  1296.    png_size_t length));
  1298. #if defined(PNG_WRITE_FLUSH_SUPPORTED)
  1299. PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
  1300. #endif
  1302. /* simple function to write the signature */
  1303. PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));
  1305. /* write various chunks */
  1307. /* Write the IHDR chunk, and update the png_struct with the necessary
  1308.  * information.
  1309.  */
  1310. PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
  1311.    png_uint_32 height,
  1312.    int bit_depth, int color_type, int compression_method, int filter_method,
  1313.    int interlace_method));
  1315. PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,
  1316.    png_uint_32 num_pal));
  1318. PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
  1319.    png_size_t length));
  1321. PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
  1323. #if defined(PNG_WRITE_gAMA_SUPPORTED)
  1324. #ifdef PNG_FLOATING_POINT_SUPPORTED
  1325. PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
  1326. #endif
  1327. #ifdef PNG_FIXED_POINT_SUPPORTED
  1328. PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point
  1329.     file_gamma));
  1330. #endif
  1331. #endif
  1333. #if defined(PNG_WRITE_sBIT_SUPPORTED)
  1334. PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,
  1335.    int color_type));
  1336. #endif
  1338. #if defined(PNG_WRITE_cHRM_SUPPORTED)
  1339. #ifdef PNG_FLOATING_POINT_SUPPORTED
  1340. PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
  1341.    double white_x, double white_y,
  1342.    double red_x, double red_y, double green_x, double green_y,
  1343.    double blue_x, double blue_y));
  1344. #endif
  1345. #ifdef PNG_FIXED_POINT_SUPPORTED
  1346. PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
  1347.    png_fixed_point int_white_x, png_fixed_point int_white_y,
  1348.    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
  1349.    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
  1350.    png_fixed_point int_blue_y));
  1351. #endif
  1352. #endif
  1354. #if defined(PNG_WRITE_sRGB_SUPPORTED)
  1355. PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
  1356.    int intent));
  1357. #endif
  1359. #if defined(PNG_WRITE_iCCP_SUPPORTED)
  1360. PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
  1361.    png_charp name, int compression_type,
  1362.    png_charp profile, int proflen));
  1363.    /* Note to maintainer: profile should be png_bytep */
  1364. #endif
  1366. #if defined(PNG_WRITE_sPLT_SUPPORTED)
  1367. PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
  1368.    png_sPLT_tp palette));
  1369. #endif
  1371. #if defined(PNG_WRITE_tRNS_SUPPORTED)
  1372. PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,
  1373.    png_color_16p values, int number, int color_type));
  1374. #endif
  1376. #if defined(PNG_WRITE_bKGD_SUPPORTED)
  1377. PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
  1378.    png_color_16p values, int color_type));
  1379. #endif
  1381. #if defined(PNG_WRITE_hIST_SUPPORTED)
  1382. PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,
  1383.    int num_hist));
  1384. #endif
  1386. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || 
  1387.     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
  1388. PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
  1389.    png_charp key, png_charpp new_key));
  1390. #endif
  1392. #if defined(PNG_WRITE_tEXt_SUPPORTED)
  1393. PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,
  1394.    png_charp text, png_size_t text_len));
  1395. #endif
  1397. #if defined(PNG_WRITE_zTXt_SUPPORTED)
  1398. PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,
  1399.    png_charp text, png_size_t text_len, int compression));
  1400. #endif
  1402. #if defined(PNG_WRITE_iTXt_SUPPORTED)
  1403. PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
  1404.    int compression, png_charp key, png_charp lang, png_charp lang_key,
  1405.    png_charp text));
  1406. #endif
  1408. #if defined(PNG_TEXT_SUPPORTED)  /* Added at version 1.0.14 and 1.2.4 */
  1409. PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
  1410.    png_infop info_ptr, png_textp text_ptr, int num_text));
  1411. #endif
  1413. #if defined(PNG_WRITE_oFFs_SUPPORTED)
  1414. PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
  1415.    png_int_32 x_offset, png_int_32 y_offset, int unit_type));
  1416. #endif
  1418. #if defined(PNG_WRITE_pCAL_SUPPORTED)
  1419. PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
  1420.    png_int_32 X0, png_int_32 X1, int type, int nparams,
  1421.    png_charp units, png_charpp params));
  1422. #endif
  1424. #if defined(PNG_WRITE_pHYs_SUPPORTED)
  1425. PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
  1426.    png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
  1427.    int unit_type));
  1428. #endif
  1430. #if defined(PNG_WRITE_tIME_SUPPORTED)
  1431. PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
  1432.    png_timep mod_time));
  1433. #endif
  1435. #if defined(PNG_WRITE_sCAL_SUPPORTED)
  1436. #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
  1437. PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,
  1438.    int unit, double width, double height));
  1439. #else
  1440. #ifdef PNG_FIXED_POINT_SUPPORTED
  1441. PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
  1442.    int unit, png_charp width, png_charp height));
  1443. #endif
  1444. #endif
  1445. #endif
  1447. /* Called when finished processing a row of data */
  1448. PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
  1450. /* Internal use only.   Called before first row of data */
  1451. PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
  1453. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1454. PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr));
  1455. #endif
  1457. /* combine a row of data, dealing with alpha, etc. if requested */
  1458. PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
  1459.    int mask));
  1461. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  1462. /* expand an interlaced row */
  1463. /* OLD pre-1.0.9 interface:
  1464. PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,
  1465.    png_bytep row, int pass, png_uint_32 transformations));
  1466.  */
  1467. PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
  1468. #endif
  1470. /* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */
  1472. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  1473. /* grab pixels out of a row for an interlaced pass */
  1474. PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,
  1475.    png_bytep row, int pass));
  1476. #endif
  1478. /* unfilter a row */
  1479. PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,
  1480.    png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));
  1482. /* Choose the best filter to use and filter the row data */
  1483. PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,
  1484.    png_row_infop row_info));
  1486. /* Write out the filtered row. */
  1487. PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,
  1488.    png_bytep filtered_row));
  1489. /* finish a row while reading, dealing with interlacing passes, etc. */
  1490. PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));
  1492. /* initialize the row buffers, etc. */
  1493. PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));
  1494. /* optional call to update the users info structure */
  1495. PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
  1496.    png_infop info_ptr));
  1498. /* these are the functions that do the transformations */
  1499. #if defined(PNG_READ_FILLER_SUPPORTED)
  1500. PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,
  1501.    png_bytep row, png_uint_32 filler, png_uint_32 flags));
  1502. #endif
  1504. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
  1505. PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
  1506.    png_bytep row));
  1507. #endif
  1509. #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  1510. PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
  1511.    png_bytep row));
  1512. #endif
  1514. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
  1515. PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
  1516.    png_bytep row));
  1517. #endif
  1519. #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  1520. PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
  1521.    png_bytep row));
  1522. #endif
  1524. #if defined(PNG_WRITE_FILLER_SUPPORTED) || 
  1525.     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  1526. PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
  1527.    png_bytep row, png_uint_32 flags));
  1528. #endif
  1530. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  1531. PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));
  1532. #endif
  1534. #if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  1535. PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));
  1536. #endif
  1538. #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  1539. PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop
  1540.    row_info, png_bytep row));
  1541. #endif
  1543. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1544. PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
  1545.    png_bytep row));
  1546. #endif
  1548. #if defined(PNG_READ_PACK_SUPPORTED)
  1549. PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));
  1550. #endif
  1552. #if defined(PNG_READ_SHIFT_SUPPORTED)
  1553. PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,
  1554.    png_color_8p sig_bits));
  1555. #endif
  1557. #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
  1558. PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));
  1559. #endif
  1561. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  1562. PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));
  1563. #endif
  1565. #if defined(PNG_READ_DITHER_SUPPORTED)
  1566. PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,
  1567.    png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));
  1569. #  if defined(PNG_CORRECT_PALETTE_SUPPORTED)
  1570. PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
  1571.    png_colorp palette, int num_palette));
  1572. #  endif
  1573. #endif
  1575. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  1576. PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));
  1577. #endif
  1579. #if defined(PNG_WRITE_PACK_SUPPORTED)
  1580. PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
  1581.    png_bytep row, png_uint_32 bit_depth));
  1582. #endif
  1584. #if defined(PNG_WRITE_SHIFT_SUPPORTED)
  1585. PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,
  1586.    png_color_8p bit_depth));
  1587. #endif
  1589. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1590. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1591. PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
  1592.    png_color_16p trans_values, png_color_16p background,
  1593.    png_color_16p background_1,
  1594.    png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
  1595.    png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
  1596.    png_uint_16pp gamma_16_to_1, int gamma_shift));
  1597. #else
  1598. PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,
  1599.    png_color_16p trans_values, png_color_16p background));
  1600. #endif
  1601. #endif
  1603. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1604. PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,
  1605.    png_bytep gamma_table, png_uint_16pp gamma_16_table,
  1606.    int gamma_shift));
  1607. #endif
  1609. #if defined(PNG_READ_EXPAND_SUPPORTED)
  1610. PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,
  1611.    png_bytep row, png_colorp palette, png_bytep trans, int num_trans));
  1612. PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
  1613.    png_bytep row, png_color_16p trans_value));
  1614. #endif
  1616. /* The following decodes the appropriate chunks, and does error correction,
  1617.  * then calls the appropriate callback for the chunk if it is valid.
  1618.  */
  1620. /* decode the IHDR chunk */
  1621. PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
  1622.    png_uint_32 length));
  1623. PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
  1624.    png_uint_32 length));
  1625. PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
  1626.    png_uint_32 length));
  1628. #if defined(PNG_READ_bKGD_SUPPORTED)
  1629. PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
  1630.    png_uint_32 length));
  1631. #endif
  1633. #if defined(PNG_READ_cHRM_SUPPORTED)
  1634. PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
  1635.    png_uint_32 length));
  1636. #endif
  1638. #if defined(PNG_READ_gAMA_SUPPORTED)
  1639. PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
  1640.    png_uint_32 length));
  1641. #endif
  1643. #if defined(PNG_READ_hIST_SUPPORTED)
  1644. PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
  1645.    png_uint_32 length));
  1646. #endif
  1648. #if defined(PNG_READ_iCCP_SUPPORTED)
  1649. extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
  1650.    png_uint_32 length));
  1651. #endif /* PNG_READ_iCCP_SUPPORTED */
  1653. #if defined(PNG_READ_iTXt_SUPPORTED)
  1654. PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
  1655.    png_uint_32 length));
  1656. #endif
  1658. #if defined(PNG_READ_oFFs_SUPPORTED)
  1659. PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
  1660.    png_uint_32 length));
  1661. #endif
  1663. #if defined(PNG_READ_pCAL_SUPPORTED)
  1664. PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
  1665.    png_uint_32 length));
  1666. #endif
  1668. #if defined(PNG_READ_pHYs_SUPPORTED)
  1669. PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
  1670.    png_uint_32 length));
  1671. #endif
  1673. #if defined(PNG_READ_sBIT_SUPPORTED)
  1674. PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
  1675.    png_uint_32 length));
  1676. #endif
  1678. #if defined(PNG_READ_sCAL_SUPPORTED)
  1679. PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
  1680.    png_uint_32 length));
  1681. #endif
  1683. #if defined(PNG_READ_sPLT_SUPPORTED)
  1684. extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
  1685.    png_uint_32 length));
  1686. #endif /* PNG_READ_sPLT_SUPPORTED */
  1688. #if defined(PNG_READ_sRGB_SUPPORTED)
  1689. PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
  1690.    png_uint_32 length));
  1691. #endif
  1693. #if defined(PNG_READ_tEXt_SUPPORTED)
  1694. PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
  1695.    png_uint_32 length));
  1696. #endif
  1698. #if defined(PNG_READ_tIME_SUPPORTED)
  1699. PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
  1700.    png_uint_32 length));
  1701. #endif
  1703. #if defined(PNG_READ_tRNS_SUPPORTED)
  1704. PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
  1705.    png_uint_32 length));
  1706. #endif
  1708. #if defined(PNG_READ_zTXt_SUPPORTED)
  1709. PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
  1710.    png_uint_32 length));
  1711. #endif
  1713. PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
  1714.    png_infop info_ptr, png_uint_32 length));
  1716. PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
  1717.    png_bytep chunk_name));
  1719. /* handle the transformations for reading and writing */
  1720. PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
  1721. PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
  1723. PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
  1725. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  1726. PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
  1727.    png_infop info_ptr));
  1728. PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
  1729.    png_infop info_ptr));
  1730. PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
  1731. PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
  1732.    png_uint_32 length));
  1733. PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
  1734. PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
  1735. PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
  1736.    png_bytep buffer, png_size_t buffer_length));
  1737. PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
  1738. PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
  1739.    png_bytep buffer, png_size_t buffer_length));
  1740. PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
  1741. PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
  1742.    png_infop info_ptr, png_uint_32 length));
  1743. PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
  1744.    png_infop info_ptr));
  1745. PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
  1746.    png_infop info_ptr));
  1747. PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
  1748. PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
  1749.    png_infop info_ptr));
  1750. PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
  1751.    png_infop info_ptr));
  1752. PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
  1753. #if defined(PNG_READ_tEXt_SUPPORTED)
  1754. PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,
  1755.    png_infop info_ptr, png_uint_32 length));
  1756. PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
  1757.    png_infop info_ptr));
  1758. #endif
  1759. #if defined(PNG_READ_zTXt_SUPPORTED)
  1760. PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,
  1761.    png_infop info_ptr, png_uint_32 length));
  1762. PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
  1763.    png_infop info_ptr));
  1764. #endif
  1765. #if defined(PNG_READ_iTXt_SUPPORTED)
  1766. PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,
  1767.    png_infop info_ptr, png_uint_32 length));
  1768. PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
  1769.    png_infop info_ptr));
  1770. #endif
  1772. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
  1774. #ifdef PNG_MNG_FEATURES_SUPPORTED
  1775. PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,
  1776.    png_bytep row));
  1777. PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
  1778.    png_bytep row));
  1779. #endif
  1781. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
  1782. #if defined(PNG_MMX_CODE_SUPPORTED)
  1783. /* png.c */ /* PRIVATE */
  1784. PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr));
  1785. #endif
  1786. #endif
  1788. #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
  1789. PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr,
  1790. png_infop info_ptr));
  1792. PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr,
  1793. png_infop info_ptr));
  1795. PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr,
  1796. png_infop info_ptr));
  1798. PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr,
  1799. png_infop info_ptr));
  1801. PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr,
  1802. png_infop info_ptr));
  1804. #if defined(PNG_pHYs_SUPPORTED)
  1805. PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr,
  1806. png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
  1807. #endif /* PNG_pHYs_SUPPORTED */
  1808. #endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
  1810. /* Read the chunk header (length + type name) */
  1811. PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
  1813. /* Added at libpng version 1.2.34 */
  1814. #if defined(PNG_cHRM_SUPPORTED)
  1815. PNG_EXTERN int png_check_cHRM_fixed  PNGARG((png_structp png_ptr,
  1816.    png_fixed_point int_white_x, png_fixed_point int_white_y,
  1817.    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
  1818.    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
  1819.    png_fixed_point int_blue_y));
  1820. #endif
  1822. /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
  1824. #endif /* PNG_INTERNAL */
  1826. #ifdef __cplusplus
  1827. }
  1828. #endif
  1830. #endif /* PNG_VERSION_INFO_ONLY */
  1831. /* do not put anything past this line */
  1832. #endif /* PNG_H */