WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/libpng/png.h

Rev	Author	Line No.	Line
4349	Serge	1
		2	*
		3	* libpng version 1.6.5 - September 14, 2013
		4	* Copyright (c) 1998-2013 Glenn Randers-Pehrson
		5	* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
		6	* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
		7	*
		8	* This code is released under the libpng license (See LICENSE, below)
		9	*
		10	* Authors and maintainers:
		11	* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
		12	* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
		13	* libpng versions 0.97, January 1998, through 1.6.5 - September 14, 2013: Glenn
		14	* See also "Contributing Authors", below.
		15	*
		16	* Note about libpng version numbers:
		17	*
		18	* Due to various miscommunications, unforeseen code incompatibilities
		19	* and occasional factors outside the authors' control, version numbering
		20	* on the library has not always been consistent and straightforward.
		21	* The following table summarizes matters since version 0.89c, which was
		22	* the first widely used release:
		23	*
		24	* source png.h png.h shared-lib
		25	* version string int version
		26	* ------- ------ ----- ----------
		27	* 0.89c "1.0 beta 3" 0.89 89 1.0.89
		28	* 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90]
		29	* 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95]
		30	* 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96]
		31	* 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97]
		32	* 0.97c 0.97 97 2.0.97
		33	* 0.98 0.98 98 2.0.98
		34	* 0.99 0.99 98 2.0.99
		35	* 0.99a-m 0.99 99 2.0.99
		36	* 1.00 1.00 100 2.1.0 [100 should be 10000]
		37	* 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000]
		38	* 1.0.1 png.h string is 10001 2.1.0
		39	* 1.0.1a-e identical to the 10002 from here on, the shared library
		40	* 1.0.2 source version) 10002 is 2.V where V is the source code
		41	* 1.0.2a-b 10003 version, except as noted.
		42	* 1.0.3 10003
		43	* 1.0.3a-d 10004
		44	* 1.0.4 10004
		45	* 1.0.4a-f 10005
		46	* 1.0.5 (+ 2 patches) 10005
		47	* 1.0.5a-d 10006
		48	* 1.0.5e-r 10100 (not source compatible)
		49	* 1.0.5s-v 10006 (not binary compatible)
		50	* 1.0.6 (+ 3 patches) 10006 (still binary incompatible)
		51	* 1.0.6d-f 10007 (still binary incompatible)
		52	* 1.0.6g 10007
		53	* 1.0.6h 10007 10.6h (testing xy.z so-numbering)
		54	* 1.0.6i 10007 10.6i
		55	* 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0)
		56	* 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible)
		57	* 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible)
		58	* 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible)
		59	* 1.0.7 1 10007 (still compatible)
		60	* 1.0.8beta1-4 1 10008 2.1.0.8beta1-4
		61	* 1.0.8rc1 1 10008 2.1.0.8rc1
		62	* 1.0.8 1 10008 2.1.0.8
		63	* 1.0.9beta1-6 1 10009 2.1.0.9beta1-6
		64	* 1.0.9rc1 1 10009 2.1.0.9rc1
		65	* 1.0.9beta7-10 1 10009 2.1.0.9beta7-10
		66	* 1.0.9rc2 1 10009 2.1.0.9rc2
		67	* 1.0.9 1 10009 2.1.0.9
		68	* 1.0.10beta1 1 10010 2.1.0.10beta1
		69	* 1.0.10rc1 1 10010 2.1.0.10rc1
		70	* 1.0.10 1 10010 2.1.0.10
		71	* 1.0.11beta1-3 1 10011 2.1.0.11beta1-3
		72	* 1.0.11rc1 1 10011 2.1.0.11rc1
		73	* 1.0.11 1 10011 2.1.0.11
		74	* 1.0.12beta1-2 2 10012 2.1.0.12beta1-2
		75	* 1.0.12rc1 2 10012 2.1.0.12rc1
		76	* 1.0.12 2 10012 2.1.0.12
		77	* 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned)
		78	* 1.2.0beta1-2 2 10200 2.1.2.0beta1-2
		79	* 1.2.0beta3-5 3 10200 3.1.2.0beta3-5
		80	* 1.2.0rc1 3 10200 3.1.2.0rc1
		81	* 1.2.0 3 10200 3.1.2.0
		82	* 1.2.1beta1-4 3 10201 3.1.2.1beta1-4
		83	* 1.2.1rc1-2 3 10201 3.1.2.1rc1-2
		84	* 1.2.1 3 10201 3.1.2.1
		85	* 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6
		86	* 1.0.13beta1 10 10013 10.so.0.1.0.13beta1
		87	* 1.0.13rc1 10 10013 10.so.0.1.0.13rc1
		88	* 1.2.2rc1 12 10202 12.so.0.1.2.2rc1
		89	* 1.0.13 10 10013 10.so.0.1.0.13
		90	* 1.2.2 12 10202 12.so.0.1.2.2
		91	* 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6
		92	* 1.2.3 12 10203 12.so.0.1.2.3
		93	* 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3
		94	* 1.0.14rc1 13 10014 10.so.0.1.0.14rc1
		95	* 1.2.4rc1 13 10204 12.so.0.1.2.4rc1
		96	* 1.0.14 10 10014 10.so.0.1.0.14
		97	* 1.2.4 13 10204 12.so.0.1.2.4
		98	* 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2
		99	* 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3
		100	* 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3
		101	* 1.0.15 10 10015 10.so.0.1.0.15
		102	* 1.2.5 13 10205 12.so.0.1.2.5
		103	* 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4
		104	* 1.0.16 10 10016 10.so.0.1.0.16
		105	* 1.2.6 13 10206 12.so.0.1.2.6
		106	* 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2
		107	* 1.0.17rc1 10 10017 12.so.0.1.0.17rc1
		108	* 1.2.7rc1 13 10207 12.so.0.1.2.7rc1
		109	* 1.0.17 10 10017 12.so.0.1.0.17
		110	* 1.2.7 13 10207 12.so.0.1.2.7
		111	* 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5
		112	* 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5
		113	* 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5
		114	* 1.0.18 10 10018 12.so.0.1.0.18
		115	* 1.2.8 13 10208 12.so.0.1.2.8
		116	* 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3
		117	* 1.2.9beta4-11 13 10209 12.so.0.9[.0]
		118	* 1.2.9rc1 13 10209 12.so.0.9[.0]
		119	* 1.2.9 13 10209 12.so.0.9[.0]
		120	* 1.2.10beta1-7 13 10210 12.so.0.10[.0]
		121	* 1.2.10rc1-2 13 10210 12.so.0.10[.0]
		122	* 1.2.10 13 10210 12.so.0.10[.0]
		123	* 1.4.0beta1-5 14 10400 14.so.0.0[.0]
		124	* 1.2.11beta1-4 13 10211 12.so.0.11[.0]
		125	* 1.4.0beta7-8 14 10400 14.so.0.0[.0]
		126	* 1.2.11 13 10211 12.so.0.11[.0]
		127	* 1.2.12 13 10212 12.so.0.12[.0]
		128	* 1.4.0beta9-14 14 10400 14.so.0.0[.0]
		129	* 1.2.13 13 10213 12.so.0.13[.0]
		130	* 1.4.0beta15-36 14 10400 14.so.0.0[.0]
		131	* 1.4.0beta37-87 14 10400 14.so.14.0[.0]
		132	* 1.4.0rc01 14 10400 14.so.14.0[.0]
		133	* 1.4.0beta88-109 14 10400 14.so.14.0[.0]
		134	* 1.4.0rc02-08 14 10400 14.so.14.0[.0]
		135	* 1.4.0 14 10400 14.so.14.0[.0]
		136	* 1.4.1beta01-03 14 10401 14.so.14.1[.0]
		137	* 1.4.1rc01 14 10401 14.so.14.1[.0]
		138	* 1.4.1beta04-12 14 10401 14.so.14.1[.0]
		139	* 1.4.1 14 10401 14.so.14.1[.0]
		140	* 1.4.2 14 10402 14.so.14.2[.0]
		141	* 1.4.3 14 10403 14.so.14.3[.0]
		142	* 1.4.4 14 10404 14.so.14.4[.0]
		143	* 1.5.0beta01-58 15 10500 15.so.15.0[.0]
		144	* 1.5.0rc01-07 15 10500 15.so.15.0[.0]
		145	* 1.5.0 15 10500 15.so.15.0[.0]
		146	* 1.5.1beta01-11 15 10501 15.so.15.1[.0]
		147	* 1.5.1rc01-02 15 10501 15.so.15.1[.0]
		148	* 1.5.1 15 10501 15.so.15.1[.0]
		149	* 1.5.2beta01-03 15 10502 15.so.15.2[.0]
		150	* 1.5.2rc01-03 15 10502 15.so.15.2[.0]
		151	* 1.5.2 15 10502 15.so.15.2[.0]
		152	* 1.5.3beta01-10 15 10503 15.so.15.3[.0]
		153	* 1.5.3rc01-02 15 10503 15.so.15.3[.0]
		154	* 1.5.3beta11 15 10503 15.so.15.3[.0]
		155	* 1.5.3 [omitted]
		156	* 1.5.4beta01-08 15 10504 15.so.15.4[.0]
		157	* 1.5.4rc01 15 10504 15.so.15.4[.0]
		158	* 1.5.4 15 10504 15.so.15.4[.0]
		159	* 1.5.5beta01-08 15 10505 15.so.15.5[.0]
		160	* 1.5.5rc01 15 10505 15.so.15.5[.0]
		161	* 1.5.5 15 10505 15.so.15.5[.0]
		162	* 1.5.6beta01-07 15 10506 15.so.15.6[.0]
		163	* 1.5.6rc01-03 15 10506 15.so.15.6[.0]
		164	* 1.5.6 15 10506 15.so.15.6[.0]
		165	* 1.5.7beta01-05 15 10507 15.so.15.7[.0]
		166	* 1.5.7rc01-03 15 10507 15.so.15.7[.0]
		167	* 1.5.7 15 10507 15.so.15.7[.0]
		168	* 1.6.0beta01-40 16 10600 16.so.16.0[.0]
		169	* 1.6.0rc01-08 16 10600 16.so.16.0[.0]
		170	* 1.6.0 16 10600 16.so.16.0[.0]
		171	* 1.6.1beta01-09 16 10601 16.so.16.1[.0]
		172	* 1.6.1rc01 16 10601 16.so.16.1[.0]
		173	* 1.6.1 16 10601 16.so.16.1[.0]
		174	* 1.6.2beta01 16 10602 16.so.16.2[.0]
		175	* 1.6.2rc01-06 16 10602 16.so.16.2[.0]
		176	* 1.6.2 16 10602 16.so.16.2[.0]
		177	* 1.6.3beta01-11 16 10603 16.so.16.3[.0]
		178	* 1.6.3rc01 16 10603 16.so.16.3[.0]
		179	* 1.6.3 16 10603 16.so.16.3[.0]
		180	* 1.6.4beta01-02 16 10604 16.so.16.4[.0]
		181	* 1.6.4rc01 16 10604 16.so.16.4[.0]
		182	* 1.6.4 16 10604 16.so.16.4[.0]
		183	* 1.6.5 16 10605 16.so.16.5[.0]
		184	*
		185	* Henceforth the source version will match the shared-library major
		186	* and minor numbers; the shared-library major version number will be
		187	* used for changes in backward compatibility, as it is intended. The
		188	* PNG_LIBPNG_VER macro, which is not used within libpng but is available
		189	* for applications, is an unsigned integer of the form xyyzz corresponding
		190	* to the source version x.y.z (leading zeros in y and z). Beta versions
		191	* were given the previous public release number plus a letter, until
		192	* version 1.0.6j; from then on they were given the upcoming public
		193	* release number plus "betaNN" or "rcNN".
		194	*
		195	* Binary incompatibility exists only when applications make direct access
		196	* to the info_ptr or png_ptr members through png.h, and the compiled
		197	* application is loaded with a different version of the library.
		198	*
		199	* DLLNUM will change each time there are forward or backward changes
		200	* in binary compatibility (e.g., when a new feature is added).
		201	*
		202	* See libpng-manual.txt or libpng.3 for more information. The PNG
		203	* specification is available as a W3C Recommendation and as an ISO
		204	* Specification,
		205	*/
		206
		207
		208	* COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
		209	*
		210	* If you modify libpng you may insert additional notices immediately following
		211	* this sentence.
		212	*
		213	* This code is released under the libpng license.
		214	*
		215	* libpng versions 1.2.6, August 15, 2004, through 1.6.5, September 14, 2013, are
		216	* Copyright (c) 2004, 2006-2013 Glenn Randers-Pehrson, and are
		217	* distributed according to the same disclaimer and license as libpng-1.2.5
		218	* with the following individual added to the list of Contributing Authors:
		219	*
		220	* Cosmin Truta
		221	*
		222	* libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are
		223	* Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
		224	* distributed according to the same disclaimer and license as libpng-1.0.6
		225	* with the following individuals added to the list of Contributing Authors:
		226	*
		227	* Simon-Pierre Cadieux
		228	* Eric S. Raymond
		229	* Gilles Vollant
		230	*
		231	* and with the following additions to the disclaimer:
		232	*
		233	* There is no warranty against interference with your enjoyment of the
		234	* library or against infringement. There is no warranty that our
		235	* efforts or the library will fulfill any of your particular purposes
		236	* or needs. This library is provided with all faults, and the entire
		237	* risk of satisfactory quality, performance, accuracy, and effort is with
		238	* the user.
		239	*
		240	* libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
		241	* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are
		242	* distributed according to the same disclaimer and license as libpng-0.96,
		243	* with the following individuals added to the list of Contributing Authors:
		244	*
		245	* Tom Lane
		246	* Glenn Randers-Pehrson
		247	* Willem van Schaik
		248	*
		249	* libpng versions 0.89, June 1996, through 0.96, May 1997, are
		250	* Copyright (c) 1996, 1997 Andreas Dilger
		251	* Distributed according to the same disclaimer and license as libpng-0.88,
		252	* with the following individuals added to the list of Contributing Authors:
		253	*
		254	* John Bowler
		255	* Kevin Bracey
		256	* Sam Bushell
		257	* Magnus Holmgren
		258	* Greg Roelofs
		259	* Tom Tanner
		260	*
		261	* libpng versions 0.5, May 1995, through 0.88, January 1996, are
		262	* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
		263	*
		264	* For the purposes of this copyright and license, "Contributing Authors"
		265	* is defined as the following set of individuals:
		266	*
		267	* Andreas Dilger
		268	* Dave Martindale
		269	* Guy Eric Schalnat
		270	* Paul Schmidt
		271	* Tim Wegner
		272	*
		273	* The PNG Reference Library is supplied "AS IS". The Contributing Authors
		274	* and Group 42, Inc. disclaim all warranties, expressed or implied,
		275	* including, without limitation, the warranties of merchantability and of
		276	* fitness for any purpose. The Contributing Authors and Group 42, Inc.
		277	* assume no liability for direct, indirect, incidental, special, exemplary,
		278	* or consequential damages, which may result from the use of the PNG
		279	* Reference Library, even if advised of the possibility of such damage.
		280	*
		281	* Permission is hereby granted to use, copy, modify, and distribute this
		282	* source code, or portions hereof, for any purpose, without fee, subject
		283	* to the following restrictions:
		284	*
		285	* 1. The origin of this source code must not be misrepresented.
		286	*
		287	* 2. Altered versions must be plainly marked as such and must not
		288	* be misrepresented as being the original source.
		289	*
		290	* 3. This Copyright notice may not be removed or altered from
		291	* any source or altered source distribution.
		292	*
		293	* The Contributing Authors and Group 42, Inc. specifically permit, without
		294	* fee, and encourage the use of this source code as a component to
		295	* supporting the PNG file format in commercial products. If you use this
		296	* source code in a product, acknowledgment is not required but would be
		297	* appreciated.
		298	*/
		299
		300
		301	* A "png_get_copyright" function is available, for convenient use in "about"
		302	* boxes and the like:
		303	*
		304	* printf("%s", png_get_copyright(NULL));
		305	*
		306	* Also, the PNG logo (in PNG format, of course) is supplied in the
		307	* files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
		308	*/
		309
		310
		311	* Libpng is OSI Certified Open Source Software. OSI Certified is a
		312	* certification mark of the Open Source Initiative.
		313	*/
		314
		315
		316	* The contributing authors would like to thank all those who helped
		317	* with testing, bug fixes, and patience. This wouldn't have been
		318	* possible without all of you.
		319	*
		320	* Thanks to Frank J. T. Wojcik for helping with the documentation.
		321	*/
		322
		323
		324	* Y2K compliance in libpng:
		325	* =========================
		326	*
		327	* September 14, 2013
		328	*
		329	* Since the PNG Development group is an ad-hoc body, we can't make
		330	* an official declaration.
		331	*
		332	* This is your unofficial assurance that libpng from version 0.71 and
		333	* upward through 1.6.5 are Y2K compliant. It is my belief that
		334	* earlier versions were also Y2K compliant.
		335	*
		336	* Libpng only has two year fields. One is a 2-byte unsigned integer
		337	* that will hold years up to 65535. The other, which is deprecated,
		338	* holds the date in text format, and will hold years up to 9999.
		339	*
		340	* The integer is
		341	* "png_uint_16 year" in png_time_struct.
		342	*
		343	* The string is
		344	* "char time_buffer[29]" in png_struct. This is no longer used
		345	* in libpng-1.6.x and will be removed from libpng-1.7.0.
		346	*
		347	* There are seven time-related functions:
		348	* png.c: png_convert_to_rfc_1123_buffer() in png.c
		349	* (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and
		350	* png_convert_to_rfc_1152() in error prior to libpng-0.98)
		351	* png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
		352	* png_convert_from_time_t() in pngwrite.c
		353	* png_get_tIME() in pngget.c
		354	* png_handle_tIME() in pngrutil.c, called in pngread.c
		355	* png_set_tIME() in pngset.c
		356	* png_write_tIME() in pngwutil.c, called in pngwrite.c
		357	*
		358	* All handle dates properly in a Y2K environment. The
		359	* png_convert_from_time_t() function calls gmtime() to convert from system
		360	* clock time, which returns (year - 1900), which we properly convert to
		361	* the full 4-digit year. There is a possibility that libpng applications
		362	* are not passing 4-digit years into the png_convert_to_rfc_1123_buffer()
		363	* function, or that they are incorrectly passing only a 2-digit year
		364	* instead of "year - 1900" into the png_convert_from_struct_tm() function,
		365	* but this is not under our control. The libpng documentation has always
		366	* stated that it works with 4-digit years, and the APIs have been
		367	* documented as such.
		368	*
		369	* The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned
		370	* integer to hold the year, and can hold years as large as 65535.
		371	*
		372	* zlib, upon which libpng depends, is also Y2K compliant. It contains
		373	* no date-related code.
		374	*
		375	* Glenn Randers-Pehrson
		376	* libpng maintainer
		377	* PNG Development Group
		378	*/
		379
		380
		381	#define PNG_H
		382
		383
		384	* describes how to use libpng, and the file example.c summarizes it
		385	* with some code on which to build. This file is useful for looking
		386	* at the actual function definitions and structure components.
		387	*
		388	* If you just need to read a PNG file and don't want to read the documentation
		389	* skip to the end of this file and read the section entitled 'simplified API'.
		390	*/
		391
		392
		393	#define PNG_LIBPNG_VER_STRING "1.6.5"
		394	#define PNG_HEADER_VERSION_STRING \
		395	" libpng version 1.6.5 - September 14, 2013\n"
		396
		397
		398	#define PNG_LIBPNG_VER_DLLNUM 16
		399
		400
		401	#define PNG_LIBPNG_VER_MAJOR 1
		402	#define PNG_LIBPNG_VER_MINOR 6
		403	#define PNG_LIBPNG_VER_RELEASE 5
		404
		405
		406	* PNG_LIBPNG_VER_STRING, omitting any leading zero:
		407	*/
		408
		409
		410
		411
		412	#define PNG_LIBPNG_BUILD_ALPHA 1
		413	#define PNG_LIBPNG_BUILD_BETA 2
		414	#define PNG_LIBPNG_BUILD_RC 3
		415	#define PNG_LIBPNG_BUILD_STABLE 4
		416	#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
		417
		418
		419	#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with
		420	PNG_LIBPNG_BUILD_STABLE only */
		421	#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
		422	PNG_LIBPNG_BUILD_SPECIAL */
		423	#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
		424	PNG_LIBPNG_BUILD_PRIVATE */
		425
		426
		427
		428
		429	* We must not include leading zeros.
		430	* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
		431	* version 1.0.0 was mis-numbered 100 instead of 10000). From
		432	* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release
		433	*/
		434	#define PNG_LIBPNG_VER 10605 /* 1.6.5 */
		435
		436
		437	* the library has been built.
		438	*/
		439	#ifndef PNGLCONF_H
		440	/* If pnglibconf.h is missing, you can
		441	* copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
		442	*/
		443	# include "pnglibconf.h"
		444	#endif
		445
		446
		447	/* Machine specific configuration. */
		448	# include "pngconf.h"
		449	#endif
		450
		451
		452	* Added at libpng-1.2.8
		453	*
		454	* Ref MSDN: Private as priority over Special
		455	* VS_FF_PRIVATEBUILD File was not built using standard release
		456	* procedures. If this value is given, the StringFileInfo block must
		457	* contain a PrivateBuild string.
		458	*
		459	* VS_FF_SPECIALBUILD File was built by the original company using
		460	* standard release procedures but is a variation of the standard
		461	* file of the same version number. If this value is given, the
		462	* StringFileInfo block must contain a SpecialBuild string.
		463	*/
		464
		465
		466	# define PNG_LIBPNG_BUILD_TYPE \
		467	(PNG_LIBPNG_BUILD_BASE_TYPE \| PNG_LIBPNG_BUILD_PRIVATE)
		468	#else
		469	# ifdef PNG_LIBPNG_SPECIALBUILD
		470	# define PNG_LIBPNG_BUILD_TYPE \
		471	(PNG_LIBPNG_BUILD_BASE_TYPE \| PNG_LIBPNG_BUILD_SPECIAL)
		472	# else
		473	# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
		474	# endif
		475	#endif
		476
		477
		478
		479
		480	#ifdef __cplusplus
		481	extern "C" {
		482	#endif /* __cplusplus */
		483
		484
		485	* the version above.
		486	*/
		487	#define png_libpng_ver png_get_header_ver(NULL)
		488
		489
		490	*
		491	* 1. Any configuration options that can be specified by for the application
		492	* code when it is built. (Build time configuration is in pnglibconf.h)
		493	* 2. Type definitions (base types are defined in pngconf.h), structure
		494	* definitions.
		495	* 3. Exported library functions.
		496	* 4. Simplified API.
		497	*
		498	* The library source code has additional files (principally pngpriv.h) that
		499	* allow configuration of the library.
		500	*/
		501	/* Section 1: run time configuration
		502	* See pnglibconf.h for build time configuration
		503	*
		504	* Run time configuration allows the application to choose between
		505	* implementations of certain arithmetic APIs. The default is set
		506	* at build time and recorded in pnglibconf.h, but it is safe to
		507	* override these (and only these) settings. Note that this won't
		508	* change what the library does, only application code, and the
		509	* settings can (and probably should) be made on a per-file basis
		510	* by setting the #defines before including png.h
		511	*
		512	* Use macros to read integers from PNG data or use the exported
		513	* functions?
		514	* PNG_USE_READ_MACROS: use the macros (see below) Note that
		515	* the macros evaluate their argument multiple times.
		516	* PNG_NO_USE_READ_MACROS: call the relevant library function.
		517	*
		518	* Use the alternative algorithm for compositing alpha samples that
		519	* does not use division?
		520	* PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division'
		521	* algorithm.
		522	* PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm.
		523	*
		524	* How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is
		525	* false?
		526	* PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error
		527	* APIs to png_warning.
		528	* Otherwise the calls are mapped to png_error.
		529	*/
		530
		531
		532	* constants.
		533	* See pngconf.h for base types that vary by machine/system
		534	*/
		535
		536
		537	* do not agree upon the version number.
		538	*/
		539	typedef char* png_libpng_version_1_6_5;
		540
		541
		542	*
		543	* png_struct is the cache of information used while reading or writing a single
		544	* PNG file. One of these is always required, although the simplified API
		545	* (below) hides the creation and destruction of it.
		546	*/
		547	typedef struct png_struct_def png_struct;
		548	typedef const png_struct * png_const_structp;
		549	typedef png_struct * png_structp;
		550	typedef png_struct * * png_structpp;
		551
		552
		553	* or more of these must exist while reading or creating a PNG file. The
		554	* information is not used by libpng during read but is used to control what
		555	* gets written when a PNG file is created. "png_get_" function calls read
		556	* information during read and "png_set_" functions calls write information
		557	* when creating a PNG.
		558	* been moved into a separate header file that is not accessible to
		559	* applications. Read libpng-manual.txt or libpng.3 for more info.
		560	*/
		561	typedef struct png_info_def png_info;
		562	typedef png_info * png_infop;
		563	typedef const png_info * png_const_infop;
		564	typedef png_info * * png_infopp;
		565
		566
		567	* names ending 'rp' are identical pointer types except that the pointer is
		568	* marked 'restrict', which means that it is the only pointer to the object
		569	* passed to the function. Applications should not use the 'restrict' types;
		570	* it is always valid to pass 'p' to a pointer with a function argument of the
		571	* corresponding 'rp' type. Different compilers have different rules with
		572	* regard to type matching in the presence of 'restrict'. For backward
		573	* compatibility libpng callbacks never have 'restrict' in their parameters and,
		574	* consequentially, writing portable application code is extremely difficult if
		575	* an attempt is made to use 'restrict'.
		576	*/
		577	typedef png_struct * PNG_RESTRICT png_structrp;
		578	typedef const png_struct * PNG_RESTRICT png_const_structrp;
		579	typedef png_info * PNG_RESTRICT png_inforp;
		580	typedef const png_info * PNG_RESTRICT png_const_inforp;
		581
		582
		583	* exact size) is not important, although the size of the fields need to
		584	* be png_byte or png_uint_16 (as defined below).
		585	*/
		586	typedef struct png_color_struct
		587	{
		588	png_byte red;
		589	png_byte green;
		590	png_byte blue;
		591	} png_color;
		592	typedef png_color * png_colorp;
		593	typedef const png_color * png_const_colorp;
		594	typedef png_color * * png_colorpp;
		595
		596
		597	{
		598	png_byte index; /* used for palette files */
		599	png_uint_16 red; /* for use in red green blue files */
		600	png_uint_16 green;
		601	png_uint_16 blue;
		602	png_uint_16 gray; /* for use in grayscale files */
		603	} png_color_16;
		604	typedef png_color_16 * png_color_16p;
		605	typedef const png_color_16 * png_const_color_16p;
		606	typedef png_color_16 * * png_color_16pp;
		607
		608
		609	{
		610	png_byte red; /* for use in red green blue files */
		611	png_byte green;
		612	png_byte blue;
		613	png_byte gray; /* for use in grayscale files */
		614	png_byte alpha; /* for alpha channel files */
		615	} png_color_8;
		616	typedef png_color_8 * png_color_8p;
		617	typedef const png_color_8 * png_const_color_8p;
		618	typedef png_color_8 * * png_color_8pp;
		619
		620
		621	* The following two structures are used for the in-core representation
		622	* of sPLT chunks.
		623	*/
		624	typedef struct png_sPLT_entry_struct
		625	{
		626	png_uint_16 red;
		627	png_uint_16 green;
		628	png_uint_16 blue;
		629	png_uint_16 alpha;
		630	png_uint_16 frequency;
		631	} png_sPLT_entry;
		632	typedef png_sPLT_entry * png_sPLT_entryp;
		633	typedef const png_sPLT_entry * png_const_sPLT_entryp;
		634	typedef png_sPLT_entry * * png_sPLT_entrypp;
		635
		636
		637	* occupy the LSB of their respective members, and the MSB of each member
		638	* is zero-filled. The frequency member always occupies the full 16 bits.
		639	*/
		640
		641
		642	{
		643	png_charp name; /* palette name */
		644	png_byte depth; /* depth of palette samples */
		645	png_sPLT_entryp entries; /* palette entries */
		646	png_int_32 nentries; /* number of palette entries */
		647	} png_sPLT_t;
		648	typedef png_sPLT_t * png_sPLT_tp;
		649	typedef const png_sPLT_t * png_const_sPLT_tp;
		650	typedef png_sPLT_t * * png_sPLT_tpp;
		651
		652
		653	/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
		654	* and whether that contents is compressed or not. The "key" field
		655	* points to a regular zero-terminated C string. The "text" fields can be a
		656	* regular C string, an empty string, or a NULL pointer.
		657	* However, the structure returned by png_get_text() will always contain
		658	* the "text" field as a regular zero-terminated C string (possibly
		659	* empty), never a NULL pointer, so it can be safely used in printf() and
		660	* other string-handling functions. Note that the "itxt_length", "lang", and
		661	* "lang_key" members of the structure only exist when the library is built
		662	* with iTXt chunk support. Prior to libpng-1.4.0 the library was built by
		663	* default without iTXt support. Also note that when iTXt is supported,
		664	* the "lang" and "lang_key" fields contain NULL pointers when the
		665	* "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
		666	* PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
		667	* same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
		668	* which is always 0 or 1, or its "compression method" which is always 0.
		669	*/
		670	typedef struct png_text_struct
		671	{
		672	int compression; /* compression value:
		673	-1: tEXt, none
		674	0: zTXt, deflate
		675	1: iTXt, none
		676	2: iTXt, deflate */
		677	png_charp key; /* keyword, 1-79 character description of "text" */
		678	png_charp text; /* comment, may be an empty string (ie "")
		679	or a NULL pointer */
		680	png_size_t text_length; /* length of the text string */
		681	png_size_t itxt_length; /* length of the itxt string */
		682	png_charp lang; /* language code, 0-79 characters
		683	or a NULL pointer */
		684	png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
		685	chars or a NULL pointer */
		686	} png_text;
		687	typedef png_text * png_textp;
		688	typedef const png_text * png_const_textp;
		689	typedef png_text * * png_textpp;
		690	#endif
		691
		692
		693	* The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
		694	#define PNG_TEXT_COMPRESSION_NONE_WR -3
		695	#define PNG_TEXT_COMPRESSION_zTXt_WR -2
		696	#define PNG_TEXT_COMPRESSION_NONE -1
		697	#define PNG_TEXT_COMPRESSION_zTXt 0
		698	#define PNG_ITXT_COMPRESSION_NONE 1
		699	#define PNG_ITXT_COMPRESSION_zTXt 2
		700	#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */
		701
		702
		703	* Two conversions are provided, both from time_t and struct tm. There
		704	* is no portable way to convert to either of these structures, as far
		705	* as I know. If you know of a portable way, send it to me. As a side
		706	* note - PNG has always been Year 2000 compliant!
		707	*/
		708	typedef struct png_time_struct
		709	{
		710	png_uint_16 year; /* full year, as in, 1995 */
		711	png_byte month; /* month of year, 1 - 12 */
		712	png_byte day; /* day of month, 1 - 31 */
		713	png_byte hour; /* hour of day, 0 - 23 */
		714	png_byte minute; /* minute of hour, 0 - 59 */
		715	png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
		716	} png_time;
		717	typedef png_time * png_timep;
		718	typedef const png_time * png_const_timep;
		719	typedef png_time * * png_timepp;
		720
		721
		722	/* png_unknown_chunk is a structure to hold queued chunks for which there is
		723	* no specific support. The idea is that we can use this to queue
		724	* up private chunks for output even though the library doesn't actually
		725	* know about their semantics.
		726	*
		727	* The data in the structure is set by libpng on read and used on write.
		728	*/
		729	typedef struct png_unknown_chunk_t
		730	{
		731	png_byte name[5]; /* Textual chunk name with '\0' terminator */
		732	png_byte data; / Data, should not be modified on read! */
		733	png_size_t size;
		734
		735
		736	* Notice that on read it is set by libpng however the values stored have
		737	* more bits set than are listed below. Always treat the value as a
		738	* bitmask. On write set only one bit - setting multiple bits may cause the
		739	* chunk to be written in multiple places.
		740	*/
		741	png_byte location; /* mode of operation at read time */
		742	}
		743	png_unknown_chunk;
		744
		745
		746	typedef const png_unknown_chunk * png_const_unknown_chunkp;
		747	typedef png_unknown_chunk * * png_unknown_chunkpp;
		748	#endif
		749
		750
		751	#define PNG_HAVE_IHDR 0x01
		752	#define PNG_HAVE_PLTE 0x02
		753	#define PNG_AFTER_IDAT 0x08
		754
		755
		756	#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
		757	#define PNG_UINT_32_MAX ((png_uint_32)(-1))
		758	#define PNG_SIZE_MAX ((png_size_t)(-1))
		759
		760
		761	* PNG specification manner (x100000)
		762	*/
		763	#define PNG_FP_1 100000
		764	#define PNG_FP_HALF 50000
		765	#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL)
		766	#define PNG_FP_MIN (-PNG_FP_MAX)
		767
		768
		769	/* color type masks */
		770	#define PNG_COLOR_MASK_PALETTE 1
		771	#define PNG_COLOR_MASK_COLOR 2
		772	#define PNG_COLOR_MASK_ALPHA 4
		773
		774
		775	#define PNG_COLOR_TYPE_GRAY 0
		776	#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR \| PNG_COLOR_MASK_PALETTE)
		777	#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
		778	#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR \| PNG_COLOR_MASK_ALPHA)
		779	#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
		780	/* aliases */
		781	#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA
		782	#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA
		783
		784
		785	#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
		786	#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
		787
		788
		789	#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */
		790	#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
		791	#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE
		792
		793
		794	#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */
		795	#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */
		796	#define PNG_INTERLACE_LAST 2 /* Not a valid value */
		797
		798
		799	#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */
		800	#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */
		801	#define PNG_OFFSET_LAST 2 /* Not a valid value */
		802
		803
		804	#define PNG_EQUATION_LINEAR 0 /* Linear transformation */
		805	#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */
		806	#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */
		807	#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */
		808	#define PNG_EQUATION_LAST 4 /* Not a valid value */
		809
		810
		811	#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */
		812	#define PNG_SCALE_METER 1 /* meters per pixel */
		813	#define PNG_SCALE_RADIAN 2 /* radians per pixel */
		814	#define PNG_SCALE_LAST 3 /* Not a valid value */
		815
		816
		817	#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */
		818	#define PNG_RESOLUTION_METER 1 /* pixels/meter */
		819	#define PNG_RESOLUTION_LAST 2 /* Not a valid value */
		820
		821
		822	#define PNG_sRGB_INTENT_PERCEPTUAL 0
		823	#define PNG_sRGB_INTENT_RELATIVE 1
		824	#define PNG_sRGB_INTENT_SATURATION 2
		825	#define PNG_sRGB_INTENT_ABSOLUTE 3
		826	#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */
		827
		828
		829	#define PNG_KEYWORD_MAX_LENGTH 79
		830
		831
		832	#define PNG_MAX_PALETTE_LENGTH 256
		833
		834
		835	* from the PNG header, or if the application has filled in the corresponding
		836	* data in the info_struct to be written into the output file. The values
		837	* of the PNG_INFO_ defines should NOT be changed.
		838	*/
		839	#define PNG_INFO_gAMA 0x0001
		840	#define PNG_INFO_sBIT 0x0002
		841	#define PNG_INFO_cHRM 0x0004
		842	#define PNG_INFO_PLTE 0x0008
		843	#define PNG_INFO_tRNS 0x0010
		844	#define PNG_INFO_bKGD 0x0020
		845	#define PNG_INFO_hIST 0x0040
		846	#define PNG_INFO_pHYs 0x0080
		847	#define PNG_INFO_oFFs 0x0100
		848	#define PNG_INFO_tIME 0x0200
		849	#define PNG_INFO_pCAL 0x0400
		850	#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */
		851	#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */
		852	#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */
		853	#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */
		854	#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */
		855
		856
		857	* change these values for the row. It also should enable using
		858	* the routines for other purposes.
		859	*/
		860	typedef struct png_row_info_struct
		861	{
		862	png_uint_32 width; /* width of row */
		863	png_size_t rowbytes; /* number of bytes in row */
		864	png_byte color_type; /* color type of row */
		865	png_byte bit_depth; /* bit depth of row */
		866	png_byte channels; /* number of channels (1, 2, 3, or 4) */
		867	png_byte pixel_depth; /* bits per pixel (depth * channels) */
		868	} png_row_info;
		869
		870
		871	typedef png_row_info * * png_row_infopp;
		872
		873
		874	* that allow the user to override the default I/O functions with his or her
		875	* own. The png_error_ptr type should match that of user-supplied warning
		876	* and error functions, while the png_rw_ptr type should match that of the
		877	* user read/write data functions. Note that the 'write' function must not
		878	* modify the buffer it is passed. The 'read' function, on the other hand, is
		879	* expected to return the read data in the buffer.
		880	*/
		881	typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
		882	typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
		883	typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
		884	typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
		885	int));
		886	typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
		887	int));
		888
		889
		890	typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
		891	typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop));
		892
		893
		894	* png_bytep data of the row. When transforming an interlaced image the
		895	* row number is the row number within the sub-image of the interlace pass, so
		896	* the value will increase to the height of the sub-image (not the full image)
		897	* then reset to 0 for the next pass.
		898	*
		899	* Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
		900	* find the output pixel (x,y) given an interlaced sub-image pixel
		901	* (row,col,pass). (See below for these macros.)
		902	*/
		903	typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
		904	png_uint_32, int));
		905	#endif
		906
		907
		908	defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
		909	typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
		910	png_bytep));
		911	#endif
		912
		913
		914	typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp,
		915	png_unknown_chunkp));
		916	#endif
		917	#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
		918	/* not used anywhere */
		919	/* typedef PNG_CALLBACK(void, png_unknown_chunk_ptr, (png_structp)); /
		920	#endif
		921
		922
		923	/* This must match the function definition in , and the application
		924	* must include this before png.h to obtain the definition of jmp_buf. The
		925	* function is required to be PNG_NORETURN, but this is not checked. If the
		926	* function does return the application will crash via an abort() or similar
		927	* system level call.
		928	*
		929	* If you get a warning here while building the library you may need to make
		930	* changes to ensure that pnglibconf.h records the calling convention used by
		931	* your compiler. This may be very difficult - try using a different compiler
		932	* to build the library!
		933	*/
		934	PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
		935	#endif
		936
		937
		938	#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */
		939	#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */
		940	#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */
		941	#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */
		942	#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */
		943	#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */
		944	#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */
		945	#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */
		946	#define PNG_TRANSFORM_BGR 0x0080 /* read and write */
		947	#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
		948	#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
		949	#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
		950	#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */
		951	/* Added to libpng-1.2.34 */
		952	#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
		953	#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
		954	/* Added to libpng-1.4.0 */
		955	#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */
		956	/* Added to libpng-1.5.4 */
		957	#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */
		958	#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */
		959
		960
		961	#define PNG_FLAG_MNG_EMPTY_PLTE 0x01
		962	#define PNG_FLAG_MNG_FILTER_64 0x04
		963	#define PNG_ALL_MNG_FEATURES 0x05
		964
		965
		966	* this allowed the zlib default functions to be used on Windows
		967	* platforms. In 1.5 the zlib default malloc (which just calls malloc and
		968	* ignores the first argument) should be completely compatible with the
		969	* following.
		970	*/
		971	typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
		972	png_alloc_size_t));
		973	typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
		974
		975
		976	* Here are the function definitions most commonly used. This is not
		977	* the place to find out how to use libpng. See libpng-manual.txt for the
		978	* full explanation, see example.c for the summary. This just provides
		979	* a simple one line description of the use of each function.
		980	*
		981	* The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in
		982	* pngconf.h and in the *.dfn files in the scripts directory.
		983	*
		984	* PNG_EXPORT(ordinal, type, name, (args));
		985	*
		986	* ordinal: ordinal that is used while building
		987	* *.def files. The ordinal value is only
		988	* relevant when preprocessing png.h with
		989	* the *.dfn files for building symbol table
		990	* entries, and are removed by pngconf.h.
		991	* type: return type of the function
		992	* name: function name
		993	* args: function arguments, with types
		994	*
		995	* When we wish to append attributes to a function prototype we use
		996	* the PNG_EXPORTA() macro instead.
		997	*
		998	* PNG_EXPORTA(ordinal, type, name, (args), attributes);
		999	*
		1000	* ordinal, type, name, and args: same as in PNG_EXPORT().
		1001	* attributes: function attributes
		1002	*/
		1003
		1004
		1005	PNG_EXPORT(1, png_uint_32, png_access_version_number, (void));
		1006
		1007
		1008	* Handling more than 8 bytes from the beginning of the file is an error.
		1009	*/
		1010	PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
		1011
		1012
		1013	* PNG file. Returns zero if the supplied bytes match the 8-byte PNG
		1014	* signature, and non-zero otherwise. Having num_to_check == 0 or
		1015	* start > 7 will always fail (ie return non-zero).
		1016	*/
		1017	PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
		1018	png_size_t num_to_check));
		1019
		1020
		1021	* png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
		1022	*/
		1023	#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))
		1024
		1025
		1026	PNG_EXPORTA(4, png_structp, png_create_read_struct,
		1027	(png_const_charp user_png_ver, png_voidp error_ptr,
		1028	png_error_ptr error_fn, png_error_ptr warn_fn),
		1029	PNG_ALLOCATED);
		1030
		1031
		1032	PNG_EXPORTA(5, png_structp, png_create_write_struct,
		1033	(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
		1034	png_error_ptr warn_fn),
		1035	PNG_ALLOCATED);
		1036
		1037
		1038	(png_const_structrp png_ptr));
		1039
		1040
		1041	png_size_t size));
		1042
		1043
		1044	* match up.
		1045	*/
		1046	#ifdef PNG_SETJMP_SUPPORTED
		1047	/* This function returns the jmp_buf built in to *png_ptr. It must be
		1048	* supplied with an appropriate 'longjmp' function to use on that jmp_buf
		1049	* unless the default error function is overridden in which case NULL is
		1050	* acceptable. The size of the jmp_buf is checked against the actual size
		1051	* allocated by the library - the call will return NULL on a mismatch
		1052	* indicating an ABI mismatch.
		1053	*/
		1054	PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
		1055	png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
		1056	# define png_jmpbuf(png_ptr) \
		1057	(*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
		1058	#else
		1059	# define png_jmpbuf(png_ptr) \
		1060	(LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
		1061	#endif
		1062	/* This function should be used by libpng applications in place of
		1063	* longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it
		1064	* will use it; otherwise it will call PNG_ABORT(). This function was
		1065	* added in libpng-1.5.0.
		1066	*/
		1067	PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
		1068	PNG_NORETURN);
		1069
		1070
		1071	/* Reset the compression stream */
		1072	PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
		1073	#endif
		1074
		1075
		1076	#ifdef PNG_USER_MEM_SUPPORTED
		1077	PNG_EXPORTA(11, png_structp, png_create_read_struct_2,
		1078	(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
		1079	png_error_ptr warn_fn,
		1080	png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
		1081	PNG_ALLOCATED);
		1082	PNG_EXPORTA(12, png_structp, png_create_write_struct_2,
		1083	(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
		1084	png_error_ptr warn_fn,
		1085	png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
		1086	PNG_ALLOCATED);
		1087	#endif
		1088
		1089
		1090	PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
		1091
		1092
		1093	PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
		1094	chunk_name, png_const_bytep data, png_size_t length));
		1095
		1096
		1097	PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
		1098	png_const_bytep chunk_name, png_uint_32 length));
		1099
		1100
		1101	PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
		1102	png_const_bytep data, png_size_t length));
		1103
		1104
		1105	PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
		1106
		1107
		1108	PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
		1109	PNG_ALLOCATED);
		1110
		1111
		1112	* default allocation method (typically malloc). Use is deprecated in 1.6.0 and
		1113	* the API will be removed in the future.
		1114	*/
		1115	PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
		1116	png_size_t png_info_struct_size), PNG_DEPRECATED);
		1117
		1118
		1119	PNG_EXPORT(20, void, png_write_info_before_PLTE,
		1120	(png_structrp png_ptr, png_const_inforp info_ptr));
		1121	PNG_EXPORT(21, void, png_write_info,
		1122	(png_structrp png_ptr, png_const_inforp info_ptr));
		1123
		1124
		1125	/* Read the information before the actual image data. */
		1126	PNG_EXPORT(22, void, png_read_info,
		1127	(png_structrp png_ptr, png_inforp info_ptr));
		1128	#endif
		1129
		1130
		1131	/* Convert to a US string format: there is no localization support in this
		1132	* routine. The original implementation used a 29 character buffer in
		1133	* png_struct, this will be removed in future versions.
		1134	*/
		1135	#if PNG_LIBPNG_VER < 10700
		1136	/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
		1137	PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
		1138	png_const_timep ptime),PNG_DEPRECATED);
		1139	#endif
		1140	PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
		1141	png_const_timep ptime));
		1142	#endif
		1143
		1144
		1145	/* Convert from a struct tm to png_time */
		1146	PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
		1147	const struct tm * ttime));
		1148
		1149
		1150	PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
		1151	#endif /* PNG_CONVERT_tIME_SUPPORTED */
		1152
		1153
		1154	/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
		1155	PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
		1156	PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
		1157	PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
		1158	PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
		1159	#endif
		1160
		1161
		1162	/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
		1163	* of a tRNS chunk if present.
		1164	*/
		1165	PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
		1166	#endif
		1167
		1168
		1169	/* Use blue, green, red order for pixels. */
		1170	PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
		1171	#endif
		1172
		1173
		1174	/* Expand the grayscale to 24-bit RGB if necessary. */
		1175	PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
		1176	#endif
		1177
		1178
		1179	/* Reduce RGB to grayscale. */
		1180	#define PNG_ERROR_ACTION_NONE 1
		1181	#define PNG_ERROR_ACTION_WARN 2
		1182	#define PNG_ERROR_ACTION_ERROR 3
		1183	#define PNG_RGB_TO_GRAY_DEFAULT (-1)/for red/green coefficients/
		1184
		1185
		1186	int error_action, double red, double green))
		1187	PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr,
		1188	int error_action, png_fixed_point red, png_fixed_point green))
		1189
		1190
		1191	png_ptr));
		1192	#endif
		1193
		1194
		1195	PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
		1196	png_colorp palette));
		1197	#endif
		1198
		1199
		1200	/* How the alpha channel is interpreted - this affects how the color channels of
		1201	* a PNG file are returned when an alpha channel, or tRNS chunk in a palette
		1202	* file, is present.
		1203	*
		1204	* This has no effect on the way pixels are written into a PNG output
		1205	* datastream. The color samples in a PNG datastream are never premultiplied
		1206	* with the alpha samples.
		1207	*
		1208	* The default is to return data according to the PNG specification: the alpha
		1209	* channel is a linear measure of the contribution of the pixel to the
		1210	* corresponding composited pixel. The gamma encoded color channels must be
		1211	* scaled according to the contribution and to do this it is necessary to undo
		1212	* the encoding, scale the color values, perform the composition and reencode
		1213	* the values. This is the 'PNG' mode.
		1214	*
		1215	* The alternative is to 'associate' the alpha with the color information by
		1216	* storing color channel values that have been scaled by the alpha. The
		1217	* advantage is that the color channels can be resampled (the image can be
		1218	* scaled) in this form. The disadvantage is that normal practice is to store
		1219	* linear, not (gamma) encoded, values and this requires 16-bit channels for
		1220	* still images rather than the 8-bit channels that are just about sufficient if
		1221	* gamma encoding is used. In addition all non-transparent pixel values,
		1222	* including completely opaque ones, must be gamma encoded to produce the final
		1223	* image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the
		1224	* latter being the two common names for associated alpha color channels.)
		1225	*
		1226	* Since it is not necessary to perform arithmetic on opaque color values so
		1227	* long as they are not to be resampled and are in the final color space it is
		1228	* possible to optimize the handling of alpha by storing the opaque pixels in
		1229	* the PNG format (adjusted for the output color space) while storing partially
		1230	* opaque pixels in the standard, linear, format. The accuracy required for
		1231	* standard alpha composition is relatively low, because the pixels are
		1232	* isolated, therefore typically the accuracy loss in storing 8-bit linear
		1233	* values is acceptable. (This is not true if the alpha channel is used to
		1234	* simulate transparency over large areas - use 16 bits or the PNG mode in
		1235	* this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is
		1236	* treated as opaque only if the alpha value is equal to the maximum value.
		1237	*
		1238	* The final choice is to gamma encode the alpha channel as well. This is
		1239	* broken because, in practice, no implementation that uses this choice
		1240	* correctly undoes the encoding before handling alpha composition. Use this
		1241	* choice only if other serious errors in the software or hardware you use
		1242	* mandate it; the typical serious error is for dark halos to appear around
		1243	* opaque areas of the composited PNG image because of arithmetic overflow.
		1244	*
		1245	* The API function png_set_alpha_mode specifies which of these choices to use
		1246	* with an enumerated 'mode' value and the gamma of the required output:
		1247	*/
		1248	#define PNG_ALPHA_PNG 0 /* according to the PNG standard */
		1249	#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */
		1250	#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */
		1251	#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */
		1252	#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */
		1253	#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */
		1254
		1255
		1256	double output_gamma))
		1257	PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
		1258	int mode, png_fixed_point output_gamma))
		1259	#endif
		1260
		1261
		1262	/* The output_gamma value is a screen gamma in libpng terminology: it expresses
		1263	* how to decode the output values, not how they are encoded. The values used
		1264	* correspond to the normal numbers used to describe the overall gamma of a
		1265	* computer display system; for example 2.2 for an sRGB conformant system. The
		1266	* values are scaled by 100000 in the _fixed version of the API (so 220000 for
		1267	* sRGB.)
		1268	*
		1269	* The inverse of the value is always used to provide a default for the PNG file
		1270	* encoding if it has no gAMA chunk and if png_set_gamma() has not been called
		1271	* to override the PNG gamma information.
		1272	*
		1273	* When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode
		1274	* opaque pixels however pixels with lower alpha values are not encoded,
		1275	* regardless of the output gamma setting.
		1276	*
		1277	* When the standard Porter Duff handling is requested with mode 1 the output
		1278	* encoding is set to be linear and the output_gamma value is only relevant
		1279	* as a default for input data that has no gamma information. The linear output
		1280	* encoding will be overridden if png_set_gamma() is called - the results may be
		1281	* highly unexpected!
		1282	*
		1283	* The following numbers are derived from the sRGB standard and the research
		1284	* behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of
		1285	* 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing
		1286	* correction required to take account of any differences in the color
		1287	* environment of the original scene and the intended display environment; the
		1288	* value expresses how to decode the image for display, not how the original
		1289	* data was encoded.
		1290	*
		1291	* sRGB provides a peg for the PNG standard by defining a viewing environment.
		1292	* sRGB itself, and earlier TV standards, actually use a more complex transform
		1293	* (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is
		1294	* limited to simple power laws.) By saying that an image for direct display on
		1295	* an sRGB conformant system should be stored with a gAMA chunk value of 45455
		1296	* (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification
		1297	* makes it possible to derive values for other display systems and
		1298	* environments.
		1299	*
		1300	* The Mac value is deduced from the sRGB based on an assumption that the actual
		1301	* extra viewing correction used in early Mac display systems was implemented as
		1302	* a power 1.45 lookup table.
		1303	*
		1304	* Any system where a programmable lookup table is used or where the behavior of
		1305	* the final display device characteristics can be changed requires system
		1306	* specific code to obtain the current characteristic. However this can be
		1307	* difficult and most PNG gamma correction only requires an approximate value.
		1308	*
		1309	* By default, if png_set_alpha_mode() is not called, libpng assumes that all
		1310	* values are unencoded, linear, values and that the output device also has a
		1311	* linear characteristic. This is only very rarely correct - it is invariably
		1312	* better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the
		1313	* default if you don't know what the right answer is!
		1314	*
		1315	* The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS
		1316	* 10.6) which used a correction table to implement a somewhat lower gamma on an
		1317	* otherwise sRGB system.
		1318	*
		1319	* Both these values are reserved (not simple gamma values) in order to allow
		1320	* more precise correction internally in the future.
		1321	*
		1322	* NOTE: the following values can be passed to either the fixed or floating
		1323	* point APIs, but the floating point API will also accept floating point
		1324	* values.
		1325	*/
		1326	#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */
		1327	#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */
		1328	#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */
		1329	#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */
		1330	#endif
		1331
		1332
		1333	* required overall gamma correction and, where necessary, alpha
		1334	* premultiplication.
		1335	*
		1336	* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
		1337	* This is the default libpng handling of the alpha channel - it is not
		1338	* pre-multiplied into the color components. In addition the call states
		1339	* that the output is for a sRGB system and causes all PNG files without gAMA
		1340	* chunks to be assumed to be encoded using sRGB.
		1341	*
		1342	* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
		1343	* In this case the output is assumed to be something like an sRGB conformant
		1344	* display preceeded by a power-law lookup table of power 1.45. This is how
		1345	* early Mac systems behaved.
		1346	*
		1347	* png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
		1348	* This is the classic Jim Blinn approach and will work in academic
		1349	* environments where everything is done by the book. It has the shortcoming
		1350	* of assuming that input PNG data with no gamma information is linear - this
		1351	* is unlikely to be correct unless the PNG files where generated locally.
		1352	* Most of the time the output precision will be so low as to show
		1353	* significant banding in dark areas of the image.
		1354	*
		1355	* png_set_expand_16(pp);
		1356	* png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
		1357	* This is a somewhat more realistic Jim Blinn inspired approach. PNG files
		1358	* are assumed to have the sRGB encoding if not marked with a gamma value and
		1359	* the output is always 16 bits per component. This permits accurate scaling
		1360	* and processing of the data. If you know that your input PNG files were
		1361	* generated locally you might need to replace PNG_DEFAULT_sRGB with the
		1362	* correct value for your system.
		1363	*
		1364	* png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
		1365	* If you just need to composite the PNG image onto an existing background
		1366	* and if you control the code that does this you can use the optimization
		1367	* setting. In this case you just copy completely opaque pixels to the
		1368	* output. For pixels that are not completely transparent (you just skip
		1369	* those) you do the composition math using png_composite or png_composite_16
		1370	* below then encode the resultant 8-bit or 16-bit values to match the output
		1371	* encoding.
		1372	*
		1373	* Other cases
		1374	* If neither the PNG nor the standard linear encoding work for you because
		1375	* of the software or hardware you use then you have a big problem. The PNG
		1376	* case will probably result in halos around the image. The linear encoding
		1377	* will probably result in a washed out, too bright, image (it's actually too
		1378	* contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably
		1379	* substantially reduce the halos. Alternatively try:
		1380	*
		1381	* png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
		1382	* This option will also reduce the halos, but there will be slight dark
		1383	* halos round the opaque parts of the image where the background is light.
		1384	* In the OPTIMIZED mode the halos will be light halos where the background
		1385	* is dark. Take your pick - the halos are unavoidable unless you can get
		1386	* your hardware/software fixed! (The OPTIMIZED approach is slightly
		1387	* faster.)
		1388	*
		1389	* When the default gamma of PNG files doesn't match the output gamma.
		1390	* If you have PNG files with no gamma information png_set_alpha_mode allows
		1391	* you to provide a default gamma, but it also sets the ouput gamma to the
		1392	* matching value. If you know your PNG files have a gamma that doesn't
		1393	* match the output you can take advantage of the fact that
		1394	* png_set_alpha_mode always sets the output gamma but only sets the PNG
		1395	* default if it is not already set:
		1396	*
		1397	* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
		1398	* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
		1399	* The first call sets both the default and the output gamma values, the
		1400	* second call overrides the output gamma without changing the default. This
		1401	* is easier than achieving the same effect with png_set_gamma. You must use
		1402	* PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
		1403	* fire if more than one call to png_set_alpha_mode and png_set_background is
		1404	* made in the same read operation, however multiple calls with PNG_ALPHA_PNG
		1405	* are ignored.
		1406	*/
		1407
		1408
		1409	PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
		1410	#endif
		1411
		1412
		1413	defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
		1414	PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
		1415	#endif
		1416
		1417
		1418	defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
		1419	PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
		1420	#endif
		1421
		1422
		1423	/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */
		1424	PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
		1425	int flags));
		1426	/* The values of the PNG_FILLER_ defines should NOT be changed */
		1427	# define PNG_FILLER_BEFORE 0
		1428	# define PNG_FILLER_AFTER 1
		1429	/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
		1430	PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
		1431	png_uint_32 filler, int flags));
		1432	#endif /* PNG_READ_FILLER_SUPPORTED \|\| PNG_WRITE_FILLER_SUPPORTED */
		1433
		1434
		1435	/* Swap bytes in 16-bit depth files. */
		1436	PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
		1437	#endif
		1438
		1439
		1440	/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
		1441	PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
		1442	#endif
		1443
		1444
		1445	defined(PNG_WRITE_PACKSWAP_SUPPORTED)
		1446	/* Swap packing order of pixels in bytes. */
		1447	PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
		1448	#endif
		1449
		1450
		1451	/* Converts files to legal bit depths. */
		1452	PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
		1453	true_bits));
		1454	#endif
		1455
		1456
		1457	defined(PNG_WRITE_INTERLACING_SUPPORTED)
		1458	/* Have the code handle the interlacing. Returns the number of passes.
		1459	* MUST be called before png_read_update_info or png_start_read_image,
		1460	* otherwise it will not have the desired effect. Note that it is still
		1461	* necessary to call png_read_row or png_read_rows png_get_image_height
		1462	* times for each pass.
		1463	*/
		1464	PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
		1465	#endif
		1466
		1467
		1468	/* Invert monochrome files */
		1469	PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
		1470	#endif
		1471
		1472
		1473	/* Handle alpha and tRNS by replacing with a background color. Prior to
		1474	* libpng-1.5.4 this API must not be called before the PNG file header has been
		1475	* read. Doing so will result in unexpected behavior and possible warnings or
		1476	* errors if the PNG file contains a bKGD chunk.
		1477	*/
		1478	PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
		1479	png_const_color_16p background_color, int background_gamma_code,
		1480	int need_expand, double background_gamma))
		1481	PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr,
		1482	png_const_color_16p background_color, int background_gamma_code,
		1483	int need_expand, png_fixed_point background_gamma))
		1484	#endif
		1485	#ifdef PNG_READ_BACKGROUND_SUPPORTED
		1486	# define PNG_BACKGROUND_GAMMA_UNKNOWN 0
		1487	# define PNG_BACKGROUND_GAMMA_SCREEN 1
		1488	# define PNG_BACKGROUND_GAMMA_FILE 2
		1489	# define PNG_BACKGROUND_GAMMA_UNIQUE 3
		1490	#endif
		1491
		1492
		1493	/* Scale a 16-bit depth file down to 8-bit, accurately. */
		1494	PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
		1495	#endif
		1496
		1497
		1498	#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */
		1499	/* Strip the second byte of information from a 16-bit depth file. */
		1500	PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
		1501	#endif
		1502
		1503
		1504	/* Turn on quantizing, and reduce the palette to the number of colors
		1505	* available.
		1506	*/
		1507	PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
		1508	png_colorp palette, int num_palette, int maximum_colors,
		1509	png_const_uint_16p histogram, int full_quantize));
		1510	#endif
		1511
		1512
		1513	/* The threshold on gamma processing is configurable but hard-wired into the
		1514	* library. The following is the floating point variant.
		1515	*/
		1516	#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
		1517
		1518
		1519	* NOTE: this API simply sets the screen and file gamma values. It will
		1520	* therefore override the value for gamma in a PNG file if it is called after
		1521	* the file header has been read - use with care - call before reading the PNG
		1522	* file for best results!
		1523	*
		1524	* These routines accept the same gamma values as png_set_alpha_mode (described
		1525	* above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
		1526	* API (floating point or fixed.) Notice, however, that the 'file_gamma' value
		1527	* is the inverse of a 'screen gamma' value.
		1528	*/
		1529	PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
		1530	double screen_gamma, double override_file_gamma))
		1531	PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr,
		1532	png_fixed_point screen_gamma, png_fixed_point override_file_gamma))
		1533	#endif
		1534
		1535
		1536	/* Set how many lines between output flushes - 0 for no flushing */
		1537	PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
		1538	/* Flush the current PNG output buffer */
		1539	PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
		1540	#endif
		1541
		1542
		1543	PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
		1544
		1545
		1546	PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
		1547	png_inforp info_ptr));
		1548
		1549
		1550	/* Read one or more rows of image data. */
		1551	PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
		1552	png_bytepp display_row, png_uint_32 num_rows));
		1553	#endif
		1554
		1555
		1556	/* Read a row of data. */
		1557	PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
		1558	png_bytep display_row));
		1559	#endif
		1560
		1561
		1562	/* Read the whole image into memory at once. */
		1563	PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
		1564	#endif
		1565
		1566
		1567	PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
		1568	png_const_bytep row));
		1569
		1570
		1571	* is declared as writeable to maintain compatibility with previous versions
		1572	* of libpng and to allow the 'display_row' array from read_rows to be passed
		1573	* unchanged to write_rows.
		1574	*/
		1575	PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
		1576	png_uint_32 num_rows));
		1577
		1578
		1579	PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
		1580
		1581
		1582	PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
		1583	png_inforp info_ptr));
		1584
		1585
		1586	/* Read the end of the PNG file. */
		1587	PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
		1588	#endif
		1589
		1590
		1591	PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
		1592	png_infopp info_ptr_ptr));
		1593
		1594
		1595	PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr,
		1596	png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
		1597
		1598
		1599	PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr,
		1600	png_infopp info_ptr_ptr));
		1601
		1602
		1603	PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
		1604	int ancil_action));
		1605
		1606
		1607	* ancillary and critical chunks, and whether to use the data contained
		1608	* therein. Note that it is impossible to "discard" data in a critical
		1609	* chunk. For versions prior to 0.90, the action was always error/quit,
		1610	* whereas in version 0.90 and later, the action for CRC errors in ancillary
		1611	* chunks is warn/discard. These values should NOT be changed.
		1612	*
		1613	* value action:critical action:ancillary
		1614	*/
		1615	#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */
		1616	#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */
		1617	#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */
		1618	#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */
		1619	#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */
		1620	#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */
		1621
		1622
		1623	* libpng and the compression methods used by zlib. These functions are
		1624	* mainly useful for testing, as the defaults should work with most users.
		1625	* Those users who are tight on memory or want faster performance at the
		1626	* expense of compression can modify them. See the compression library
		1627	* header file (zlib.h) for an explination of the compression functions.
		1628	*/
		1629
		1630
		1631	* value for "method" is 0.
		1632	*/
		1633	PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
		1634	int filters));
		1635
		1636
		1637	* are chosen so that they don't conflict with real filter types
		1638	* below, in case they are supplied instead of the #defined constants.
		1639	* These values should NOT be changed.
		1640	*/
		1641	#define PNG_NO_FILTERS 0x00
		1642	#define PNG_FILTER_NONE 0x08
		1643	#define PNG_FILTER_SUB 0x10
		1644	#define PNG_FILTER_UP 0x20
		1645	#define PNG_FILTER_AVG 0x40
		1646	#define PNG_FILTER_PAETH 0x80
		1647	#define PNG_ALL_FILTERS (PNG_FILTER_NONE \| PNG_FILTER_SUB \| PNG_FILTER_UP \| \
		1648	PNG_FILTER_AVG \| PNG_FILTER_PAETH)
		1649
		1650
		1651	* These defines should NOT be changed.
		1652	*/
		1653	#define PNG_FILTER_VALUE_NONE 0
		1654	#define PNG_FILTER_VALUE_SUB 1
		1655	#define PNG_FILTER_VALUE_UP 2
		1656	#define PNG_FILTER_VALUE_AVG 3
		1657	#define PNG_FILTER_VALUE_PAETH 4
		1658	#define PNG_FILTER_VALUE_LAST 5
		1659
		1660
		1661	/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_
		1662	* defines, either the default (minimum-sum-of-absolute-differences), or
		1663	* the experimental method (weighted-minimum-sum-of-absolute-differences).
		1664	*
		1665	* Weights are factors >= 1.0, indicating how important it is to keep the
		1666	* filter type consistent between rows. Larger numbers mean the current
		1667	* filter is that many times as likely to be the same as the "num_weights"
		1668	* previous filters. This is cumulative for each previous row with a weight.
		1669	* There needs to be "num_weights" values in "filter_weights", or it can be
		1670	* NULL if the weights aren't being specified. Weights have no influence on
		1671	* the selection of the first row filter. Well chosen weights can (in theory)
		1672	* improve the compression for a given image.
		1673	*
		1674	* Costs are factors >= 1.0 indicating the relative decoding costs of a
		1675	* filter type. Higher costs indicate more decoding expense, and are
		1676	* therefore less likely to be selected over a filter with lower computational
		1677	* costs. There needs to be a value in "filter_costs" for each valid filter
		1678	* type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't
		1679	* setting the costs. Costs try to improve the speed of decompression without
		1680	* unduly increasing the compressed image size.
		1681	*
		1682	* A negative weight or cost indicates the default value is to be used, and
		1683	* values in the range [0.0, 1.0) indicate the value is to remain unchanged.
		1684	* The default values for both weights and costs are currently 1.0, but may
		1685	* change if good general weighting/cost heuristics can be found. If both
		1686	* the weights and costs are set to 1.0, this degenerates the WEIGHTED method
		1687	* to the UNWEIGHTED method, but with added encoding time/computation.
		1688	*/
		1689	PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
		1690	int heuristic_method, int num_weights, png_const_doublep filter_weights,
		1691	png_const_doublep filter_costs))
		1692	PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
		1693	(png_structrp png_ptr, int heuristic_method, int num_weights,
		1694	png_const_fixed_point_p filter_weights,
		1695	png_const_fixed_point_p filter_costs))
		1696	#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
		1697
		1698
		1699	* changed.
		1700	*/
		1701	#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */
		1702	#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */
		1703	#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */
		1704	#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */
		1705
		1706
		1707	/* Set the library compression level. Currently, valid values range from
		1708	* 0 - 9, corresponding directly to the zlib compression levels 0 - 9
		1709	* (0 - no compression, 9 - "maximal" compression). Note that tests have
		1710	* shown that zlib compression levels 3-6 usually perform as well as level 9
		1711	* for PNG images, and do considerably fewer caclulations. In the future,
		1712	* these values may not correspond directly to the zlib compression levels.
		1713	*/
		1714	PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
		1715	int level));
		1716
		1717
		1718	int mem_level));
		1719
		1720
		1721	int strategy));
		1722
		1723
		1724	* smaller value of window_bits if it can do so safely.
		1725	*/
		1726	PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
		1727	int window_bits));
		1728
		1729
		1730	int method));
		1731	#endif
		1732
		1733
		1734	/* Also set zlib parameters for compressing non-IDAT chunks */
		1735	PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
		1736	int level));
		1737
		1738
		1739	int mem_level));
		1740
		1741
		1742	int strategy));
		1743
		1744
		1745	* smaller value of window_bits if it can do so safely.
		1746	*/
		1747	PNG_EXPORT(225, void, png_set_text_compression_window_bits,
		1748	(png_structrp png_ptr, int window_bits));
		1749
		1750
		1751	int method));
		1752	#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */
		1753
		1754
		1755	* handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
		1756	* and call standard C I/O routines such as fread(), fwrite(), and
		1757	* fprintf(). These functions can be made to use other I/O routines
		1758	* at run time for those applications that need to handle I/O in a
		1759	* different manner by calling png_set_???_fn(). See libpng-manual.txt for
		1760	* more information.
		1761	*/
		1762
		1763
		1764	/* Initialize the input/output for the PNG file to the default functions. */
		1765	PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
		1766	#endif
		1767
		1768
		1769	* supplied functions. If no messages are to be printed you must still
		1770	* write and use replacement functions. The replacement error_fn should
		1771	* still do a longjmp to the last setjmp location if you are using this
		1772	* method of error handling. If error_fn or warning_fn is NULL, the
		1773	* default function will be used.
		1774	*/
		1775
		1776
		1777	png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
		1778
		1779
		1780	PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
		1781
		1782
		1783	* If buffered output is not used, then output_flush_fn can be set to NULL.
		1784	* If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
		1785	* output_flush_fn will be ignored (and thus can be NULL).
		1786	* It is probably a mistake to use NULL for output_flush_fn if
		1787	* write_data_fn is not also NULL unless you have built libpng with
		1788	* PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
		1789	* default flush function, which uses the standard *FILE structure, will
		1790	* be used.
		1791	*/
		1792	PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
		1793	png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
		1794
		1795
		1796	PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
		1797	png_rw_ptr read_data_fn));
		1798
		1799
		1800	PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr));
		1801
		1802
		1803	png_read_status_ptr read_row_fn));
		1804
		1805
		1806	png_write_status_ptr write_row_fn));
		1807
		1808
		1809	/* Replace the default memory allocation functions with user supplied one(s). */
		1810	PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
		1811	png_malloc_ptr malloc_fn, png_free_ptr free_fn));
		1812	/* Return the user pointer associated with the memory functions */
		1813	PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
		1814	#endif
		1815
		1816
		1817	PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
		1818	png_user_transform_ptr read_user_transform_fn));
		1819	#endif
		1820
		1821
		1822	PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
		1823	png_user_transform_ptr write_user_transform_fn));
		1824	#endif
		1825
		1826
		1827	PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
		1828	png_voidp user_transform_ptr, int user_transform_depth,
		1829	int user_transform_channels));
		1830	/* Return the user pointer associated with the user transform functions */
		1831	PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
		1832	(png_const_structrp png_ptr));
		1833	#endif
		1834
		1835
		1836	/* Return information about the row currently being processed. Note that these
		1837	* APIs do not fail but will return unexpected results if called outside a user
		1838	* transform callback. Also note that when transforming an interlaced image the
		1839	* row number is the row number within the sub-image of the interlace pass, so
		1840	* the value will increase to the height of the sub-image (not the full image)
		1841	* then reset to 0 for the next pass.
		1842	*
		1843	* Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
		1844	* find the output pixel (x,y) given an interlaced sub-image pixel
		1845	* (row,col,pass). (See below for these macros.)
		1846	*/
		1847	PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
		1848	PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
		1849	#endif
		1850
		1851
		1852	/* This callback is called only for unknown chunks. If
		1853	* PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known
		1854	* chunks to be treated as unknown, however in this case the callback must do
		1855	* any processing required by the chunk (e.g. by calling the appropriate
		1856	* png_set_ APIs.)
		1857	*
		1858	* There is no write support - on write, by default, all the chunks in the
		1859	* 'unknown' list are written in the specified position.
		1860	*
		1861	* The integer return from the callback function is interpreted thus:
		1862	*
		1863	* negative: An error occured, png_chunk_error will be called.
		1864	* zero: The chunk was not handled, the chunk will be saved. A critical
		1865	* chunk will cause an error at this point unless it is to be saved.
		1866	* positive: The chunk was handled, libpng will ignore/discard it.
		1867	*
		1868	* See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
		1869	* how this behavior will change in libpng 1.7
		1870	*/
		1871	PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
		1872	png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
		1873	#endif
		1874
		1875
		1876	PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
		1877	#endif
		1878
		1879
		1880	/* Sets the function callbacks for the push reader, and a pointer to a
		1881	* user-defined structure available to the callback functions.
		1882	*/
		1883	PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
		1884	png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
		1885	png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
		1886
		1887
		1888	PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
		1889	(png_const_structrp png_ptr));
		1890
		1891
		1892	PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
		1893	png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
		1894
		1895
		1896	* processing of any more data. The function returns the number of bytes
		1897	* remaining, excluding any that libpng has cached internally. A subsequent
		1898	* call to png_process_data must supply these bytes again. If the argument
		1899	* 'save' is set to true the routine will first save all the pending data and
		1900	* will always return 0.
		1901	*/
		1902	PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
		1903
		1904
		1905	* png_process_data. It returns the number of bytes of data to skip in the
		1906	* input. Normally it will return 0, but if it returns a non-zero value the
		1907	* application must skip than number of bytes of input data and pass the
		1908	* following data to the next call to png_process_data.
		1909	*/
		1910	PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
		1911
		1912
		1913	/* Function that combines rows. 'new_row' is a flag that should come from
		1914	* the callback and be non-NULL if anything needs to be done; the library
		1915	* stores its own version of the new data internally and ignores the passed
		1916	* in value.
		1917	*/
		1918	PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
		1919	png_bytep old_row, png_const_bytep new_row));
		1920	#endif /* PNG_READ_INTERLACING_SUPPORTED */
		1921	#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
		1922
		1923
		1924	png_alloc_size_t size), PNG_ALLOCATED);
		1925	/* Added at libpng version 1.4.0 */
		1926	PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr,
		1927	png_alloc_size_t size), PNG_ALLOCATED);
		1928
		1929
		1930	PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
		1931	png_alloc_size_t size), PNG_ALLOCATED);
		1932
		1933
		1934	PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
		1935
		1936
		1937	PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
		1938	png_inforp info_ptr, png_uint_32 free_me, int num));
		1939
		1940
		1941	* by libpng or by the application; this works on the png_info structure passed
		1942	* in, it does not change the state for other png_info structures.
		1943	*
		1944	* It is unlikely that this function works correctly as of 1.6.0 and using it
		1945	* may result either in memory leaks or double free of allocated data.
		1946	*/
		1947	PNG_EXPORTA(99, void, png_data_freer, (png_const_structrp png_ptr,
		1948	png_inforp info_ptr, int freer, png_uint_32 mask), PNG_DEPRECATED);
		1949
		1950
		1951	#define PNG_DESTROY_WILL_FREE_DATA 1
		1952	#define PNG_SET_WILL_FREE_DATA 1
		1953	#define PNG_USER_WILL_FREE_DATA 2
		1954	/* Flags for png_ptr->free_me and info_ptr->free_me */
		1955	#define PNG_FREE_HIST 0x0008
		1956	#define PNG_FREE_ICCP 0x0010
		1957	#define PNG_FREE_SPLT 0x0020
		1958	#define PNG_FREE_ROWS 0x0040
		1959	#define PNG_FREE_PCAL 0x0080
		1960	#define PNG_FREE_SCAL 0x0100
		1961	#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
		1962	# define PNG_FREE_UNKN 0x0200
		1963	#endif
		1964	/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */
		1965	#define PNG_FREE_PLTE 0x1000
		1966	#define PNG_FREE_TRNS 0x2000
		1967	#define PNG_FREE_TEXT 0x4000
		1968	#define PNG_FREE_ALL 0x7fff
		1969	#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT\|PNG_FREE_TEXT\|PNG_FREE_UNKN */
		1970
		1971
		1972	PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
		1973	png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED);
		1974	PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
		1975	png_voidp ptr), PNG_DEPRECATED);
		1976	#endif
		1977
		1978
		1979	/* Fatal error in PNG image of libpng - can't continue */
		1980	PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
		1981	png_const_charp error_message), PNG_NORETURN);
		1982
		1983
		1984	PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
		1985	png_const_charp error_message), PNG_NORETURN);
		1986
		1987
		1988	/* Fatal error in PNG image of libpng - can't continue */
		1989	PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
		1990	#endif
		1991
		1992
		1993	/* Non-fatal error in libpng. Can continue, but may have a problem. */
		1994	PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
		1995	png_const_charp warning_message));
		1996
		1997
		1998	PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
		1999	png_const_charp warning_message));
		2000	#endif
		2001
		2002
		2003	/* Benign error in libpng. Can continue, but may have a problem.
		2004	* User can choose whether to handle as a fatal error or as a warning. */
		2005	PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
		2006	png_const_charp warning_message));
		2007
		2008
		2009	/* Same, chunk name is prepended to message (only during read) */
		2010	PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
		2011	png_const_charp warning_message));
		2012	#endif
		2013
		2014
		2015	(png_structrp png_ptr, int allowed));
		2016	#else
		2017	# ifdef PNG_ALLOW_BENIGN_ERRORS
		2018	# define png_benign_error png_warning
		2019	# define png_chunk_benign_error png_chunk_warning
		2020	# else
		2021	# define png_benign_error png_error
		2022	# define png_chunk_benign_error png_chunk_error
		2023	# endif
		2024	#endif
		2025
		2026
		2027	* Similarly, the png_get_ calls are used to read values from the
		2028	* png_info_struct, either storing the parameters in the passed variables, or
		2029	* setting pointers into the png_info_struct where the data is stored. The
		2030	* png_get_ functions return a non-zero value if the data was available
		2031	* in info_ptr, or return zero and do not change any of the parameters if the
		2032	* data was not available.
		2033	*
		2034	* These functions should be used instead of directly accessing png_info
		2035	* to avoid problems with future changes in the size and internal layout of
		2036	* png_info_struct.
		2037	*/
		2038	/* Returns "flag" if chunk data is valid in info_ptr. */
		2039	PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
		2040	png_const_inforp info_ptr, png_uint_32 flag));
		2041
		2042
		2043	PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
		2044	png_const_inforp info_ptr));
		2045
		2046
		2047	/* Returns row_pointers, which is an array of pointers to scanlines that was
		2048	* returned from png_read_png().
		2049	*/
		2050	PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
		2051	png_const_inforp info_ptr));
		2052
		2053
		2054	* by png_write_png().
		2055	*/
		2056	PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
		2057	png_inforp info_ptr, png_bytepp row_pointers));
		2058	#endif
		2059
		2060
		2061	PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
		2062	png_const_inforp info_ptr));
		2063
		2064
		2065	/* Returns image width in pixels. */
		2066	PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
		2067	png_const_inforp info_ptr));
		2068
		2069
		2070	PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
		2071	png_const_inforp info_ptr));
		2072
		2073
		2074	PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
		2075	png_const_inforp info_ptr));
		2076
		2077
		2078	PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
		2079	png_const_inforp info_ptr));
		2080
		2081
		2082	PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
		2083	png_const_inforp info_ptr));
		2084
		2085
		2086	PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
		2087	png_const_inforp info_ptr));
		2088
		2089
		2090	PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
		2091	png_const_inforp info_ptr));
		2092
		2093
		2094	PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
		2095	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2096	PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
		2097	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2098	PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
		2099	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2100
		2101
		2102	PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
		2103	(png_const_structrp png_ptr, png_const_inforp info_ptr))
		2104	PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed,
		2105	(png_const_structrp png_ptr, png_const_inforp info_ptr))
		2106
		2107
		2108	PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
		2109	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2110	PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
		2111	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2112	PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
		2113	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2114	PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
		2115	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2116
		2117
		2118
		2119
		2120	/* Returns pointer to signature string read from PNG header */
		2121	PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
		2122	png_const_inforp info_ptr));
		2123	#endif
		2124
		2125
		2126	PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
		2127	png_inforp info_ptr, png_color_16p *background));
		2128	#endif
		2129
		2130
		2131	PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
		2132	png_inforp info_ptr, png_const_color_16p background));
		2133	#endif
		2134
		2135
		2136	PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr,
		2137	png_const_inforp info_ptr, double white_x, double white_y, double *red_x,
		2138	double red_y, double green_x, double green_y, double blue_x,
		2139	double *blue_y))
		2140	PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr,
		2141	png_const_inforp info_ptr, double red_X, double red_Y, double *red_Z,
		2142	double green_X, double green_Y, double green_Z, double blue_X,
		2143	double blue_Y, double blue_Z))
		2144	PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
		2145	(png_const_structrp png_ptr, png_const_inforp info_ptr,
		2146	png_fixed_point int_white_x, png_fixed_point int_white_y,
		2147	png_fixed_point int_red_x, png_fixed_point int_red_y,
		2148	png_fixed_point int_green_x, png_fixed_point int_green_y,
		2149	png_fixed_point int_blue_x, png_fixed_point int_blue_y))
		2150	PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed,
		2151	(png_const_structrp png_ptr, png_const_inforp info_ptr,
		2152	png_fixed_point int_red_X, png_fixed_point int_red_Y,
		2153	png_fixed_point int_red_Z, png_fixed_point int_green_X,
		2154	png_fixed_point int_green_Y, png_fixed_point int_green_Z,
		2155	png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
		2156	png_fixed_point *int_blue_Z))
		2157	#endif
		2158
		2159
		2160	PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
		2161	png_inforp info_ptr,
		2162	double white_x, double white_y, double red_x, double red_y, double green_x,
		2163	double green_y, double blue_x, double blue_y))
		2164	PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr,
		2165	png_inforp info_ptr, double red_X, double red_Y, double red_Z,
		2166	double green_X, double green_Y, double green_Z, double blue_X,
		2167	double blue_Y, double blue_Z))
		2168	PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
		2169	png_inforp info_ptr, png_fixed_point int_white_x,
		2170	png_fixed_point int_white_y, png_fixed_point int_red_x,
		2171	png_fixed_point int_red_y, png_fixed_point int_green_x,
		2172	png_fixed_point int_green_y, png_fixed_point int_blue_x,
		2173	png_fixed_point int_blue_y))
		2174	PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
		2175	png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y,
		2176	png_fixed_point int_red_Z, png_fixed_point int_green_X,
		2177	png_fixed_point int_green_Y, png_fixed_point int_green_Z,
		2178	png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
		2179	png_fixed_point int_blue_Z))
		2180	#endif
		2181
		2182
		2183	PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr,
		2184	png_const_inforp info_ptr, double *file_gamma))
		2185	PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed,
		2186	(png_const_structrp png_ptr, png_const_inforp info_ptr,
		2187	png_fixed_point *int_file_gamma))
		2188	#endif
		2189
		2190
		2191	PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
		2192	png_inforp info_ptr, double file_gamma))
		2193	PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,
		2194	png_inforp info_ptr, png_fixed_point int_file_gamma))
		2195	#endif
		2196
		2197
		2198	PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
		2199	png_inforp info_ptr, png_uint_16p *hist));
		2200	#endif
		2201
		2202
		2203	PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
		2204	png_inforp info_ptr, png_const_uint_16p hist));
		2205	#endif
		2206
		2207
		2208	png_const_inforp info_ptr, png_uint_32 width, png_uint_32 height,
		2209	int bit_depth, int color_type, int *interlace_method,
		2210	int compression_method, int filter_method));
		2211
		2212
		2213	png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
		2214	int color_type, int interlace_method, int compression_method,
		2215	int filter_method));
		2216
		2217
		2218	PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
		2219	png_const_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
		2220	int *unit_type));
		2221	#endif
		2222
		2223
		2224	PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
		2225	png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
		2226	int unit_type));
		2227	#endif
		2228
		2229
		2230	PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
		2231	png_inforp info_ptr, png_charp purpose, png_int_32 X0,
		2232	png_int_32 X1, int type, int nparams, png_charp units,
		2233	png_charpp *params));
		2234	#endif
		2235
		2236
		2237	PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
		2238	png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1,
		2239	int type, int nparams, png_const_charp units, png_charpp params));
		2240	#endif
		2241
		2242
		2243	PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
		2244	png_const_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y,
		2245	int *unit_type));
		2246	#endif
		2247
		2248
		2249	PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
		2250	png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
		2251	#endif
		2252
		2253
		2254	png_inforp info_ptr, png_colorp palette, int num_palette));
		2255
		2256
		2257	png_inforp info_ptr, png_const_colorp palette, int num_palette));
		2258
		2259
		2260	PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
		2261	png_inforp info_ptr, png_color_8p *sig_bit));
		2262	#endif
		2263
		2264
		2265	PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
		2266	png_inforp info_ptr, png_const_color_8p sig_bit));
		2267	#endif
		2268
		2269
		2270	PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
		2271	png_const_inforp info_ptr, int *file_srgb_intent));
		2272	#endif
		2273
		2274
		2275	PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
		2276	png_inforp info_ptr, int srgb_intent));
		2277	PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
		2278	png_inforp info_ptr, int srgb_intent));
		2279	#endif
		2280
		2281
		2282	PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
		2283	png_inforp info_ptr, png_charpp name, int *compression_type,
		2284	png_bytepp profile, png_uint_32 *proflen));
		2285	#endif
		2286
		2287
		2288	PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
		2289	png_inforp info_ptr, png_const_charp name, int compression_type,
		2290	png_const_bytep profile, png_uint_32 proflen));
		2291	#endif
		2292
		2293
		2294	PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
		2295	png_inforp info_ptr, png_sPLT_tpp entries));
		2296	#endif
		2297
		2298
		2299	PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
		2300	png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
		2301	#endif
		2302
		2303
		2304	/* png_get_text also returns the number of text chunks in num_text /
		2305	PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
		2306	png_inforp info_ptr, png_textp text_ptr, int num_text));
		2307	#endif
		2308
		2309
		2310	* language, and translated keywords are NULL pointers, the structure
		2311	* returned by png_get_text will always contain regular
		2312	* zero-terminated C strings. They might be empty strings but
		2313	* they will never be NULL pointers.
		2314	*/
		2315
		2316
		2317	PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
		2318	png_inforp info_ptr, png_const_textp text_ptr, int num_text));
		2319	#endif
		2320
		2321
		2322	PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
		2323	png_inforp info_ptr, png_timep *mod_time));
		2324	#endif
		2325
		2326
		2327	PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
		2328	png_inforp info_ptr, png_const_timep mod_time));
		2329	#endif
		2330
		2331
		2332	PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
		2333	png_inforp info_ptr, png_bytep trans_alpha, int num_trans,
		2334	png_color_16p *trans_color));
		2335	#endif
		2336
		2337
		2338	PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
		2339	png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans,
		2340	png_const_color_16p trans_color));
		2341	#endif
		2342
		2343
		2344	PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
		2345	png_const_inforp info_ptr, int unit, double width, double *height))
		2346	#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) \|\| \
		2347	defined(PNG_FLOATING_POINT_SUPPORTED)
		2348	/* NOTE: this API is currently implemented using floating point arithmetic,
		2349	* consequently it can only be used on systems with floating point support.
		2350	* In any case the range of values supported by png_fixed_point is small and it
		2351	* is highly recommended that png_get_sCAL_s be used instead.
		2352	*/
		2353	PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
		2354	(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
		2355	png_fixed_point width, png_fixed_point height))
		2356	#endif
		2357	PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
		2358	(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
		2359	png_charpp swidth, png_charpp sheight));
		2360
		2361
		2362	png_inforp info_ptr, int unit, double width, double height))
		2363	PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
		2364	png_inforp info_ptr, int unit, png_fixed_point width,
		2365	png_fixed_point height))
		2366	PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
		2367	png_inforp info_ptr, int unit,
		2368	png_const_charp swidth, png_const_charp sheight));
		2369	#endif /* PNG_sCAL_SUPPORTED */
		2370
		2371
		2372	/* Provide the default handling for all unknown chunks or, optionally, for
		2373	* specific unknown chunks.
		2374	*
		2375	* NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
		2376	* ignored and the default was used, the per-chunk setting only had an effect on
		2377	* write. If you wish to have chunk-specific handling on read in code that must
		2378	* work on earlier versions you must use a user chunk callback to specify the
		2379	* desired handling (keep or discard.)
		2380	*
		2381	* The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The
		2382	* parameter is interpreted as follows:
		2383	*
		2384	* READ:
		2385	* PNG_HANDLE_CHUNK_AS_DEFAULT:
		2386	* Known chunks: do normal libpng processing, do not keep the chunk (but
		2387	* see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
		2388	* Unknown chunks: for a specific chunk use the global default, when used
		2389	* as the default discard the chunk data.
		2390	* PNG_HANDLE_CHUNK_NEVER:
		2391	* Discard the chunk data.
		2392	* PNG_HANDLE_CHUNK_IF_SAFE:
		2393	* Keep the chunk data if the chunk is not critical else raise a chunk
		2394	* error.
		2395	* PNG_HANDLE_CHUNK_ALWAYS:
		2396	* Keep the chunk data.
		2397	*
		2398	* If the chunk data is saved it can be retrieved using png_get_unknown_chunks,
		2399	* below. Notice that specifying "AS_DEFAULT" as a global default is equivalent
		2400	* to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
		2401	* it simply resets the behavior to the libpng default.
		2402	*
		2403	* INTERACTION WTIH USER CHUNK CALLBACKS:
		2404	* The per-chunk handling is always used when there is a png_user_chunk_ptr
		2405	* callback and the callback returns 0; the chunk is then always stored unless
		2406	* it is critical and the per-chunk setting is other than ALWAYS. Notice that
		2407	* the global default is not used in this case. (In effect the per-chunk
		2408	* value is incremented to at least IF_SAFE.)
		2409	*
		2410	* IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
		2411	* per-chunk defaults will be honored. If you want to preserve the current
		2412	* behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
		2413	* as the default - if you don't do this libpng 1.6 will issue a warning.
		2414	*
		2415	* If you want unhandled unknown chunks to be discarded in libpng 1.6 and
		2416	* earlier simply return '1' (handled).
		2417	*
		2418	* PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
		2419	* If this is not set known chunks will always be handled by libpng and
		2420	* will never be stored in the unknown chunk list. Known chunks listed to
		2421	* png_set_keep_unknown_chunks will have no effect. If it is set then known
		2422	* chunks listed with a keep other than AS_DEFAULT will never be processed
		2423	* by libpng, in addition critical chunks must either be processed by the
		2424	* callback or saved.
		2425	*
		2426	* The IHDR and IEND chunks must not be listed. Because this turns off the
		2427	* default handling for chunks that would otherwise be recognized the
		2428	* behavior of libpng transformations may well become incorrect!
		2429	*
		2430	* WRITE:
		2431	* When writing chunks the options only apply to the chunks specified by
		2432	* png_set_unknown_chunks (below), libpng will always write known chunks
		2433	* required by png_set_ calls and will always write the core critical chunks
		2434	* (as required for PLTE).
		2435	*
		2436	* Each chunk in the png_set_unknown_chunks list is looked up in the
		2437	* png_set_keep_unknown_chunks list to find the keep setting, this is then
		2438	* interpreted as follows:
		2439	*
		2440	* PNG_HANDLE_CHUNK_AS_DEFAULT:
		2441	* Write safe-to-copy chunks and write other chunks if the global
		2442	* default is set to _ALWAYS, otherwise don't write this chunk.
		2443	* PNG_HANDLE_CHUNK_NEVER:
		2444	* Do not write the chunk.
		2445	* PNG_HANDLE_CHUNK_IF_SAFE:
		2446	* Write the chunk if it is safe-to-copy, otherwise do not write it.
		2447	* PNG_HANDLE_CHUNK_ALWAYS:
		2448	* Write the chunk.
		2449	*
		2450	* Note that the default behavior is effectively the opposite of the read case -
		2451	* in read unknown chunks are not stored by default, in write they are written
		2452	* by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different
		2453	* - on write the safe-to-copy bit is checked, on read the critical bit is
		2454	* checked and on read if the chunk is critical an error will be raised.
		2455	*
		2456	* num_chunks:
		2457	* ===========
		2458	* If num_chunks is positive, then the "keep" parameter specifies the manner
		2459	* for handling only those chunks appearing in the chunk_list array,
		2460	* otherwise the chunk list array is ignored.
		2461	*
		2462	* If num_chunks is 0 the "keep" parameter specifies the default behavior for
		2463	* unknown chunks, as described above.
		2464	*
		2465	* If num_chunks is negative, then the "keep" parameter specifies the manner
		2466	* for handling all unknown chunks plus all chunks recognized by libpng
		2467	* except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
		2468	* be processed by libpng.
		2469	*/
		2470	PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
		2471	int keep, png_const_bytep chunk_list, int num_chunks));
		2472
		2473
		2474	* the result is therefore true (non-zero) if special handling is required,
		2475	* false for the default handling.
		2476	*/
		2477	PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
		2478	png_const_bytep chunk_name));
		2479	#endif
		2480
		2481
		2482	PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
		2483	png_inforp info_ptr, png_const_unknown_chunkp unknowns,
		2484	int num_unknowns));
		2485	/* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
		2486	* unknowns to the location currently stored in the png_struct. This is
		2487	* invariably the wrong value on write. To fix this call the following API
		2488	* for each chunk in the list with the correct location. If you know your
		2489	* code won't be compiled on earlier versions you can rely on
		2490	* png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing
		2491	* the correct thing.
		2492	*/
		2493
		2494
		2495	(png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location));
		2496
		2497
		2498	png_inforp info_ptr, png_unknown_chunkpp entries));
		2499	#endif
		2500
		2501
		2502	* If you need to turn it off for a chunk that your application has freed,
		2503	* you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
		2504	*/
		2505	PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
		2506	png_inforp info_ptr, int mask));
		2507
		2508
		2509	/* The "params" pointer is currently not used and is for future expansion. */
		2510	PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
		2511	int transforms, png_voidp params));
		2512	PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
		2513	int transforms, png_voidp params));
		2514	#endif
		2515
		2516
		2517	(png_const_structrp png_ptr));
		2518	PNG_EXPORT(181, png_const_charp, png_get_header_ver,
		2519	(png_const_structrp png_ptr));
		2520	PNG_EXPORT(182, png_const_charp, png_get_header_version,
		2521	(png_const_structrp png_ptr));
		2522	PNG_EXPORT(183, png_const_charp, png_get_libpng_ver,
		2523	(png_const_structrp png_ptr));
		2524
		2525
		2526	PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
		2527	png_uint_32 mng_features_permitted));
		2528	#endif
		2529
		2530
		2531	#define PNG_HANDLE_CHUNK_AS_DEFAULT 0
		2532	#define PNG_HANDLE_CHUNK_NEVER 1
		2533	#define PNG_HANDLE_CHUNK_IF_SAFE 2
		2534	#define PNG_HANDLE_CHUNK_ALWAYS 3
		2535	#define PNG_HANDLE_CHUNK_LAST 4
		2536
		2537
		2538	* messages before passing them to the error or warning handler.
		2539	*/
		2540	#ifdef PNG_ERROR_NUMBERS_SUPPORTED
		2541	PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
		2542	png_uint_32 strip_mode));
		2543	#endif
		2544
		2545
		2546	#ifdef PNG_SET_USER_LIMITS_SUPPORTED
		2547	PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
		2548	png_uint_32 user_width_max, png_uint_32 user_height_max));
		2549	PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
		2550	(png_const_structrp png_ptr));
		2551	PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
		2552	(png_const_structrp png_ptr));
		2553	/* Added in libpng-1.4.0 */
		2554	PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
		2555	png_uint_32 user_chunk_cache_max));
		2556	PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
		2557	(png_const_structrp png_ptr));
		2558	/* Added in libpng-1.4.1 */
		2559	PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
		2560	png_alloc_size_t user_chunk_cache_max));
		2561	PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
		2562	(png_const_structrp png_ptr));
		2563	#endif
		2564
		2565
		2566	PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
		2567	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2568
		2569
		2570	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2571
		2572
		2573	(png_const_structrp png_ptr, png_const_inforp info_ptr));
		2574
		2575
		2576	(png_const_structrp png_ptr, png_const_inforp info_ptr))
		2577	#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
		2578	PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed,
		2579	(png_const_structrp png_ptr, png_const_inforp info_ptr))
		2580	#endif
		2581
		2582
		2583	png_const_inforp info_ptr))
		2584	#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
		2585	PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
		2586	(png_const_structrp png_ptr, png_const_inforp info_ptr))
		2587	#endif
		2588
		2589
		2590	PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
		2591	png_const_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y,
		2592	int *unit_type));
		2593	# endif /* PNG_pHYs_SUPPORTED */
		2594	#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */
		2595
		2596
		2597	#ifdef PNG_IO_STATE_SUPPORTED
		2598	PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
		2599
		2600
		2601	PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
		2602	PNG_DEPRECATED)
		2603
		2604
		2605	(png_const_structrp png_ptr));
		2606
		2607
		2608	# define PNG_IO_NONE 0x0000 /* no I/O at this moment */
		2609	# define PNG_IO_READING 0x0001 /* currently reading */
		2610	# define PNG_IO_WRITING 0x0002 /* currently writing */
		2611	# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */
		2612	# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */
		2613	# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */
		2614	# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */
		2615	# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */
		2616	# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */
		2617	#endif /* ?PNG_IO_STATE_SUPPORTED */
		2618
		2619
		2620	* libpng interlace handling is turned off the macros may be used to handle
		2621	* interlaced images within the application.
		2622	*/
		2623	#define PNG_INTERLACE_ADAM7_PASSES 7
		2624
		2625
		2626	* full, image which appears in a given pass. 'pass' is in the range 0
		2627	* to 6 and the result is in the range 0 to 7.
		2628	*/
		2629	#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
		2630	#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
		2631
		2632
		2633	* pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
		2634	* follows. Note that ROW_OFFSET is the offset from one row to the next whereas
		2635	* COL_OFFSET is from one column to the next, within a row.
		2636	*/
		2637	#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
		2638	#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
		2639
		2640
		2641	* pass. This is expressed as a shift - effectively log2 of the number or
		2642	* rows or columns in each 8x8 tile of the original image.
		2643	*/
		2644	#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
		2645	#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
		2646
		2647
		2648	* pass of an image given its height or width. In fact these macros may
		2649	* return non-zero even though the sub-image is empty, because the other
		2650	* dimension may be empty for a small image.
		2651	*/
		2652	#define PNG_PASS_ROWS(height, pass) (((height)+(((1<
		2653	-1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
		2654	#define PNG_PASS_COLS(width, pass) (((width)+(((1<
		2655	-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
		2656
		2657
		2658	* necessary to find the row in the output image given a row in an interlaced
		2659	* image, so two more macros:
		2660	*/
		2661	#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
		2662	(((y_in)<
		2663	#define PNG_COL_FROM_PASS_COL(x_in, pass) \
		2664	(((x_in)<
		2665
		2666
		2667	* or column is in a particular pass. These use a common utility macro that
		2668	* returns a mask for a given pass - the offset 'off' selects the row or
		2669	* column version. The mask has the appropriate bit set for each column in
		2670	* the tile.
		2671	*/
		2672	#define PNG_PASS_MASK(pass,off) ( \
		2673	((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) \| \
		2674	((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
		2675
		2676
		2677	((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
		2678	#define PNG_COL_IN_INTERLACE_PASS(x, pass) \
		2679	((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
		2680
		2681
		2682	/* With these routines we avoid an integer divide, which will be slower on
		2683	* most machines. However, it does take more operations than the corresponding
		2684	* divide method, so it may be slower on a few RISC systems. There are two
		2685	* shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
		2686	*
		2687	* Note that the rounding factors are NOT supposed to be the same! 128 and
		2688	* 32768 are correct for the NODIV code; 127 and 32767 are correct for the
		2689	* standard method.
		2690	*
		2691	* [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
		2692	*/
		2693
		2694
		2695
		2696
		2697	{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
		2698	* (png_uint_16)(alpha) \
		2699	+ (png_uint_16)(bg)*(png_uint_16)(255 \
		2700	- (png_uint_16)(alpha)) + 128); \
		2701	(composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
		2702
		2703
		2704	{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
		2705	* (png_uint_32)(alpha) \
		2706	+ (png_uint_32)(bg)*(65535 \
		2707	- (png_uint_32)(alpha)) + 32768); \
		2708	(composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
		2709
		2710
		2711
		2712
		2713	(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
		2714	(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
		2715	127) / 255)
		2716
		2717
		2718	(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
		2719	(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
		2720	32767) / 65535)
		2721	#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
		2722
		2723
		2724	PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
		2725	PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
		2726	PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
		2727	#endif
		2728
		2729
		2730	png_const_bytep buf));
		2731	/* No png_get_int_16 -- may be added if there's a real need for it. */
		2732
		2733
		2734	#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
		2735	PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
		2736	#endif
		2737	#ifdef PNG_SAVE_INT_32_SUPPORTED
		2738	PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i));
		2739	#endif
		2740
		2741
		2742	* The parameter is declared unsigned int, not png_uint_16,
		2743	* just to avoid potential problems on pre-ANSI C compilers.
		2744	*/
		2745	#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
		2746	PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
		2747	/* No png_save_int_16 -- may be added if there's a real need for it. */
		2748	#endif
		2749
		2750
		2751	/* Inline macros to do direct reads of bytes from the input buffer.
		2752	* The png_get_int_32() routine assumes we are using two's complement
		2753	* format for negative values, which is almost certainly true.
		2754	*/
		2755	# define PNG_get_uint_32(buf) \
		2756	(((png_uint_32)(*(buf)) << 24) + \
		2757	((png_uint_32)(*((buf) + 1)) << 16) + \
		2758	((png_uint_32)(*((buf) + 2)) << 8) + \
		2759	((png_uint_32)(*((buf) + 3))))
		2760
		2761
		2762	* function) incorrectly returned a value of type png_uint_32.
		2763	*/
		2764	# define PNG_get_uint_16(buf) \
		2765	((png_uint_16) \
		2766	(((unsigned int)(*(buf)) << 8) + \
		2767	((unsigned int)(*((buf) + 1)))))
		2768
		2769
		2770	((png_int_32)((*(buf) & 0x80) \
		2771	? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \
		2772	: (png_int_32)png_get_uint_32(buf)))
		2773
		2774
		2775	* but defining a macro name prefixed with PNG_PREFIX.
		2776	*/
		2777	# ifndef PNG_PREFIX
		2778	# define png_get_uint_32(buf) PNG_get_uint_32(buf)
		2779	# define png_get_uint_16(buf) PNG_get_uint_16(buf)
		2780	# define png_get_int_32(buf) PNG_get_int_32(buf)
		2781	# endif
		2782	#else
		2783	# ifdef PNG_PREFIX
		2784	/* No macros; revert to the (redefined) function */
		2785	# define PNG_get_uint_32 (png_get_uint_32)
		2786	# define PNG_get_uint_16 (png_get_uint_16)
		2787	# define PNG_get_int_32 (png_get_int_32)
		2788	# endif
		2789	#endif
		2790
		2791
		2792	* SIMPLIFIED API
		2793	*******************************************************************************
		2794	*
		2795	* Please read the documentation in libpng-manual.txt (TODO: write said
		2796	* documentation) if you don't understand what follows.
		2797	*
		2798	* The simplified API hides the details of both libpng and the PNG file format
		2799	* itself. It allows PNG files to be read into a very limited number of
		2800	* in-memory bitmap formats or to be written from the same formats. If these
		2801	* formats do not accomodate your needs then you can, and should, use the more
		2802	* sophisticated APIs above - these support a wide variety of in-memory formats
		2803	* and a wide variety of sophisticated transformations to those formats as well
		2804	* as a wide variety of APIs to manipulate ancillary information.
		2805	*
		2806	* To read a PNG file using the simplified API:
		2807	*
		2808	* 1) Declare a 'png_image' structure (see below) on the stack and set the
		2809	* version field to PNG_IMAGE_VERSION.
		2810	* 2) Call the appropriate png_image_begin_read... function.
		2811	* 3) Set the png_image 'format' member to the required sample format.
		2812	* 4) Allocate a buffer for the image and, if required, the color-map.
		2813	* 5) Call png_image_finish_read to read the image and, if required, the
		2814	* color-map into your buffers.
		2815	*
		2816	* There are no restrictions on the format of the PNG input itself; all valid
		2817	* color types, bit depths, and interlace methods are acceptable, and the
		2818	* input image is transformed as necessary to the requested in-memory format
		2819	* during the png_image_finish_read() step. The only caveat is that if you
		2820	* request a color-mapped image from a PNG that is full-color or makes
		2821	* complex use of an alpha channel the transformation is extremely lossy and the
		2822	* result may look terrible.
		2823	*
		2824	* To write a PNG file using the simplified API:
		2825	*
		2826	* 1) Declare a 'png_image' structure on the stack and memset() it to all zero.
		2827	* 2) Initialize the members of the structure that describe the image, setting
		2828	* the 'format' member to the format of the image samples.
		2829	* 3) Call the appropriate png_image_write... function with a pointer to the
		2830	* image and, if necessary, the color-map to write the PNG data.
		2831	*
		2832	* png_image is a structure that describes the in-memory format of an image
		2833	* when it is being read or defines the in-memory format of an image that you
		2834	* need to write:
		2835	*/
		2836	#define PNG_IMAGE_VERSION 1
		2837
		2838
		2839	typedef struct
		2840	{
		2841	png_controlp opaque; /* Initialize to NULL, free with png_image_free */
		2842	png_uint_32 version; /* Set to PNG_IMAGE_VERSION */
		2843	png_uint_32 width; /* Image width in pixels (columns) */
		2844	png_uint_32 height; /* Image height in pixels (rows) */
		2845	png_uint_32 format; /* Image format as defined below */
		2846	png_uint_32 flags; /* A bit mask containing informational flags */
		2847	png_uint_32 colormap_entries;
		2848	/* Number of entries in the color-map */
		2849
		2850
		2851	* non-zero value and the 'message' field will contain a '\0' terminated
		2852	* string with the libpng error or warning message. If both warnings and
		2853	* an error were encountered, only the error is recorded. If there
		2854	* are multiple warnings, only the first one is recorded.
		2855	*
		2856	* The upper 30 bits of this value are reserved, the low two bits contain
		2857	* a value as follows:
		2858	*/
		2859	# define PNG_IMAGE_WARNING 1
		2860	# define PNG_IMAGE_ERROR 2
		2861	/*
		2862	* The result is a two bit code such that a value more than 1 indicates
		2863	* a failure in the API just called:
		2864	*
		2865	* 0 - no warning or error
		2866	* 1 - warning
		2867	* 2 - error
		2868	* 3 - error preceded by warning
		2869	*/
		2870	# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
		2871
		2872
		2873
		2874
		2875	} png_image, *png_imagep;
		2876
		2877
		2878	* original values in the range 0 to 1.0:
		2879	*
		2880	* 1: A single gray or luminance channel (G).
		2881	* 2: A gray/luminance channel and an alpha channel (GA).
		2882	* 3: Three red, green, blue color channels (RGB).
		2883	* 4: Three color channels and an alpha channel (RGBA).
		2884	*
		2885	* The components are encoded in one of two ways:
		2886	*
		2887	* a) As a small integer, value 0..255, contained in a single byte. For the
		2888	* alpha channel the original value is simply value/255. For the color or
		2889	* luminance channels the value is encoded according to the sRGB specification
		2890	* and matches the 8-bit format expected by typical display devices.
		2891	*
		2892	* The color/gray channels are not scaled (pre-multiplied) by the alpha
		2893	* channel and are suitable for passing to color management software.
		2894	*
		2895	* b) As a value in the range 0..65535, contained in a 2-byte integer. All
		2896	* channels can be converted to the original value by dividing by 65535; all
		2897	* channels are linear. Color channels use the RGB encoding (RGB end-points) of
		2898	* the sRGB specification. This encoding is identified by the
		2899	* PNG_FORMAT_FLAG_LINEAR flag below.
		2900	*
		2901	* When the simplified API needs to convert between sRGB and linear colorspaces,
		2902	* the actual sRGB transfer curve defined in the sRGB specification (see the
		2903	* article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2
		2904	* approximation used elsewhere in libpng.
		2905	*
		2906	* When an alpha channel is present it is expected to denote pixel coverage
		2907	* of the color or luminance channels and is returned as an associated alpha
		2908	* channel: the color/gray channels are scaled (pre-multiplied) by the alpha
		2909	* value.
		2910	*
		2911	* The samples are either contained directly in the image data, between 1 and 8
		2912	* bytes per pixel according to the encoding, or are held in a color-map indexed
		2913	* by bytes in the image data. In the case of a color-map the color-map entries
		2914	* are individual samples, encoded as above, and the image data has one byte per
		2915	* pixel to select the relevant sample from the color-map.
		2916	*/
		2917
		2918
		2919	*
		2920	* #defines to be used in png_image::format. Each #define identifies a
		2921	* particular layout of sample data and, if present, alpha values. There are
		2922	* separate defines for each of the two component encodings.
		2923	*
		2924	* A format is built up using single bit flag values. All combinations are
		2925	* valid. Formats can be built up from the flag values or you can use one of
		2926	* the predefined values below. When testing formats always use the FORMAT_FLAG
		2927	* macros to test for individual features - future versions of the library may
		2928	* add new flags.
		2929	*
		2930	* When reading or writing color-mapped images the format should be set to the
		2931	* format of the entries in the color-map then png_image_{read,write}_colormap
		2932	* called to read or write the color-map and set the format correctly for the
		2933	* image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly!
		2934	*
		2935	* NOTE: libpng can be built with particular features disabled, if you see
		2936	* compiler errors because the definition of one of the following flags has been
		2937	* compiled out it is because libpng does not have the required support. It is
		2938	* possible, however, for the libpng configuration to enable the format on just
		2939	* read or just write; in that case you may see an error at run time. You can
		2940	* guard against this by checking for the definition of the appropriate
		2941	* "_SUPPORTED" macro, one of:
		2942	*
		2943	* PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
		2944	*/
		2945	#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */
		2946	#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */
		2947	#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */
		2948	#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */
		2949
		2950
		2951	# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */
		2952	#endif
		2953
		2954
		2955	# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */
		2956	#endif
		2957
		2958
		2959	*
		2960	* First the single byte (sRGB) formats:
		2961	*/
		2962	#define PNG_FORMAT_GRAY 0
		2963	#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA
		2964	#define PNG_FORMAT_AG (PNG_FORMAT_GA\|PNG_FORMAT_FLAG_AFIRST)
		2965	#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR
		2966	#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_BGR)
		2967	#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB\|PNG_FORMAT_FLAG_ALPHA)
		2968	#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA\|PNG_FORMAT_FLAG_AFIRST)
		2969	#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR\|PNG_FORMAT_FLAG_ALPHA)
		2970	#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA\|PNG_FORMAT_FLAG_AFIRST)
		2971
		2972
		2973	* indicate a luminance (gray) channel.
		2974	*/
		2975	#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR
		2976	#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_ALPHA)
		2977	#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_COLOR)
		2978	#define PNG_FORMAT_LINEAR_RGB_ALPHA \
		2979	(PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_ALPHA)
		2980
		2981
		2982	* is an index into the color-map which is formatted as above. To obtain a
		2983	* color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP
		2984	* to one of the above definitions, or you can use one of the definitions below.
		2985	*/
		2986	#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB\|PNG_FORMAT_FLAG_COLORMAP)
		2987	#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR\|PNG_FORMAT_FLAG_COLORMAP)
		2988	#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA\|PNG_FORMAT_FLAG_COLORMAP)
		2989	#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB\|PNG_FORMAT_FLAG_COLORMAP)
		2990	#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA\|PNG_FORMAT_FLAG_COLORMAP)
		2991	#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR\|PNG_FORMAT_FLAG_COLORMAP)
		2992
		2993
		2994	*
		2995	* These are convenience macros to derive information from a png_image
		2996	* structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the
		2997	* actual image sample values - either the entries in the color-map or the
		2998	* pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values
		2999	* for the pixels and will always return 1 for color-mapped formats. The
		3000	* remaining macros return information about the rows in the image and the
		3001	* complete image.
		3002	*
		3003	* NOTE: All the macros that take a png_image::format parameter are compile time
		3004	* constants if the format parameter is, itself, a constant. Therefore these
		3005	* macros can be used in array declarations and case labels where required.
		3006	* Similarly the macros are also pre-processor constants (sizeof is not used) so
		3007	* they can be used in #if tests.
		3008	*
		3009	* First the information about the samples.
		3010	*/
		3011	#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\
		3012	(((fmt)&(PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_ALPHA))+1)
		3013	/* Return the total number of channels in a given format: 1..4 */
		3014
		3015
		3016	((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)
		3017	/* Return the size in bytes of a single component of a pixel or color-map
		3018	* entry (as appropriate) in the image: 1 or 2.
		3019	*/
		3020
		3021
		3022	(PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))
		3023	/* This is the size of the sample data for one sample. If the image is
		3024	* color-mapped it is the size of one color-map entry (and image pixels are
		3025	* one byte in size), otherwise it is the size of one image pixel.
		3026	*/
		3027
		3028
		3029	(PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)
		3030	/* The maximum size of the color-map required by the format expressed in a
		3031	* count of components. This can be used to compile-time allocate a
		3032	* color-map:
		3033	*
		3034	* png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)];
		3035	*
		3036	* png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];
		3037	*
		3038	* Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the
		3039	* information from one of the png_image_begin_read_ APIs and dynamically
		3040	* allocate the required memory.
		3041	*/
		3042
		3043
		3044	#define PNG_IMAGE_PIXEL_(test,fmt)\
		3045	(((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))
		3046
		3047
		3048	PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)
		3049	/* The number of separate channels (components) in a pixel; 1 for a
		3050	* color-mapped image.
		3051	*/
		3052
		3053
		3054	PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)
		3055	/* The size, in bytes, of each component in a pixel; 1 for a color-mapped
		3056	* image.
		3057	*/
		3058
		3059
		3060	/* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */
		3061
		3062
		3063	#define PNG_IMAGE_ROW_STRIDE(image)\
		3064	(PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)
		3065	/* Return the total number of components in a single row of the image; this
		3066	* is the minimum 'row stride', the minimum count of components between each
		3067	* row. For a color-mapped image this is the minimum number of bytes in a
		3068	* row.
		3069	*/
		3070
		3071
		3072	(PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)(image).height(row_stride))
		3073	/* Return the size, in bytes, of an image buffer given a png_image and a row
		3074	* stride - the number of components to leave space for in each row.
		3075	*/
		3076
		3077
		3078	PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))
		3079	/* Return the size, in bytes, of the image in memory given just a png_image;
		3080	* the row stride is the minimum stride required for the image.
		3081	*/
		3082
		3083
		3084	(PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)
		3085	/* Return the size, in bytes, of the color-map of this image. If the image
		3086	* format is not a color-map format this will return a size sufficient for
		3087	* 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
		3088	* you don't want to allocate a color-map in this case.
		3089	*/
		3090
		3091
		3092	*
		3093	* Flags containing additional information about the image are held in the
		3094	* 'flags' field of png_image.
		3095	*/
		3096	#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
		3097	/* This indicates the the RGB values of the in-memory bitmap do not
		3098	* correspond to the red, green and blue end-points defined by sRGB.
		3099	*/
		3100
		3101
		3102	/* On write emphasise speed over compression; the resultant PNG file will be
		3103	* larger but will be produced significantly faster, particular for large
		3104	* images. Do not use this option for images which will be distributed, only
		3105	* used it when producing intermediate files that will be read back in
		3106	* repeatedly. For a typical 24-bit image the option will double the read
		3107	* speed at the cost of increasing the image size by 25%, however for many
		3108	* more compressible images the PNG file can be 10 times larger with only a
		3109	* slight speed gain.
		3110	*/
		3111
		3112
		3113	/* On read if the image is a 16-bit per component image and there is no gAMA
		3114	* or sRGB chunk assume that the components are sRGB encoded. Notice that
		3115	* images output by the simplified API always have gamma information; setting
		3116	* this flag only affects the interpretation of 16-bit images from an
		3117	* external source. It is recommended that the application expose this flag
		3118	* to the user; the user can normally easily recognize the difference between
		3119	* linear and sRGB encoding. This flag has no effect on write - the data
		3120	* passed to the write APIs must have the correct encoding (as defined
		3121	* above.)
		3122	*
		3123	* If the flag is not set (the default) input 16-bit per component data is
		3124	* assumed to be linear.
		3125	*
		3126	* NOTE: the flag can only be set after the png_image_begin_read_ call,
		3127	* because that call initializes the 'flags' field.
		3128	*/
		3129
		3130
		3131	/* READ APIs
		3132	* ---------
		3133	*
		3134	* The png_image passed to the read APIs must have been initialized by setting
		3135	* the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
		3136	*/
		3137	#ifdef PNG_STDIO_SUPPORTED
		3138	PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
		3139	const char *file_name));
		3140	/* The named file is opened for read and the image header is filled in
		3141	* from the PNG header in the file.
		3142	*/
		3143
		3144
		3145	FILE* file));
		3146	/* The PNG header is read from the stdio FILE object. */
		3147	#endif /* PNG_STDIO_SUPPORTED */
		3148
		3149
		3150	png_const_voidp memory, png_size_t size));
		3151	/* The PNG header is read from the given memory buffer. */
		3152
		3153
		3154	png_const_colorp background, void *buffer, png_int_32 row_stride,
		3155	void *colormap));
		3156	/* Finish reading the image into the supplied buffer and clean up the
		3157	* png_image structure.
		3158	*
		3159	* row_stride is the step, in byte or 2-byte units as appropriate,
		3160	* between adjacent rows. A positive stride indicates that the top-most row
		3161	* is first in the buffer - the normal top-down arrangement. A negative
		3162	* stride indicates that the bottom-most row is first in the buffer.
		3163	*
		3164	* background need only be supplied if an alpha channel must be removed from
		3165	* a png_byte format and the removal is to be done by compositing on a solid
		3166	* color; otherwise it may be NULL and any composition will be done directly
		3167	* onto the buffer. The value is an sRGB color to use for the background,
		3168	* for grayscale output the green channel is used.
		3169	*
		3170	* background must be supplied when an alpha channel must be removed from a
		3171	* single byte color-mapped output format, in other words if:
		3172	*
		3173	* 1) The original format from png_image_begin_read_from_* had
		3174	* PNG_FORMAT_FLAG_ALPHA set.
		3175	* 2) The format set by the application does not.
		3176	* 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
		3177	* PNG_FORMAT_FLAG_LINEAR not set.
		3178	*
		3179	* For linear output removing the alpha channel is always done by compositing
		3180	* on black and background is ignored.
		3181	*
		3182	* colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must
		3183	* be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
		3184	* image->colormap_entries will be updated to the actual number of entries
		3185	* written to the colormap; this may be less than the original value.
		3186	*/
		3187
		3188
		3189	/* Free any data allocated by libpng in image->opaque, setting the pointer to
		3190	* NULL. May be called at any time after the structure is initialized.
		3191	*/
		3192	#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */
		3193
		3194
		3195	#ifdef PNG_STDIO_SUPPORTED
		3196	/* WRITE APIS
		3197	* ----------
		3198	* For write you must initialize a png_image structure to describe the image to
		3199	* be written. To do this use memset to set the whole structure to 0 then
		3200	* initialize fields describing your image.
		3201	*
		3202	* version: must be set to PNG_IMAGE_VERSION
		3203	* opaque: must be initialized to NULL
		3204	* width: image width in pixels
		3205	* height: image height in rows
		3206	* format: the format of the data (image and color-map) you wish to write
		3207	* flags: set to 0 unless one of the defined flags applies; set
		3208	* PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB
		3209	* values do not correspond to the colors in sRGB.
		3210	* colormap_entries: set to the number of entries in the color-map (0 to 256)
		3211	*/
		3212	PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
		3213	const char file, int convert_to_8bit, const void buffer,
		3214	png_int_32 row_stride, const void *colormap));
		3215	/* Write the image to the named file. */
		3216
		3217
		3218	int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
		3219	const void *colormap));
		3220	/* Write the image to the given (FILE). /
		3221
		3222
		3223	* data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
		3224	* gamma encoded according to the sRGB specification, otherwise a 16-bit linear
		3225	* encoded PNG file is written.
		3226	*
		3227	* With color-mapped data formats the colormap parameter point to a color-map
		3228	* with at least image->colormap_entries encoded in the specified format. If
		3229	* the format is linear the written PNG color-map will be converted to sRGB
		3230	* regardless of the convert_to_8_bit flag.
		3231	*
		3232	* With all APIs row_stride is handled as in the read APIs - it is the spacing
		3233	* from one row to the next in component sized units (1 or 2 bytes) and if
		3234	* negative indicates a bottom-up row layout in the buffer.
		3235	*
		3236	* Note that the write API does not support interlacing or sub-8-bit pixels.
		3237	*/
		3238	#endif /* PNG_STDIO_SUPPORTED */
		3239	#endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */
		3240	/*******************************************************************************
		3241	* END OF SIMPLIFIED API
		3242	******************************************************************************/
		3243
		3244
		3245	PNG_EXPORT(242, void, png_set_check_for_invalid_index,
		3246	(png_structrp png_ptr, int allowed));
		3247	# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
		3248	PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
		3249	png_const_infop info_ptr));
		3250	# endif
		3251	#endif /* CHECK_FOR_INVALID_INDEX */
		3252
		3253
		3254	* IMPLEMENTATION OPTIONS
		3255	*******************************************************************************
		3256	*
		3257	* Support for arbitrary implementation-specific optimizations. The API allows
		3258	* particular options to be turned on or off. 'Option' is the number of the
		3259	* option and 'onoff' is 0 (off) or non-0 (on). The value returned is given
		3260	* by the PNG_OPTION_ defines below.
		3261	*
		3262	* HARDWARE: normally hardware capabilites, such as the Intel SSE instructions,
		3263	* are detected at run time, however sometimes it may be impossible
		3264	* to do this in user mode, in which case it is necessary to discover
		3265	* the capabilities in an OS specific way. Such capabilities are
		3266	* listed here when libpng has support for them and must be turned
		3267	* ON by the application if present.
		3268	*
		3269	* SOFTWARE: sometimes software optimizations actually result in performance
		3270	* decrease on some architectures or systems, or with some sets of
		3271	* PNG images. 'Software' options allow such optimizations to be
		3272	* selected at run time.
		3273	*/
		3274	#ifdef PNG_SET_OPTION_SUPPORTED
		3275	#ifdef PNG_ARM_NEON_API_SUPPORTED
		3276	# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */
		3277	#endif
		3278	#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */
		3279	#define PNG_OPTION_NEXT 4 /* Next option - numbers must be even */
		3280
		3281
		3282	#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */
		3283	#define PNG_OPTION_INVALID 1 /* Option number out of range */
		3284	#define PNG_OPTION_OFF 2
		3285	#define PNG_OPTION_ON 3
		3286
		3287
		3288	int onoff));
		3289	#endif
		3290
		3291
		3292	* END OF HARDWARE OPTIONS
		3293	******************************************************************************/
		3294
		3295
		3296	* defs, scripts/pnglibconf.h, and scripts/pnglibconf.h.prebuilt
		3297	*/
		3298
		3299
		3300	* one to use is one more than this.) Maintainer, remember to add an entry to
		3301	* scripts/symbols.def as well.
		3302	*/
		3303	#ifdef PNG_EXPORT_LAST_ORDINAL
		3304	PNG_EXPORT_LAST_ORDINAL(244);
		3305	#endif
		3306
		3307
		3308	}
		3309	#endif
		3310
		3311
		3312	/* Do not put anything past this line */
		3313	#endif /* PNG_H */
		3314

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/libpng/png.h @ 5022 – Rev 4349