| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

pngpriv.h
Go to the documentation of this file.
1
2 /* pngpriv.h - private declarations for use inside libpng
3 *
4 * For conditions of distribution and use, see copyright notice in png.h
5 * Copyright (c) 1998-2011 Glenn Randers-Pehrson
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8 *
9 * Last changed in libpng 1.5.0 [January 6, 2011]
10 *
11 * This code is released under the libpng license.
12 * For conditions of distribution and use, see the disclaimer
13 * and license in png.h
14 */
15
16 /* The symbols declared in this file (including the functions declared
17 * as PNG_EXTERN) are PRIVATE. They are not part of the libpng public
18 * interface, and are not recommended for use by regular applications.
19 * Some of them may become public in the future; others may stay private,
20 * change in an incompatible way, or even disappear.
21 * Although the libpng users are not forbidden to include this header,
22 * they should be well aware of the issues that may arise from doing so.
23 */
24
25 #ifndef PNGPRIV_H
26 #define PNGPRIV_H
27
28 /* This is required for the definition of abort(), used as a last ditch
29 * error handler when all else fails.
30 */
31 #include <stdlib.h>
32
33 #define PNGLIB_BUILD
34 #ifdef PNG_USER_CONFIG
35 # include "pngusr.h"
36 /* These should have been defined in pngusr.h */
37 # ifndef PNG_USER_PRIVATEBUILD
38 # define PNG_USER_PRIVATEBUILD "Custom libpng build"
39 # endif
40 # ifndef PNG_USER_DLLFNAME_POSTFIX
41 # define PNG_USER_DLLFNAME_POSTFIX "Cb"
42 # endif
43 #endif
44 #include "png.h"
45 #include "pnginfo.h"
46 #include "pngstruct.h"
47
48 /* This is used for 16 bit gamma tables - only the top level pointers are const,
49 * this could be changed:
50 */
51 typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;
52
53 /* Added at libpng-1.2.9 */
54 /* Moved to pngpriv.h at libpng-1.5.0 */
55
56 /* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure"
57 * script. We may need it here to get the correct configuration on things
58 * like limits.
59 */
60 #ifdef PNG_CONFIGURE_LIBPNG
61 # ifdef HAVE_CONFIG_H
62 # include "config.h"
63 # endif
64 #endif
65
66 /* Moved to pngpriv.h at libpng-1.5.0 */
67 /* NOTE: some of these may have been used in external applications as
68 * these definitions were exposed in pngconf.h prior to 1.5.
69 */
70
71 /* If you are running on a machine where you cannot allocate more
72 * than 64K of memory at once, uncomment this. While libpng will not
73 * normally need that much memory in a chunk (unless you load up a very
74 * large file), zlib needs to know how big of a chunk it can use, and
75 * libpng thus makes sure to check any memory allocation to verify it
76 * will fit into memory.
77 *
78 * zlib provides 'MAXSEG_64K' which, if defined, indicates the
79 * same limit and pngconf.h (already included) sets the limit
80 * if certain operating systems are detected.
81 */
82 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
83 # define PNG_MAX_MALLOC_64K
84 #endif
85
86 /* Unused formal parameter warnings are silenced using the following macro
87 * which is expected to have no bad effects on performance (optimizing
88 * compilers will probably remove it entirely). Note that if you replace
89 * it with something other than whitespace, you must include the terminating
90 * semicolon.
91 */
92 #define PNG_UNUSED(param) (void)param;
93
94 /* Just a little check that someone hasn't tried to define something
95 * contradictory.
96 */
97 #if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
98 # undef PNG_ZBUF_SIZE
99 # define PNG_ZBUF_SIZE 65536L
100 #endif
101
102 /* If warnings or errors are turned off the code is disabled
103 * or redirected here.
104 */
105 #ifndef PNG_WARNINGS_SUPPORTED
106 # define png_warning(s1,s2) ((void)0)
107 # define png_chunk_warning(s1,s2) ((void)0)
108 #endif
109 #ifndef PNG_ERROR_TEXT_SUPPORTED
110 # define png_error(s1,s2) png_err(s1)
111 # define png_chunk_error(s1,s2) png_err(s1)
112 # define png_fixed_error(s1,s2) png_err(s1)
113 #endif
114
115 #ifndef PNG_EXTERN
116 /* The functions exported by PNG_EXTERN are internal functions, which
117 * aren't usually used outside the library (as far as I know), so it is
118 * debatable if they should be exported at all. In the future, when it
119 * is possible to have run-time registry of chunk-handling functions,
120 * some of these might be made available again.
121 # define PNG_EXTERN extern
122 */
123 # define PNG_EXTERN
124 #endif
125
126 /* Some fixed point APIs are still required even if not exported because
127 * they get used by the corresponding floating point APIs. This magic
128 * deals with this:
129 */
130 #ifdef PNG_FIXED_POINT_SUPPORTED
131 # define PNGFAPI PNGAPI
132 #else
133 # define PNGFAPI /* PRIVATE */
134 #endif
135
136 /* Other defines specific to compilers can go here. Try to keep
137 * them inside an appropriate ifdef/endif pair for portability.
138 */
139 #if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
140 defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
141 /* png.c requires the following ANSI-C constants if the conversion of
142 * floating point to ASCII is implemented therein:
143 *
144 * DBL_DIG Maximum number of decimal digits (can be set to any constant)
145 * DBL_MIN Smallest normalized fp number (can be set to an arbitrary value)
146 * DBL_MAX Maximum floating point number (can be set to an arbitrary value)
147 */
148 # include <float.h>
149
150 # if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
151 defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
152 /* We need to check that <math.h> hasn't already been included earlier
153 * as it seems it doesn't agree with <fp.h>, yet we should really use
154 * <fp.h> if possible.
155 */
156 # if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
157 # include <fp.h>
158 # endif
159 # else
160 # include <math.h>
161 # endif
162 # if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
163 /* Amiga SAS/C: We must include builtin FPU functions when compiling using
164 * MATH=68881
165 */
166 # include <m68881.h>
167 # endif
168 #endif
169
170 /* This provides the non-ANSI (far) memory allocation routines. */
171 #if defined(__TURBOC__) && defined(__MSDOS__)
172 # include <mem.h>
173 # include <alloc.h>
174 #endif
175
176 #if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
177 defined(_WIN32) || defined(__WIN32__)
178 # include <windows.h> /* defines _WINDOWS_ macro */
179 #endif
180
181 /* Moved here around 1.5.0beta36 from pngconf.h */
182 /* Users may want to use these so they are not private. Any library
183 * functions that are passed far data must be model-independent.
184 */
185
186 /* Memory model/platform independent fns */
187 #ifndef PNG_ABORT
188 # ifdef _WINDOWS_
189 # define PNG_ABORT() ExitProcess(0)
190 # else
191 # define PNG_ABORT() abort()
192 # endif
193 #endif
194
195 #ifdef USE_FAR_KEYWORD
196 /* Use this to make far-to-near assignments */
197 # define CHECK 1
198 # define NOCHECK 0
199 # define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))
200 # define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))
201 # define png_strcpy _fstrcpy
202 # define png_strncpy _fstrncpy /* Added to v 1.2.6 */
203 # define png_strlen _fstrlen
204 # define png_memcmp _fmemcmp /* SJT: added */
205 # define png_memcpy _fmemcpy
206 # define png_memset _fmemset
207 # define png_sprintf sprintf
208 #else
209 # ifdef _WINDOWS_ /* Favor Windows over C runtime fns */
210 # define CVT_PTR(ptr) (ptr)
211 # define CVT_PTR_NOCHECK(ptr) (ptr)
212 # define png_strcpy lstrcpyA
213 # define png_strncpy lstrcpynA
214 # define png_strlen lstrlenA
215 # define png_memcmp memcmp
216 # define png_memcpy CopyMemory
217 # define png_memset memset
218 # define png_sprintf wsprintfA
219 # else
220 # define CVT_PTR(ptr) (ptr)
221 # define CVT_PTR_NOCHECK(ptr) (ptr)
222 # define png_strcpy strcpy
223 # define png_strncpy strncpy /* Added to v 1.2.6 */
224 # define png_strlen strlen
225 # define png_memcmp memcmp /* SJT: added */
226 # define png_memcpy memcpy
227 # define png_memset memset
228 # define png_sprintf sprintf
229 # endif
230 #endif
231 /* End of memory model/platform independent support */
232
233 #ifndef PNG_NO_SNPRINTF
234 # ifdef _MSC_VER
235 # define png_snprintf _snprintf /* Added to v 1.2.19 */
236 # define png_snprintf2 _snprintf
237 # define png_snprintf6 _snprintf
238 # else
239 # define png_snprintf snprintf /* Added to v 1.2.19 */
240 # define png_snprintf2 snprintf
241 # define png_snprintf6 snprintf
242 # endif
243 #else
244 /* You don't have or don't want to use snprintf(). Caution: Using
245 * sprintf instead of snprintf exposes your application to accidental
246 * or malevolent buffer overflows. If you don't have snprintf()
247 * as a general rule you should provide one (you can get one from
248 * Portable OpenSSH).
249 */
250 # define png_snprintf(s1,n,fmt,x1) png_sprintf(s1,fmt,x1)
251 # define png_snprintf2(s1,n,fmt,x1,x2) png_sprintf(s1,fmt,x1,x2)
252 # define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \
253 png_sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)
254 #endif
255 /* End of 1.5.0beta36 move from pngconf.h */
256
257 /* CONSTANTS and UTILITY MACROS
258 * These are used internally by libpng and not exposed in the API
259 */
260
261 /* Various modes of operation. Note that after an init, mode is set to
262 * zero automatically when the structure is created.
263 */
264 #define PNG_HAVE_IHDR 0x01
265 #define PNG_HAVE_PLTE 0x02
266 #define PNG_HAVE_IDAT 0x04
267 #define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */
268 #define PNG_HAVE_IEND 0x10
269 #define PNG_HAVE_gAMA 0x20
270 #define PNG_HAVE_cHRM 0x40
271 #define PNG_HAVE_sRGB 0x80
272 #define PNG_HAVE_CHUNK_HEADER 0x100
273 #define PNG_WROTE_tIME 0x200
274 #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
275 #define PNG_BACKGROUND_IS_GRAY 0x800
276 #define PNG_HAVE_PNG_SIGNATURE 0x1000
277 #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
278
279 /* Flags for the transformations the PNG library does on the image data */
280 #define PNG_BGR 0x0001
281 #define PNG_INTERLACE 0x0002
282 #define PNG_PACK 0x0004
283 #define PNG_SHIFT 0x0008
284 #define PNG_SWAP_BYTES 0x0010
285 #define PNG_INVERT_MONO 0x0020
286 #define PNG_QUANTIZE 0x0040
287 #define PNG_BACKGROUND 0x0080
288 #define PNG_BACKGROUND_EXPAND 0x0100
289 /* 0x0200 unused */
290 #define PNG_16_TO_8 0x0400
291 #define PNG_RGBA 0x0800
292 #define PNG_EXPAND 0x1000
293 #define PNG_GAMMA 0x2000
294 #define PNG_GRAY_TO_RGB 0x4000
295 #define PNG_FILLER 0x8000L
296 #define PNG_PACKSWAP 0x10000L
297 #define PNG_SWAP_ALPHA 0x20000L
298 #define PNG_STRIP_ALPHA 0x40000L
299 #define PNG_INVERT_ALPHA 0x80000L
300 #define PNG_USER_TRANSFORM 0x100000L
301 #define PNG_RGB_TO_GRAY_ERR 0x200000L
302 #define PNG_RGB_TO_GRAY_WARN 0x400000L
303 #define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */
304 /* 0x800000L Unused */
305 #define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */
306 #define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */
307 /* 0x4000000L unused */
308 /* 0x8000000L unused */
309 /* 0x10000000L unused */
310 /* 0x20000000L unused */
311 /* 0x40000000L unused */
312
313 /* Flags for png_create_struct */
314 #define PNG_STRUCT_PNG 0x0001
315 #define PNG_STRUCT_INFO 0x0002
316
317 /* Scaling factor for filter heuristic weighting calculations */
318 #define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
319 #define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
320
321 /* Flags for the png_ptr->flags rather than declaring a byte for each one */
322 #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001
323 #define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002
324 #define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004
325 #define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008
326 #define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010
327 #define PNG_FLAG_ZLIB_FINISHED 0x0020
328 #define PNG_FLAG_ROW_INIT 0x0040
329 #define PNG_FLAG_FILLER_AFTER 0x0080
330 #define PNG_FLAG_CRC_ANCILLARY_USE 0x0100
331 #define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200
332 #define PNG_FLAG_CRC_CRITICAL_USE 0x0400
333 #define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800
334 /* 0x1000 unused */
335 /* 0x2000 unused */
336 /* 0x4000 unused */
337 #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L
338 #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L
339 #define PNG_FLAG_LIBRARY_MISMATCH 0x20000L
340 #define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L
341 #define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L
342 #define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L
343 #define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */
344 #define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */
345 #define PNG_FLAG_BENIGN_ERRORS_WARN 0x800000L /* Added to libpng-1.4.0 */
346 /* 0x1000000L unused */
347 /* 0x2000000L unused */
348 /* 0x4000000L unused */
349 /* 0x8000000L unused */
350 /* 0x10000000L unused */
351 /* 0x20000000L unused */
352 /* 0x40000000L unused */
353
354 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
355 PNG_FLAG_CRC_ANCILLARY_NOWARN)
356
357 #define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \
358 PNG_FLAG_CRC_CRITICAL_IGNORE)
359
360 #define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \
361 PNG_FLAG_CRC_CRITICAL_MASK)
362
363 /* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
364 * can handle at once. This type need be no larger than 16 bits (so maximum of
365 * 65535), this define allows us to discover how big it is, but limited by the
366 * maximuum for png_size_t. The value can be overriden in a library build
367 * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
368 * lower value (e.g. 255 works). A lower value may help memory usage (slightly)
369 * and may even improve performance on some systems (and degrade it on others.)
370 */
371 #ifndef ZLIB_IO_MAX
372 # define ZLIB_IO_MAX ((uInt)-1)
373 #endif
374
375 /* Save typing and make code easier to understand */
376
377 #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
378 abs((int)((c1).green) - (int)((c2).green)) + \
379 abs((int)((c1).blue) - (int)((c2).blue)))
380
381 /* Added to libpng-1.2.6 JB */
382 #define PNG_ROWBYTES(pixel_bits, width) \
383 ((pixel_bits) >= 8 ? \
384 ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
385 (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
386
387 /* PNG_OUT_OF_RANGE returns true if value is outside the range
388 * ideal-delta..ideal+delta. Each argument is evaluated twice.
389 * "ideal" and "delta" should be constants, normally simple
390 * integers, "value" a variable. Added to libpng-1.2.6 JB
391 */
392 #define PNG_OUT_OF_RANGE(value, ideal, delta) \
393 ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
394
395 /* Conversions between fixed and floating point, only defined if
396 * required (to make sure the code doesn't accidentally use float
397 * when it is supposedly disabled.)
398 */
399 #ifdef PNG_FLOATING_POINT_SUPPORTED
400 /* The floating point conversion can't overflow, though it can and
401 * does lose accuracy relative to the original fixed point value.
402 * In practice this doesn't matter because png_fixed_point only
403 * stores numbers with very low precision. The png_ptr and s
404 * arguments are unused by default but are there in case error
405 * checking becomes a requirement.
406 */
407 #define png_float(png_ptr, fixed, s) (.00001 * (fixed))
408
409 /* The fixed point conversion performs range checking and evaluates
410 * its argument multiple times, so must be used with care. The
411 * range checking uses the PNG specification values for a signed
412 * 32 bit fixed point value except that the values are deliberately
413 * rounded-to-zero to an integral value - 21474 (21474.83 is roughly
414 * (2^31-1) * 100000). 's' is a string that describes the value being
415 * converted.
416 *
417 * NOTE: this macro will raise a png_error if the range check fails,
418 * therefore it is normally only appropriate to use this on values
419 * that come from API calls or other sources where an out of range
420 * error indicates a programming error, not a data error!
421 *
422 * NOTE: by default this is off - the macro is not used - because the
423 * function call saves a lot of code.
424 */
425 #ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
426 #define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
427 ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
428 #else
429 PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp,
430 png_const_charp text));
431 #endif
432 #endif
433
434 /* Constant strings for known chunk types. If you need to add a chunk,
435 * define the name here, and add an invocation of the macro wherever it's
436 * needed.
437 */
438 #define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'}
439 #define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'}
440 #define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'}
441 #define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'}
442 #define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'}
443 #define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'}
444 #define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'}
445 #define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'}
446 #define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'}
447 #define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'}
448 #define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'}
449 #define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'}
450 #define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'}
451 #define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'}
452 #define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'}
453 #define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'}
454 #define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'}
455 #define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115, 84, 69, 82, '\0'}
456 #define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'}
457 #define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116, 73, 77, 69, '\0'}
458 #define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'}
459 #define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'}
460
461
462 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
463 #ifdef __cplusplus
464 extern "C" {
465 #endif /* __cplusplus */
466
467 /* These functions are used internally in the code. They generally
468 * shouldn't be used unless you are writing code to add or replace some
469 * functionality in libpng. More information about most functions can
470 * be found in the files where the functions are located.
471 */
472
473 /* Allocate memory for an internal libpng struct */
474 PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)),
475 PNG_ALLOCATED);
476
477 /* Free memory from internal libpng struct */
478 PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));
479
480 PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct_2,
481 PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)),
482 PNG_ALLOCATED);
483 PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
484 png_free_ptr free_fn, png_voidp mem_ptr));
485
486 /* Free any memory that info_ptr points to and reset struct. */
487 PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,
488 png_infop info_ptr));
489
490 /* Function to allocate memory for zlib. PNGAPI is disallowed. */
491 PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items,
492 uInt size)),PNG_ALLOCATED);
493
494 /* Function to free memory for zlib. PNGAPI is disallowed. */
495 PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));
496
497 /* Next four functions are used internally as callbacks. PNGCBAPI is required
498 * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to
499 * PNGCBAPI at 1.5.0
500 */
501
502 PNG_EXTERN void PNGCBAPI png_default_read_data PNGARG((png_structp png_ptr,
503 png_bytep data, png_size_t length));
504
505 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
506 PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr,
507 png_bytep buffer, png_size_t length));
508 #endif
509
510 PNG_EXTERN void PNGCBAPI png_default_write_data PNGARG((png_structp png_ptr,
511 png_bytep data, png_size_t length));
512
513 #ifdef PNG_WRITE_FLUSH_SUPPORTED
514 # ifdef PNG_STDIO_SUPPORTED
515 PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr));
516 # endif
517 #endif
518
519 /* Reset the CRC variable */
520 PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));
521
522 /* Write the "data" buffer to whatever output you are using */
523 PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr,
524 png_const_bytep data, png_size_t length));
525
526 /* Read and check the PNG file signature */
527 PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr));
528
529 /* Read the chunk header (length + type name) */
530 PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
531
532 /* Read data from whatever input you are using into the "data" buffer */
533 PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,
534 png_size_t length));
535
536 /* Read bytes into buf, and update png_ptr->crc */
537 PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,
538 png_size_t length));
539
540 /* Decompress data in a chunk that uses compression */
541 #if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \
542 defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)
543 PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,
544 int comp_type, png_size_t chunklength, png_size_t prefix_length,
545 png_size_t *data_length));
546 #endif
547
548 /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
549 PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));
550
551 /* Read the CRC from the file and compare it to the libpng calculated CRC */
552 PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));
553
554 /* Calculate the CRC over a section of data. Note that we are only
555 * passing a maximum of 64K on systems that have this as a memory limit,
556 * since this is the maximum buffer size we can specify.
557 */
558 PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr,
559 png_const_bytep ptr, png_size_t length));
560
561 #ifdef PNG_WRITE_FLUSH_SUPPORTED
562 PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));
563 #endif
564
565 /* Write various chunks */
566
567 /* Write the IHDR chunk, and update the png_struct with the necessary
568 * information.
569 */
570 PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,
571 png_uint_32 height,
572 int bit_depth, int color_type, int compression_method, int filter_method,
573 int interlace_method));
574
575 PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr,
576 png_const_colorp palette, png_uint_32 num_pal));
577
578 PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,
579 png_size_t length));
580
581 PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));
582
583 #ifdef PNG_WRITE_gAMA_SUPPORTED
584 # ifdef PNG_FLOATING_POINT_SUPPORTED
585 PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));
586 # endif
587 # ifdef PNG_FIXED_POINT_SUPPORTED
588 PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,
589 png_fixed_point file_gamma));
590 # endif
591 #endif
592
593 #ifdef PNG_WRITE_sBIT_SUPPORTED
594 PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr,
595 png_const_color_8p sbit, int color_type));
596 #endif
597
598 #ifdef PNG_WRITE_cHRM_SUPPORTED
599 # ifdef PNG_FLOATING_POINT_SUPPORTED
600 PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,
601 double white_x, double white_y,
602 double red_x, double red_y, double green_x, double green_y,
603 double blue_x, double blue_y));
604 # endif
605 PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,
606 png_fixed_point int_white_x, png_fixed_point int_white_y,
607 png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
608 int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
609 png_fixed_point int_blue_y));
610 #endif
611
612 #ifdef PNG_WRITE_sRGB_SUPPORTED
613 PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,
614 int intent));
615 #endif
616
617 #ifdef PNG_WRITE_iCCP_SUPPORTED
618 PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,
619 png_const_charp name, int compression_type,
620 png_const_charp profile, int proflen));
621 /* Note to maintainer: profile should be png_bytep */
622 #endif
623
624 #ifdef PNG_WRITE_sPLT_SUPPORTED
625 PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,
626 png_const_sPLT_tp palette));
627 #endif
628
629 #ifdef PNG_WRITE_tRNS_SUPPORTED
630 PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr,
631 png_const_bytep trans, png_const_color_16p values, int number,
632 int color_type));
633 #endif
634
635 #ifdef PNG_WRITE_bKGD_SUPPORTED
636 PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,
637 png_const_color_16p values, int color_type));
638 #endif
639
640 #ifdef PNG_WRITE_hIST_SUPPORTED
641 PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr,
642 png_const_uint_16p hist, int num_hist));
643 #endif
644
645 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
646 defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
647 PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,
648 png_const_charp key, png_charpp new_key));
649 #endif
650
651 #ifdef PNG_WRITE_tEXt_SUPPORTED
652 PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key,
653 png_const_charp text, png_size_t text_len));
654 #endif
655
656 #ifdef PNG_WRITE_zTXt_SUPPORTED
657 PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key,
658 png_const_charp text, png_size_t text_len, int compression));
659 #endif
660
661 #ifdef PNG_WRITE_iTXt_SUPPORTED
662 PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,
663 int compression, png_const_charp key, png_const_charp lang,
664 png_const_charp lang_key, png_const_charp text));
665 #endif
666
667 #ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */
668 PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,
669 png_infop info_ptr, png_const_textp text_ptr, int num_text));
670 #endif
671
672 #ifdef PNG_WRITE_oFFs_SUPPORTED
673 PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,
674 png_int_32 x_offset, png_int_32 y_offset, int unit_type));
675 #endif
676
677 #ifdef PNG_WRITE_pCAL_SUPPORTED
678 PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,
679 png_int_32 X0, png_int_32 X1, int type, int nparams,
680 png_const_charp units, png_charpp params));
681 #endif
682
683 #ifdef PNG_WRITE_pHYs_SUPPORTED
684 PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,
685 png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
686 int unit_type));
687 #endif
688
689 #ifdef PNG_WRITE_tIME_SUPPORTED
690 PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,
691 png_const_timep mod_time));
692 #endif
693
694 #ifdef PNG_WRITE_sCAL_SUPPORTED
695 PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
696 int unit, png_const_charp width, png_const_charp height));
697 #endif
698
699 /* Called when finished processing a row of data */
700 PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));
701
702 /* Internal use only. Called before first row of data */
703 PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));
704
705 /* Combine a row of data, dealing with alpha, etc. if requested */
706 PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,
707 int mask));
708
709 #ifdef PNG_READ_INTERLACING_SUPPORTED
710 /* Expand an interlaced row */
711 /* OLD pre-1.0.9 interface:
712 PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,
713 png_bytep row, int pass, png_uint_32 transformations));
714 */
715 PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));
716 #endif
717
718 /* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */
719
720 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
721 /* Grab pixels out of a row for an interlaced pass */
722 PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,
723 png_bytep row, int pass));
724 #endif
725
726 /* Unfilter a row */
727 PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,
728 png_row_infop row_info, png_bytep row, png_const_bytep prev_row,
729 int filter));
730
731 /* Choose the best filter to use and filter the row data */
732 PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,
733 png_row_infop row_info));
734
735 /* Write out the filtered row. */
736 PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,
737 png_bytep filtered_row));
738 /* Finish a row while reading, dealing with interlacing passes, etc. */
739 PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));
740
741 /* Initialize the row buffers, etc. */
742 PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));
743 /* Optional call to update the users info structure */
744 PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,
745 png_infop info_ptr));
746
747 /* These are the functions that do the transformations */
748 #ifdef PNG_READ_FILLER_SUPPORTED
749 PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,
750 png_bytep row, png_uint_32 filler, png_uint_32 flags));
751 #endif
752
753 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
754 PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,
755 png_bytep row));
756 #endif
757
758 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
759 PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,
760 png_bytep row));
761 #endif
762
763 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
764 PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,
765 png_bytep row));
766 #endif
767
768 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
769 PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,
770 png_bytep row));
771 #endif
772
773 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
774 defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
775 PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,
776 png_bytep row, png_uint_32 flags));
777 #endif
778
779 #ifdef PNG_16BIT_SUPPORTED
780 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
781 PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info,
782 png_bytep row));
783 #endif
784 #endif
785
786 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
787 defined(PNG_WRITE_PACKSWAP_SUPPORTED)
788 PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info,
789 png_bytep row));
790 #endif
791
792 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
793 PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr,
794 png_row_infop row_info, png_bytep row));
795 #endif
796
797 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
798 PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,
799 png_bytep row));
800 #endif
801
802 #ifdef PNG_READ_PACK_SUPPORTED
803 PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info,
804 png_bytep row));
805 #endif
806
807 #ifdef PNG_READ_SHIFT_SUPPORTED
808 PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info,
809 png_bytep row, png_const_color_8p sig_bits));
810 #endif
811
812 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
813 PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info,
814 png_bytep row));
815 #endif
816
817 #ifdef PNG_READ_16_TO_8_SUPPORTED
818 PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info,
819 png_bytep row));
820 #endif
821
822 #ifdef PNG_READ_QUANTIZE_SUPPORTED
823 PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,
824 png_bytep row, png_const_bytep palette_lookup,
825 png_const_bytep quantize_lookup));
826
827 # ifdef PNG_CORRECT_PALETTE_SUPPORTED
828 PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
829 png_colorp palette, int num_palette));
830 # endif
831 #endif
832
833 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
834 PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info,
835 png_bytep row));
836 #endif
837
838 #ifdef PNG_WRITE_PACK_SUPPORTED
839 PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,
840 png_bytep row, png_uint_32 bit_depth));
841 #endif
842
843 #ifdef PNG_WRITE_SHIFT_SUPPORTED
844 PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info,
845 png_bytep row, png_const_color_8p bit_depth));
846 #endif
847
848 #ifdef PNG_READ_BACKGROUND_SUPPORTED
849 # ifdef PNG_READ_GAMMA_SUPPORTED
850 PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info,
851 png_bytep row, png_const_color_16p trans_color,
852 png_const_color_16p background, png_const_color_16p background_1,
853 png_const_bytep gamma_table, png_const_bytep gamma_from_1,
854 png_const_bytep gamma_to_1, png_const_uint_16pp gamma_16,
855 png_const_uint_16pp gamma_16_from_1, png_const_uint_16pp gamma_16_to_1,
856 int gamma_shift));
857 # else
858 PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info,
859 png_bytep row, png_const_color_16p trans_color,
860 png_const_color_16p background));
861 # endif
862 #endif
863
864 #ifdef PNG_READ_GAMMA_SUPPORTED
865 PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info,
866 png_bytep row, png_const_bytep gamma_table,
867 png_const_uint_16pp gamma_16_table, int gamma_shift));
868 #endif
869
870 #ifdef PNG_READ_EXPAND_SUPPORTED
871 PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,
872 png_bytep row, png_const_colorp palette, png_const_bytep trans,
873 int num_trans));
874 PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,
875 png_bytep row, png_const_color_16p trans_color));
876 #endif
877
878 /* The following decodes the appropriate chunks, and does error correction,
879 * then calls the appropriate callback for the chunk if it is valid.
880 */
881
882 /* Decode the IHDR chunk */
883 PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,
884 png_uint_32 length));
885 PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,
886 png_uint_32 length));
887 PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,
888 png_uint_32 length));
889
890 #ifdef PNG_READ_bKGD_SUPPORTED
891 PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,
892 png_uint_32 length));
893 #endif
894
895 #ifdef PNG_READ_cHRM_SUPPORTED
896 PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,
897 png_uint_32 length));
898 #endif
899
900 #ifdef PNG_READ_gAMA_SUPPORTED
901 PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,
902 png_uint_32 length));
903 #endif
904
905 #ifdef PNG_READ_hIST_SUPPORTED
906 PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,
907 png_uint_32 length));
908 #endif
909
910 #ifdef PNG_READ_iCCP_SUPPORTED
911 PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,
912 png_uint_32 length));
913 #endif /* PNG_READ_iCCP_SUPPORTED */
914
915 #ifdef PNG_READ_iTXt_SUPPORTED
916 PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
917 png_uint_32 length));
918 #endif
919
920 #ifdef PNG_READ_oFFs_SUPPORTED
921 PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,
922 png_uint_32 length));
923 #endif
924
925 #ifdef PNG_READ_pCAL_SUPPORTED
926 PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
927 png_uint_32 length));
928 #endif
929
930 #ifdef PNG_READ_pHYs_SUPPORTED
931 PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,
932 png_uint_32 length));
933 #endif
934
935 #ifdef PNG_READ_sBIT_SUPPORTED
936 PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,
937 png_uint_32 length));
938 #endif
939
940 #ifdef PNG_READ_sCAL_SUPPORTED
941 PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,
942 png_uint_32 length));
943 #endif
944
945 #ifdef PNG_READ_sPLT_SUPPORTED
946 PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,
947 png_uint_32 length));
948 #endif /* PNG_READ_sPLT_SUPPORTED */
949
950 #ifdef PNG_READ_sRGB_SUPPORTED
951 PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,
952 png_uint_32 length));
953 #endif
954
955 #ifdef PNG_READ_tEXt_SUPPORTED
956 PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,
957 png_uint_32 length));
958 #endif
959
960 #ifdef PNG_READ_tIME_SUPPORTED
961 PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,
962 png_uint_32 length));
963 #endif
964
965 #ifdef PNG_READ_tRNS_SUPPORTED
966 PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,
967 png_uint_32 length));
968 #endif
969
970 #ifdef PNG_READ_zTXt_SUPPORTED
971 PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
972 png_uint_32 length));
973 #endif
974
975 PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,
976 png_infop info_ptr, png_uint_32 length));
977
978 PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,
979 png_const_bytep chunk_name));
980
981 /* Handle the transformations for reading and writing */
982 PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));
983 PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));
984
985 PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));
986
987 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
988 PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,
989 png_infop info_ptr));
990 PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,
991 png_infop info_ptr));
992 PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));
993 PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,
994 png_uint_32 length));
995 PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));
996 PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));
997 PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,
998 png_bytep buffer, png_size_t buffer_length));
999 PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));
1000 PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,
1001 png_bytep buffer, png_size_t buffer_length));
1002 PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));
1003 PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,
1004 png_infop info_ptr, png_uint_32 length));
1005 PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,
1006 png_infop info_ptr));
1007 PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,
1008 png_infop info_ptr));
1009 PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));
1010 PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,
1011 png_infop info_ptr));
1012 PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,
1013 png_infop info_ptr));
1014 PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));
1015 # ifdef PNG_READ_tEXt_SUPPORTED
1016 PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,
1017 png_infop info_ptr, png_uint_32 length));
1018 PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,
1019 png_infop info_ptr));
1020 # endif
1021 # ifdef PNG_READ_zTXt_SUPPORTED
1022 PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,
1023 png_infop info_ptr, png_uint_32 length));
1024 PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,
1025 png_infop info_ptr));
1026 # endif
1027 # ifdef PNG_READ_iTXt_SUPPORTED
1028 PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,
1029 png_infop info_ptr, png_uint_32 length));
1030 PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
1031 png_infop info_ptr));
1032 # endif
1033
1034 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
1035
1036 #ifdef PNG_MNG_FEATURES_SUPPORTED
1037 PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,
1038 png_bytep row));
1039 PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,
1040 png_bytep row));
1041 #endif
1042
1043 /* Added at libpng version 1.4.0 */
1044 #ifdef PNG_CHECK_cHRM_SUPPORTED
1045 PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,
1046 png_fixed_point int_white_x, png_fixed_point int_white_y,
1047 png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
1048 int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
1049 png_fixed_point int_blue_y));
1050 #endif
1051
1052 #ifdef PNG_CHECK_cHRM_SUPPORTED
1053 /* Added at libpng version 1.2.34 and 1.4.0 */
1054 /* Currently only used by png_check_cHRM_fixed */
1055 PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,
1056 unsigned long *hi_product, unsigned long *lo_product));
1057 #endif
1058
1059 /* Added at libpng version 1.4.0 */
1060 PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,
1061 png_uint_32 width, png_uint_32 height, int bit_depth,
1062 int color_type, int interlace_type, int compression_type,
1063 int filter_type));
1064
1065 /* Free all memory used by the read (old method - NOT DLL EXPORTED) */
1066 PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr,
1067 png_infop info_ptr, png_infop end_info_ptr));
1068
1069 /* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */
1070 PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr));
1071
1072 #ifdef USE_FAR_KEYWORD /* memory model conversion function */
1073 PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr,
1074 int check));
1075 #endif /* USE_FAR_KEYWORD */
1076
1077 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
1078 PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr,
1079 png_const_charp name),PNG_NORETURN);
1080 #endif
1081
1082 /* ASCII to FP interfaces, currently only implemented if sCAL
1083 * support is required.
1084 */
1085 #if defined(PNG_READ_sCAL_SUPPORTED)
1086 /* MAX_DIGITS is actually the maximum number of characters in an sCAL
1087 * width or height, derived from the precision (number of significant
1088 * digits - a build time settable option) and assumpitions about the
1089 * maximum ridiculous exponent.
1090 */
1091 #define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
1092
1093 #ifdef PNG_FLOATING_POINT_SUPPORTED
1094 PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii,
1095 png_size_t size, double fp, unsigned int precision));
1096 #endif /* FLOATING_POINT */
1097
1098 #ifdef PNG_FIXED_POINT_SUPPORTED
1099 PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr,
1100 png_charp ascii, png_size_t size, png_fixed_point fp));
1101 #endif /* FIXED_POINT */
1102 #endif /* READ_sCAL */
1103
1104 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
1105 /* An internal API to validate the format of a floating point number.
1106 * The result is the index of the next character. If the number is
1107 * not valid it will be the index of a character in the supposed number.
1108 *
1109 * The format of a number is defined in the PNG extensions specification
1110 * and this API is strictly conformant to that spec, not anyone elses!
1111 *
1112 * The format as a regular expression is:
1113 *
1114 * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?
1115 *
1116 * or:
1117 *
1118 * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?
1119 *
1120 * The complexity is that either integer or fraction must be present and the
1121 * fraction is permitted to have no digits only if the integer is present.
1122 *
1123 * NOTE: The dangling E problem.
1124 * There is a PNG valid floating point number in the following:
1125 *
1126 * PNG floating point numb1.ers are not greedy.
1127 *
1128 * Working this out requires *TWO* character lookahead (because of the
1129 * sign), the parser does not do this - it will fail at the 'r' - this
1130 * doesn't matter for PNG sCAL chunk values, but it requires more care
1131 * if the value were ever to be embedded in something more complex. Use
1132 * ANSI-C strtod if you need the lookahead.
1133 */
1134 /* State table for the parser. */
1135 #define PNG_FP_INTEGER 0 /* before or in integer */
1136 #define PNG_FP_FRACTION 1 /* before or in fraction */
1137 #define PNG_FP_EXPONENT 2 /* before or in exponent */
1138 #define PNG_FP_STATE 3 /* mask for the above */
1139 #define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */
1140 #define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */
1141 #define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */
1142 #define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */
1143 #define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */
1144 #define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */
1145 #define PNG_FP_INVALID 128 /* Available for callers as a distinct value */
1146
1147 /* Result codes for the parser (boolean - true meants ok, false means
1148 * not ok yet.)
1149 */
1150 #define PNG_FP_MAYBE 0 /* The number may be valid in the future */
1151 #define PNG_FP_OK 1 /* The number is valid */
1152
1153 /* The actual parser. This can be called repeatedly, it updates
1154 * the index into the string and the state variable (which must
1155 * be initialzed to 0). It returns a result code, as above. There
1156 * is no point calling the parser any more if it fails to advance to
1157 * the end of the string - it is stuck on an invalid character (or
1158 * terminated by '\0').
1159 *
1160 * Note that the pointer will consume an E or even an E+ then leave
1161 * a 'maybe' state even though a preceding integer.fraction is valid.
1162 * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
1163 * a valid number. It's possible to recover from this by calling
1164 * the parser again (from the start, with state 0) but with a string
1165 * that omits the last character (i.e. set the size to the index of
1166 * the problem character.) This has not been tested within libpng.
1167 */
1168 PNG_EXTERN int png_check_fp_number PNGARG((png_const_charp string,
1169 png_size_t size, int *statep, png_size_tp whereami));
1170
1171 /* This is the same but it checks a complete string and returns true
1172 * only if it just contains a floating point number.
1173 */
1174 PNG_EXTERN int png_check_fp_string PNGARG((png_const_charp string,
1175 png_size_t size));
1176 #endif /* pCAL || sCAL */
1177
1178 #if defined(PNG_READ_GAMMA_SUPPORTED) ||\
1179 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
1180 /* Added at libpng version 1.5.0 */
1181 /* This is a utility to provide a*times/div (rounded) and indicate
1182 * if there is an overflow. The result is a boolean - false (0)
1183 * for overflow, true (1) if no overflow, in which case *res
1184 * holds the result.
1185 */
1186 PNG_EXTERN int png_muldiv PNGARG((png_fixed_point_p res, png_fixed_point a,
1187 png_int_32 times, png_int_32 div));
1188 #endif
1189
1190 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
1191 /* Same deal, but issue a warning on overflow and return 0. */
1192 PNG_EXTERN png_fixed_point png_muldiv_warn PNGARG((png_structp png_ptr,
1193 png_fixed_point a, png_int_32 times, png_int_32 div));
1194 #endif
1195
1196 #ifdef PNG_READ_GAMMA_SUPPORTED
1197 /* Calculate a reciprocal - used for gamma values. This returns
1198 * 0 if the argument is 0 in order to maintain an undefined value,
1199 * there are no warnings.
1200 */
1201 PNG_EXTERN png_fixed_point png_reciprocal PNGARG((png_fixed_point a));
1202
1203 /* The same but gives a reciprocal of the product of two fixed point
1204 * values. Accuracy is suitable for gamma calculations but this is
1205 * not exact - use png_muldiv for that.
1206 */
1207 PNG_EXTERN png_fixed_point png_reciprocal2 PNGARG((png_fixed_point a,
1208 png_fixed_point b));
1209 #endif
1210
1211 #ifdef PNG_READ_GAMMA_SUPPORTED
1212 /* Internal fixed point gamma correction. These APIs are called as
1213 * required to convert single values - they don't need to be fast,
1214 * they are not used when processing image pixel values.
1215 *
1216 * While the input is an 'unsigned' value it must actually be the
1217 * correct bit value - 0..255 or 0..65535 as required.
1218 */
1219 PNG_EXTERN png_uint_16 png_gamma_correct PNGARG((png_structp png_ptr,
1220 unsigned int value, png_fixed_point gamma));
1221 PNG_EXTERN int png_gamma_significant PNGARG((png_fixed_point gamma));
1222 PNG_EXTERN png_uint_16 png_gamma_16bit_correct PNGARG((unsigned int value,
1223 png_fixed_point gamma));
1224 PNG_EXTERN png_byte png_gamma_8bit_correct PNGARG((unsigned int value,
1225 png_fixed_point gamma));
1226 PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr,
1227 int bit_depth));
1228 #endif
1229
1230 /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
1231
1232
1233 #include "pngdebug.h"
1234
1235 #ifdef __cplusplus
1236 }
1237 #endif
1238
1239 #endif /* PNGPRIV_H */
png_do_read_intrapixel
void png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:4164
png_do_write_intrapixel
void png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
Definition: pngwtran.c:570
png_push_read_IDAT
void png_push_read_IDAT(png_structp png_ptr)
Definition: pngpread.c:810
png_push_fill_buffer
void PNGCBAPI png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
Definition: pngpread.c:700
png_do_packswap
void png_do_packswap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:396
png_do_expand
void png_do_expand(png_row_infop row_info, png_bytep row, png_const_color_16p trans_value)
Definition: pngrtran.c:3842
png_write_start_row
void png_write_start_row(png_structp png_ptr)
Definition: pngwutil.c:1774
png_zfree
void png_zfree(voidpf png_ptr, voidpf ptr)
Definition: png.c:99
voidpf
Byte FAR * voidpf
Definition: zconf.h:355
png_push_have_row
void png_push_have_row(png_structp png_ptr, png_bytep row)
Definition: pngpread.c:1810
pngdebug.h
png_write_sPLT
void png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette)
Definition: pngwutil.c:931
png_handle_IEND
void png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:766
png_write_PLTE
void png_write_PLTE(png_structp png_ptr, png_const_colorp palette, png_uint_32 num_pal)
Definition: pngwutil.c:671
PNG_NORETURN
#define PNG_NORETURN
Definition: pngconf.h:425
png_const_uint_16pp
PNG_CONST png_uint_16p FAR * png_const_uint_16pp
Definition: pngpriv.h:51
png_do_invert
void png_do_invert(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:210
png_const_timep
PNG_CONST png_time FAR * png_const_timep
Definition: png.h:641
png_ascii_from_fp
void png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size, double fp, unsigned int precision)
Definition: png.c:1084
png_write_sBIT
void png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type)
Definition: pngwutil.c:1016
png_do_read_filler
void png_do_read_filler(png_row_infop row_info, png_bytep row, png_uint_32 filler, png_uint_32 flags)
Definition: pngrtran.c:2130
png_size_tp
png_size_t FAR * png_size_tp
Definition: pngconf.h:576
png_do_unshift
void png_do_unshift(png_row_infop row_info, png_bytep row, png_const_color_8p sig_bits)
Definition: pngrtran.c:1761
png.h
png_push_read_sig
void png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:176
pnginfo.h
png_push_have_end
void png_push_have_end(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:1803
png_write_gAMA_fixed
void png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
Definition: pngwutil.c:813
PNGCBAPI
#define PNGCBAPI
Definition: pngconf.h:253
png_charp
char FAR * png_charp
Definition: pngconf.h:572
png_do_strip_filler
void png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
Definition: pngtrans.c:429
png_do_pack
void png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
Definition: pngwtran.c:100
png_handle_IHDR
void png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:543
png_fixed
png_fixed_point png_fixed(png_structp png_ptr, double fp, png_const_charp text)
Definition: png.c:1459
PNG_FUNCTION
PNG_EXTERN PNG_FUNCTION(png_voidp, png_create_struct, PNGARG((int type)), PNG_ALLOCATED)
png_push_read_iTXt
void png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:1616
png_handle_sPLT
void png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1273
png_fixed_point_p
png_fixed_point FAR * png_fixed_point_p
Definition: pngconf.h:574
png_do_read_invert_alpha
void png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2028
png_reciprocal
png_fixed_point png_reciprocal(png_fixed_point a)
Definition: png.c:1614
png_do_background
void png_do_background(png_row_infop row_info, png_bytep row, png_const_color_16p trans_color, png_const_color_16p background, png_const_color_16p background_1, png_const_bytep gamma_table, png_const_bytep gamma_from_1, png_const_bytep gamma_to_1, png_const_uint_16pp gamma_16, png_const_uint_16pp gamma_16_from_1, png_const_uint_16pp gamma_16_to_1, int gamma_shift)
Definition: pngrtran.c:2738
png_write_zTXt
void png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len, int compression)
Definition: pngwutil.c:1450
png_const_colorp
PNG_CONST png_color FAR * png_const_colorp
Definition: png.h:525
png_int_32
long png_int_32
Definition: pngconf.h:481
png_do_read_transformations
void png_do_read_transformations(png_structp png_ptr)
Definition: pngrtran.c:1404
png_do_write_transformations
void png_do_write_transformations(png_structp png_ptr)
Definition: pngwtran.c:22
png_const_charp
PNG_CONST char FAR * png_const_charp
Definition: pngconf.h:573
png_write_oFFs
void png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, int unit_type)
Definition: pngwutil.c:1606
png_crc_read
void png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
Definition: pngrutil.c:189
png_write_IDAT
void png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: pngwutil.c:742
png_read_filter_row
void png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, png_const_bytep prev_row, int filter)
Definition: pngrutil.c:3121
png_default_write_data
void PNGCBAPI png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: pngwio.c:51
png_do_chop
void png_do_chop(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:1877
png_read_destroy
void png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
Definition: pngread.c:1157
png_handle_sCAL
void png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1963
png_const_color_8p
PNG_CONST png_color_8 FAR * png_const_color_8p
Definition: png.h:549
PNG_ALLOCATED
#define PNG_ALLOCATED
Definition: pngconf.h:428
png_do_rgb_to_gray
int png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2425
b
long b
Definition: jpegint.h:371
png_do_quantize
void png_do_quantize(png_row_infop row_info, png_bytep row, png_const_bytep palette_lookup, png_const_bytep quantize_lookup)
Definition: pngrtran.c:4069
pngstruct.h
png_read_finish_row
void png_read_finish_row(png_structp png_ptr)
Definition: pngrutil.c:3250
png_push_read_chunk
void png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:209
png_write_pCAL
void png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)
Definition: pngwutil.c:1627
png_flush
void png_flush(png_structp png_ptr)
Definition: pngwio.c:129
png_handle_iTXt
void png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:2336
png_write_data
void png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length)
Definition: pngwio.c:33
png_write_pHYs
void png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int unit_type)
Definition: pngwutil.c:1721
png_handle_zTXt
void png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:2206
png_do_gray_to_rgb
void png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2317
png_init_read_transformations
void png_init_read_transformations(png_structp png_ptr)
Definition: pngrtran.c:814
png_do_gamma
void png_do_gamma(png_row_infop row_info, png_bytep row, png_const_bytep gamma_table, png_const_uint_16pp gamma_16_table, int gamma_shift)
Definition: pngrtran.c:3491
png_handle_cHRM
void png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:944
png_handle_hIST
void png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1668
png_push_handle_zTXt
void png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngpread.c:1381
png_push_save_buffer
void png_push_save_buffer(png_structp png_ptr)
Definition: pngpread.c:743
png_uint_32
unsigned long png_uint_32
Definition: pngconf.h:480
png_read_transform_info
void png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
Definition: pngrtran.c:1254
png_check_IHDR
void png_check_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_type, int compression_type, int filter_type)
Definition: png.c:745
png_structp
png_struct FAR * png_structp
Definition: png.h:797
png_read_start_row
void png_read_start_row(png_structp png_ptr)
Definition: pngrutil.c:3380
png_write_tIME
void png_write_tIME(png_structp png_ptr, png_const_timep mod_time)
Definition: pngwutil.c:1746
png_write_cHRM_fixed
void png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, png_fixed_point blue_y)
Definition: pngwutil.c:1076
png_default_read_data
void PNGCBAPI png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: pngrio.c:51
png_write_tEXt
void png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len)
Definition: pngwutil.c:1408
png_info_destroy
void png_info_destroy(png_structp png_ptr, png_infop info_ptr)
Definition: png.c:455
png_const_textp
PNG_CONST png_text FAR * png_const_textp
Definition: png.h:611
PNG_CONST
#define PNG_CONST
Definition: pngconf.h:462
png_infop
png_info FAR * png_infop
Definition: png.h:667
png_handle_tEXt
void png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:2099
png_check_fp_number
int png_check_fp_number(png_const_charp string, png_size_t size, int *statep, png_size_tp whereami)
Definition: png.c:904
png_muldiv_warn
png_fixed_point png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: png.c:1598
png_destroy_struct
void png_destroy_struct(png_voidp struct_ptr)
Definition: pngmem.c:429
png_do_read_swap_alpha
void png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:1931
png_write_find_filter
void png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
Definition: pngwutil.c:2189
png_push_crc_finish
void png_push_crc_finish(png_structp png_ptr)
Definition: pngpread.c:639
png_build_gamma_table
void png_build_gamma_table(png_structp png_ptr, int bit_depth)
Definition: png.c:2250
png_byte
unsigned char png_byte
Definition: pngconf.h:485
png_uint_16
unsigned short png_uint_16
Definition: pngconf.h:483
png_handle_pCAL
void png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1819
png_do_read_interlace
void png_do_read_interlace(png_structp png_ptr)
Definition: pngrutil.c:2879
png_write_IHDR
void png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int compression_type, int filter_type, int interlace_type)
Definition: pngwutil.c:449
png_write_filtered_row
void png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
Definition: pngwutil.c:2860
png_combine_row
void png_combine_row(png_structp png_ptr, png_bytep row, int mask)
Definition: pngrutil.c:2661
png_check_cHRM_fixed
int png_check_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, png_fixed_point blue_y)
Definition: png.c:671
png_push_handle_iTXt
void png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngpread.c:1585
png_ascii_from_fixed
void png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size, png_fixed_point fp)
Definition: png.c:1386
FAR
#define FAR
Definition: jmorecfg.h:215
png_do_bgr
void png_do_bgr(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:597
png_default_flush
void PNGCBAPI png_default_flush(png_structp png_ptr)
Definition: pngwio.c:137
png_uint_16p
png_uint_16 FAR * png_uint_16p
Definition: pngconf.h:568
png_const_bytep
PNG_CONST png_byte FAR * png_const_bytep
Definition: pngconf.h:563
png_push_handle_tEXt
void png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngpread.c:1284
png_push_crc_skip
void png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
Definition: pngpread.c:632
png_muldiv
int png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: png.c:1479
png_process_IDAT_data
void png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, png_size_t buffer_length)
Definition: pngpread.c:908
png_read_push_finish_row
void png_read_push_finish_row(png_structp png_ptr)
Definition: pngpread.c:1219
png_handle_unknown
void png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:2502
png_const_color_16p
PNG_CONST png_color_16 FAR * png_const_color_16p
Definition: png.h:537
png_write_iCCP
void png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type, png_const_charp profile, int profile_len)
Definition: pngwutil.c:848
png_read_sig
void png_read_sig(png_structp png_ptr, png_infop info_ptr)
Definition: pngrutil.c:117
png_crc_finish
int png_crc_finish(png_structp png_ptr, png_uint_32 skip)
Definition: pngrutil.c:204
png_reciprocal2
png_fixed_point png_reciprocal2(png_fixed_point a, png_fixed_point b)
Definition: png.c:1655
png_do_shift
void png_do_shift(png_row_infop row_info, png_bytep row, png_const_color_8p bit_depth)
Definition: pngwtran.c:245
png_check_keyword
png_size_t png_check_keyword(png_structp png_ptr, png_const_charp key, png_charpp new_key)
Definition: pngwutil.c:1282
png_set_text_2
int png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_const_textp text_ptr, int num_text)
Definition: pngset.c:628
png_bytep
png_byte FAR * png_bytep
Definition: pngconf.h:562
png_handle_tRNS
void png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1462
png_push_restore_buffer
void png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, png_size_t buffer_length)
Definition: pngpread.c:800
png_do_unpack
void png_do_unpack(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:1663
png_handle_sRGB
void png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1045
png_read_data
void png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: pngrio.c:32
PNGARG
PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp, png_const_charp text))
png_write_destroy
void png_write_destroy(png_structp png_ptr)
Definition: pngwrite.c:980
png_do_expand_palette
void png_do_expand_palette(png_row_infop row_info, png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
Definition: pngrtran.c:3689
png_row_infop
png_row_info FAR * png_row_infop
Definition: png.h:784
png_64bit_product
void png_64bit_product(long v1, long v2, unsigned long *hi_product, unsigned long *lo_product)
Definition: png.c:1700
png_write_sRGB
void png_write_sRGB(png_structp png_ptr, int srgb_intent)
Definition: pngwutil.c:829
png_do_swap
void png_do_swap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:267
png_gamma_8bit_correct
png_byte png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2016
png_handle_tIME
void png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:2053
png_handle_oFFs
void png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1772
png_write_tRNS
void png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha, png_const_color_16p tran, int num_trans, int color_type)
Definition: pngwutil.c:1112
png_process_some_data
void png_process_some_data(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:106
png_voidp
void FAR * png_voidp
Definition: pngconf.h:560
png_write_IEND
void png_write_IEND(png_structp png_ptr)
Definition: pngwutil.c:800
png_write_iTXt
void png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key, png_const_charp lang, png_const_charp lang_key, png_const_charp text)
Definition: pngwutil.c:1512
png_fixed_point
png_int_32 png_fixed_point
Definition: pngconf.h:557
png_charpp
char FAR *FAR * png_charpp
Definition: pngconf.h:595
png_handle_bKGD
void png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1566
png_destroy_struct_2
void png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, png_voidp mem_ptr)
Definition: pngmem.c:437
png_calculate_crc
void png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
Definition: png.c:119
png_handle_gAMA
void png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:789
png_size_t
size_t png_size_t
Definition: pngconf.h:490
png_crc_error
int png_crc_error(png_structp png_ptr)
Definition: pngrutil.c:245
png_handle_sBIT
void png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:871
data
JSAMPIMAGE data
Definition: jpeglib.h:945
png_push_process_row
void png_push_process_row(png_structp png_ptr)
Definition: pngpread.c:1012
png_write_hIST
void png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist)
Definition: pngwutil.c:1240
png_push_handle_unknown
void png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngpread.c:1711
png_const_sPLT_tp
PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp
Definition: png.h:581
png_decompress_chunk
void png_decompress_chunk(png_structp png_ptr, int comp_type, png_size_t chunklength, png_size_t prefix_size, png_size_t *newlength)
Definition: pngrutil.c:424
png_handle_iCCP
void png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1130
png_check_fp_string
int png_check_fp_string(png_const_charp string, png_size_t size)
Definition: png.c:1031
png_write_finish_row
void png_write_finish_row(png_structp png_ptr)
Definition: pngwutil.c:1880
png_handle_PLTE
void png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:618
png_push_read_tEXt
void png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:1315
png_push_read_zTXt
void png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:1414
png_gamma_correct
png_uint_16 png_gamma_correct(png_structp png_ptr, unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2067
png_push_have_info
void png_push_have_info(png_structp png_ptr, png_infop info_ptr)
Definition: pngpread.c:1796
png_gamma_16bit_correct
png_uint_16 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: png.c:2039
png_handle_pHYs
void png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
Definition: pngrutil.c:1726
png_write_sCAL_s
void png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width, png_const_charp height)
Definition: pngwutil.c:1690
png_do_write_interlace
void png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
Definition: pngwutil.c:2008
png_const_uint_16p
PNG_CONST png_uint_16 FAR * png_const_uint_16p
Definition: pngconf.h:569
png_reset_crc
void png_reset_crc(png_structp png_ptr)
Definition: png.c:108
png_gamma_significant
int png_gamma_significant(png_fixed_point gamma_val)
Definition: png.c:2081
uInt
unsigned int uInt
Definition: zconf.h:335
PNG_EXTERN
#define PNG_EXTERN
Definition: pngpriv.h:123
png_read_chunk_header
png_uint_32 png_read_chunk_header(png_structp png_ptr)
Definition: pngrutil.c:152
png_do_write_swap_alpha
void png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
Definition: pngwtran.c:380
png_write_bKGD
void png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type)
Definition: pngwutil.c:1177
png_do_write_invert_alpha
void png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
Definition: pngwtran.c:474
png_colorp
png_color FAR * png_colorp
Definition: png.h:524
png_check_chunk_name
void png_check_chunk_name(png_structp png_ptr, png_const_bytep chunk_name)
Definition: pngrutil.c:2638