← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/3rdparty/libpng/pngstruct.h

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/3rdparty/libpng/pngstruct.h
 
1
 
 
2
/* pngstruct.h - header file for PNG reference library
 
3
 *
 
4
 * Last changed in libpng 1.6.18 [July 23, 2015]
 
5
 * Copyright (c) 1998-2015 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
 * This code is released under the libpng license.
 
10
 * For conditions of distribution and use, see the disclaimer
 
11
 * and license in png.h
 
12
 */
 
13
 
 
14
/* The structure that holds the information to read and write PNG files.
 
15
 * The only people who need to care about what is inside of this are the
 
16
 * people who will be modifying the library for their own special needs.
 
17
 * It should NOT be accessed directly by an application.
 
18
 */
 
19
 
 
20
#ifndef PNGSTRUCT_H
 
21
#define PNGSTRUCT_H
 
22
/* zlib.h defines the structure z_stream, an instance of which is included
 
23
 * in this structure and is required for decompressing the LZ compressed
 
24
 * data in PNG files.
 
25
 */
 
26
#ifndef ZLIB_CONST
 
27
   /* We must ensure that zlib uses 'const' in declarations. */
 
28
#  define ZLIB_CONST
 
29
#endif
 
30
#include "zlib.h"
 
31
#ifdef const
 
32
   /* zlib.h sometimes #defines const to nothing, undo this. */
 
33
#  undef const
 
34
#endif
 
35
 
 
36
/* zlib.h has mediocre z_const use before 1.2.6, this stuff is for compatibility
 
37
 * with older builds.
 
38
 */
 
39
#if ZLIB_VERNUM < 0x1260
 
40
#  define PNGZ_MSG_CAST(s) png_constcast(char*,s)
 
41
#  define PNGZ_INPUT_CAST(b) png_constcast(png_bytep,b)
 
42
#else
 
43
#  define PNGZ_MSG_CAST(s) (s)
 
44
#  define PNGZ_INPUT_CAST(b) (b)
 
45
#endif
 
46
 
 
47
/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
 
48
 * can handle at once.  This type need be no larger than 16 bits (so maximum of
 
49
 * 65535), this define allows us to discover how big it is, but limited by the
 
50
 * maximuum for png_size_t.  The value can be overriden in a library build
 
51
 * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
 
52
 * lower value (e.g. 255 works).  A lower value may help memory usage (slightly)
 
53
 * and may even improve performance on some systems (and degrade it on others.)
 
54
 */
 
55
#ifndef ZLIB_IO_MAX
 
56
#  define ZLIB_IO_MAX ((uInt)-1)
 
57
#endif
 
58
 
 
59
#ifdef PNG_WRITE_SUPPORTED
 
60
/* The type of a compression buffer list used by the write code. */
 
61
typedef struct png_compression_buffer
 
62
{
 
63
   struct png_compression_buffer *next;
 
64
   png_byte                       output[1]; /* actually zbuf_size */
 
65
} png_compression_buffer, *png_compression_bufferp;
 
66
 
 
67
#define PNG_COMPRESSION_BUFFER_SIZE(pp)\
 
68
   (offsetof(png_compression_buffer, output) + (pp)->zbuffer_size)
 
69
#endif
 
70
 
 
71
/* Colorspace support; structures used in png_struct, png_info and in internal
 
72
 * functions to hold and communicate information about the color space.
 
73
 *
 
74
 * PNG_COLORSPACE_SUPPORTED is only required if the application will perform
 
75
 * colorspace corrections, otherwise all the colorspace information can be
 
76
 * skipped and the size of libpng can be reduced (significantly) by compiling
 
77
 * out the colorspace support.
 
78
 */
 
79
#ifdef PNG_COLORSPACE_SUPPORTED
 
80
/* The chromaticities of the red, green and blue colorants and the chromaticity
 
81
 * of the corresponding white point (i.e. of rgb(1.0,1.0,1.0)).
 
82
 */
 
83
typedef struct png_xy
 
84
{
 
85
   png_fixed_point redx, redy;
 
86
   png_fixed_point greenx, greeny;
 
87
   png_fixed_point bluex, bluey;
 
88
   png_fixed_point whitex, whitey;
 
89
} png_xy;
 
90
 
 
91
/* The same data as above but encoded as CIE XYZ values.  When this data comes
 
92
 * from chromaticities the sum of the Y values is assumed to be 1.0
 
93
 */
 
94
typedef struct png_XYZ
 
95
{
 
96
   png_fixed_point red_X, red_Y, red_Z;
 
97
   png_fixed_point green_X, green_Y, green_Z;
 
98
   png_fixed_point blue_X, blue_Y, blue_Z;
 
99
} png_XYZ;
 
100
#endif /* COLORSPACE */
 
101
 
 
102
#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
 
103
/* A colorspace is all the above plus, potentially, profile information;
 
104
 * however at present libpng does not use the profile internally so it is only
 
105
 * stored in the png_info struct (if iCCP is supported.)  The rendering intent
 
106
 * is retained here and is checked.
 
107
 *
 
108
 * The file gamma encoding information is also stored here and gamma correction
 
109
 * is done by libpng, whereas color correction must currently be done by the
 
110
 * application.
 
111
 */
 
112
typedef struct png_colorspace
 
113
{
 
114
#ifdef PNG_GAMMA_SUPPORTED
 
115
   png_fixed_point gamma;        /* File gamma */
 
116
#endif
 
117
 
 
118
#ifdef PNG_COLORSPACE_SUPPORTED
 
119
   png_xy      end_points_xy;    /* End points as chromaticities */
 
120
   png_XYZ     end_points_XYZ;   /* End points as CIE XYZ colorant values */
 
121
   png_uint_16 rendering_intent; /* Rendering intent of a profile */
 
122
#endif
 
123
 
 
124
   /* Flags are always defined to simplify the code. */
 
125
   png_uint_16 flags;            /* As defined below */
 
126
} png_colorspace, * PNG_RESTRICT png_colorspacerp;
 
127
 
 
128
typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp;
 
129
 
 
130
/* General flags for the 'flags' field */
 
131
#define PNG_COLORSPACE_HAVE_GAMMA           0x0001
 
132
#define PNG_COLORSPACE_HAVE_ENDPOINTS       0x0002
 
133
#define PNG_COLORSPACE_HAVE_INTENT          0x0004
 
134
#define PNG_COLORSPACE_FROM_gAMA            0x0008
 
135
#define PNG_COLORSPACE_FROM_cHRM            0x0010
 
136
#define PNG_COLORSPACE_FROM_sRGB            0x0020
 
137
#define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0040
 
138
#define PNG_COLORSPACE_MATCHES_sRGB         0x0080 /* exact match on profile */
 
139
#define PNG_COLORSPACE_INVALID              0x8000
 
140
#define PNG_COLORSPACE_CANCEL(flags)        (0xffff ^ (flags))
 
141
#endif /* COLORSPACE || GAMMA */
 
142
 
 
143
struct png_struct_def
 
144
{
 
145
#ifdef PNG_SETJMP_SUPPORTED
 
146
   jmp_buf jmp_buf_local;     /* New name in 1.6.0 for jmp_buf in png_struct */
 
147
   png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */
 
148
   jmp_buf *jmp_buf_ptr;      /* passed to longjmp_fn */
 
149
   size_t jmp_buf_size;       /* size of the above, if allocated */
 
150
#endif
 
151
   png_error_ptr error_fn;    /* function for printing errors and aborting */
 
152
#ifdef PNG_WARNINGS_SUPPORTED
 
153
   png_error_ptr warning_fn;  /* function for printing warnings */
 
154
#endif
 
155
   png_voidp error_ptr;       /* user supplied struct for error functions */
 
156
   png_rw_ptr write_data_fn;  /* function for writing output data */
 
157
   png_rw_ptr read_data_fn;   /* function for reading input data */
 
158
   png_voidp io_ptr;          /* ptr to application struct for I/O functions */
 
159
 
 
160
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 
161
   png_user_transform_ptr read_user_transform_fn; /* user read transform */
 
162
#endif
 
163
 
 
164
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
 
165
   png_user_transform_ptr write_user_transform_fn; /* user write transform */
 
166
#endif
 
167
 
 
168
/* These were added in libpng-1.0.2 */
 
169
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 
170
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
 
171
    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 
172
   png_voidp user_transform_ptr; /* user supplied struct for user transform */
 
173
   png_byte user_transform_depth;    /* bit depth of user transformed pixels */
 
174
   png_byte user_transform_channels; /* channels in user transformed pixels */
 
175
#endif
 
176
#endif
 
177
 
 
178
   png_uint_32 mode;          /* tells us where we are in the PNG file */
 
179
   png_uint_32 flags;         /* flags indicating various things to libpng */
 
180
   png_uint_32 transformations; /* which transformations to perform */
 
181
 
 
182
   png_uint_32 zowner;        /* ID (chunk type) of zstream owner, 0 if none */
 
183
   z_stream    zstream;       /* decompression structure */
 
184
 
 
185
#ifdef PNG_WRITE_SUPPORTED
 
186
   png_compression_bufferp zbuffer_list; /* Created on demand during write */
 
187
   uInt                    zbuffer_size; /* size of the actual buffer */
 
188
 
 
189
   int zlib_level;            /* holds zlib compression level */
 
190
   int zlib_method;           /* holds zlib compression method */
 
191
   int zlib_window_bits;      /* holds zlib compression window bits */
 
192
   int zlib_mem_level;        /* holds zlib compression memory level */
 
193
   int zlib_strategy;         /* holds zlib compression strategy */
 
194
#endif
 
195
/* Added at libpng 1.5.4 */
 
196
#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
 
197
   int zlib_text_level;            /* holds zlib compression level */
 
198
   int zlib_text_method;           /* holds zlib compression method */
 
199
   int zlib_text_window_bits;      /* holds zlib compression window bits */
 
200
   int zlib_text_mem_level;        /* holds zlib compression memory level */
 
201
   int zlib_text_strategy;         /* holds zlib compression strategy */
 
202
#endif
 
203
/* End of material added at libpng 1.5.4 */
 
204
/* Added at libpng 1.6.0 */
 
205
#ifdef PNG_WRITE_SUPPORTED
 
206
   int zlib_set_level;        /* Actual values set into the zstream on write */
 
207
   int zlib_set_method;
 
208
   int zlib_set_window_bits;
 
209
   int zlib_set_mem_level;
 
210
   int zlib_set_strategy;
 
211
#endif
 
212
 
 
213
   png_uint_32 width;         /* width of image in pixels */
 
214
   png_uint_32 height;        /* height of image in pixels */
 
215
   png_uint_32 num_rows;      /* number of rows in current pass */
 
216
   png_uint_32 usr_width;     /* width of row at start of write */
 
217
   png_size_t rowbytes;       /* size of row in bytes */
 
218
   png_uint_32 iwidth;        /* width of current interlaced row in pixels */
 
219
   png_uint_32 row_number;    /* current row in interlace pass */
 
220
   png_uint_32 chunk_name;    /* PNG_CHUNK() id of current chunk */
 
221
   png_bytep prev_row;        /* buffer to save previous (unfiltered) row.
 
222
                               * While reading this is a pointer into
 
223
                               * big_prev_row; while writing it is separately
 
224
                               * allocated if needed.
 
225
                               */
 
226
   png_bytep row_buf;         /* buffer to save current (unfiltered) row.
 
227
                               * While reading, this is a pointer into
 
228
                               * big_row_buf; while writing it is separately
 
229
                               * allocated.
 
230
                               */
 
231
#ifdef PNG_WRITE_FILTER_SUPPORTED
 
232
   png_bytep try_row;    /* buffer to save trial row when filtering */
 
233
   png_bytep tst_row;    /* buffer to save best trial row when filtering */
 
234
#endif
 
235
   png_size_t info_rowbytes;  /* Added in 1.5.4: cache of updated row bytes */
 
236
 
 
237
   png_uint_32 idat_size;     /* current IDAT size for read */
 
238
   png_uint_32 crc;           /* current chunk CRC value */
 
239
   png_colorp palette;        /* palette from the input file */
 
240
   png_uint_16 num_palette;   /* number of color entries in palette */
 
241
 
 
242
/* Added at libpng-1.5.10 */
 
243
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
 
244
   int num_palette_max;       /* maximum palette index found in IDAT */
 
245
#endif
 
246
 
 
247
   png_uint_16 num_trans;     /* number of transparency values */
 
248
   png_byte compression;      /* file compression type (always 0) */
 
249
   png_byte filter;           /* file filter type (always 0) */
 
250
   png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
 
251
   png_byte pass;             /* current interlace pass (0 - 6) */
 
252
   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */
 
253
   png_byte color_type;       /* color type of file */
 
254
   png_byte bit_depth;        /* bit depth of file */
 
255
   png_byte usr_bit_depth;    /* bit depth of users row: write only */
 
256
   png_byte pixel_depth;      /* number of bits per pixel */
 
257
   png_byte channels;         /* number of channels in file */
 
258
#ifdef PNG_WRITE_SUPPORTED
 
259
   png_byte usr_channels;     /* channels at start of write: write only */
 
260
#endif
 
261
   png_byte sig_bytes;        /* magic bytes read/written from start of file */
 
262
   png_byte maximum_pixel_depth;
 
263
                              /* pixel depth used for the row buffers */
 
264
   png_byte transformed_pixel_depth;
 
265
                              /* pixel depth after read/write transforms */
 
266
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
 
267
   png_uint_16 filler;           /* filler bytes for pixel expansion */
 
268
#endif
 
269
 
 
270
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
 
271
   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
 
272
   png_byte background_gamma_type;
 
273
   png_fixed_point background_gamma;
 
274
   png_color_16 background;   /* background color in screen gamma space */
 
275
#ifdef PNG_READ_GAMMA_SUPPORTED
 
276
   png_color_16 background_1; /* background normalized to gamma 1.0 */
 
277
#endif
 
278
#endif /* bKGD */
 
279
 
 
280
#ifdef PNG_WRITE_FLUSH_SUPPORTED
 
281
   png_flush_ptr output_flush_fn; /* Function for flushing output */
 
282
   png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */
 
283
   png_uint_32 flush_rows;    /* number of rows written since last flush */
 
284
#endif
 
285
 
 
286
#ifdef PNG_READ_GAMMA_SUPPORTED
 
287
   int gamma_shift;      /* number of "insignificant" bits in 16-bit gamma */
 
288
   png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */
 
289
 
 
290
   png_bytep gamma_table;     /* gamma table for 8-bit depth files */
 
291
   png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
 
292
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
 
293
   defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
 
294
   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
 
295
   png_bytep gamma_from_1;    /* converts from 1.0 to screen */
 
296
   png_bytep gamma_to_1;      /* converts from file to 1.0 */
 
297
   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
 
298
   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
 
299
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
 
300
#endif
 
301
 
 
302
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
 
303
   png_color_8 sig_bit;       /* significant bits in each available channel */
 
304
#endif
 
305
 
 
306
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
 
307
   png_color_8 shift;         /* shift for significant bit tranformation */
 
308
#endif
 
309
 
 
310
#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
 
311
 || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
 
312
   png_bytep trans_alpha;           /* alpha values for paletted files */
 
313
   png_color_16 trans_color;  /* transparent color for non-paletted files */
 
314
#endif
 
315
 
 
316
   png_read_status_ptr read_row_fn;   /* called after each row is decoded */
 
317
   png_write_status_ptr write_row_fn; /* called after each row is encoded */
 
318
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 
319
   png_progressive_info_ptr info_fn; /* called after header data fully read */
 
320
   png_progressive_row_ptr row_fn;   /* called after a prog. row is decoded */
 
321
   png_progressive_end_ptr end_fn;   /* called after image is complete */
 
322
   png_bytep save_buffer_ptr;        /* current location in save_buffer */
 
323
   png_bytep save_buffer;            /* buffer for previously read data */
 
324
   png_bytep current_buffer_ptr;     /* current location in current_buffer */
 
325
   png_bytep current_buffer;         /* buffer for recently used data */
 
326
   png_uint_32 push_length;          /* size of current input chunk */
 
327
   png_uint_32 skip_length;          /* bytes to skip in input data */
 
328
   png_size_t save_buffer_size;      /* amount of data now in save_buffer */
 
329
   png_size_t save_buffer_max;       /* total size of save_buffer */
 
330
   png_size_t buffer_size;           /* total amount of available input data */
 
331
   png_size_t current_buffer_size;   /* amount of data now in current_buffer */
 
332
   int process_mode;                 /* what push library is currently doing */
 
333
   int cur_palette;                  /* current push library palette index */
 
334
 
 
335
#endif /* PROGRESSIVE_READ */
 
336
 
 
337
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 
338
/* For the Borland special 64K segment handler */
 
339
   png_bytepp offset_table_ptr;
 
340
   png_bytep offset_table;
 
341
   png_uint_16 offset_table_number;
 
342
   png_uint_16 offset_table_count;
 
343
   png_uint_16 offset_table_count_free;
 
344
#endif
 
345
 
 
346
#ifdef PNG_READ_QUANTIZE_SUPPORTED
 
347
   png_bytep palette_lookup; /* lookup table for quantizing */
 
348
   png_bytep quantize_index; /* index translation for palette files */
 
349
#endif
 
350
 
 
351
/* Options */
 
352
#ifdef PNG_SET_OPTION_SUPPORTED
 
353
   png_byte options;           /* On/off state (up to 4 options) */
 
354
#endif
 
355
 
 
356
#if PNG_LIBPNG_VER < 10700
 
357
/* To do: remove this from libpng-1.7 */
 
358
#ifdef PNG_TIME_RFC1123_SUPPORTED
 
359
   char time_buffer[29]; /* String to hold RFC 1123 time text */
 
360
#endif
 
361
#endif
 
362
 
 
363
/* New members added in libpng-1.0.6 */
 
364
 
 
365
   png_uint_32 free_me;    /* flags items libpng is responsible for freeing */
 
366
 
 
367
#ifdef PNG_USER_CHUNKS_SUPPORTED
 
368
   png_voidp user_chunk_ptr;
 
369
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
 
370
   png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
 
371
#endif
 
372
#endif
 
373
 
 
374
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
 
375
   int          unknown_default; /* As PNG_HANDLE_* */
 
376
   unsigned int num_chunk_list;  /* Number of entries in the list */
 
377
   png_bytep    chunk_list;      /* List of png_byte[5]; the textual chunk name
 
378
                                  * followed by a PNG_HANDLE_* byte */
 
379
#endif
 
380
 
 
381
/* New members added in libpng-1.0.3 */
 
382
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 
383
   png_byte rgb_to_gray_status;
 
384
   /* Added in libpng 1.5.5 to record setting of coefficients: */
 
385
   png_byte rgb_to_gray_coefficients_set;
 
386
   /* These were changed from png_byte in libpng-1.0.6 */
 
387
   png_uint_16 rgb_to_gray_red_coeff;
 
388
   png_uint_16 rgb_to_gray_green_coeff;
 
389
   /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */
 
390
#endif
 
391
 
 
392
/* New member added in libpng-1.0.4 (renamed in 1.0.9) */
 
393
#if defined(PNG_MNG_FEATURES_SUPPORTED)
 
394
/* Changed from png_byte to png_uint_32 at version 1.2.0 */
 
395
   png_uint_32 mng_features_permitted;
 
396
#endif
 
397
 
 
398
/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */
 
399
#ifdef PNG_MNG_FEATURES_SUPPORTED
 
400
   png_byte filter_type;
 
401
#endif
 
402
 
 
403
/* New members added in libpng-1.2.0 */
 
404
 
 
405
/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */
 
406
#ifdef PNG_USER_MEM_SUPPORTED
 
407
   png_voidp mem_ptr;             /* user supplied struct for mem functions */
 
408
   png_malloc_ptr malloc_fn;      /* function for allocating memory */
 
409
   png_free_ptr free_fn;          /* function for freeing memory */
 
410
#endif
 
411
 
 
412
/* New member added in libpng-1.0.13 and 1.2.0 */
 
413
   png_bytep big_row_buf;         /* buffer to save current (unfiltered) row */
 
414
 
 
415
#ifdef PNG_READ_QUANTIZE_SUPPORTED
 
416
/* The following three members were added at version 1.0.14 and 1.2.4 */
 
417
   png_bytep quantize_sort;          /* working sort array */
 
418
   png_bytep index_to_palette;       /* where the original index currently is
 
419
                                        in the palette */
 
420
   png_bytep palette_to_index;       /* which original index points to this
 
421
                                         palette color */
 
422
#endif
 
423
 
 
424
/* New members added in libpng-1.0.16 and 1.2.6 */
 
425
   png_byte compression_type;
 
426
 
 
427
#ifdef PNG_USER_LIMITS_SUPPORTED
 
428
   png_uint_32 user_width_max;
 
429
   png_uint_32 user_height_max;
 
430
 
 
431
   /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown
 
432
    * chunks that can be stored (0 means unlimited).
 
433
    */
 
434
   png_uint_32 user_chunk_cache_max;
 
435
 
 
436
   /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk
 
437
    * can occupy when decompressed.  0 means unlimited.
 
438
    */
 
439
   png_alloc_size_t user_chunk_malloc_max;
 
440
#endif
 
441
 
 
442
/* New member added in libpng-1.0.25 and 1.2.17 */
 
443
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
 
444
   /* Temporary storage for unknown chunk that the library doesn't recognize,
 
445
    * used while reading the chunk.
 
446
    */
 
447
   png_unknown_chunk unknown_chunk;
 
448
#endif
 
449
 
 
450
/* New member added in libpng-1.2.26 */
 
451
  png_size_t old_big_row_buf_size;
 
452
 
 
453
#ifdef PNG_READ_SUPPORTED
 
454
/* New member added in libpng-1.2.30 */
 
455
  png_bytep        read_buffer;      /* buffer for reading chunk data */
 
456
  png_alloc_size_t read_buffer_size; /* current size of the buffer */
 
457
#endif
 
458
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 
459
  uInt             IDAT_read_size;   /* limit on read buffer size for IDAT */
 
460
#endif
 
461
 
 
462
#ifdef PNG_IO_STATE_SUPPORTED
 
463
/* New member added in libpng-1.4.0 */
 
464
   png_uint_32 io_state;
 
465
#endif
 
466
 
 
467
/* New member added in libpng-1.5.6 */
 
468
   png_bytep big_prev_row;
 
469
 
 
470
/* New member added in libpng-1.5.7 */
 
471
   void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info,
 
472
      png_bytep row, png_const_bytep prev_row);
 
473
 
 
474
#ifdef PNG_READ_SUPPORTED
 
475
#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
 
476
   png_colorspace   colorspace;
 
477
#endif
 
478
#endif
 
479
};
 
480
#endif /* PNGSTRUCT_H */