zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
pngerror.c
Go to the documentation of this file.
1 
2 /* pngerror.c - stub functions for i/o and memory allocation
3  *
4  * Last changed in libpng 1.5.8 [February 1, 2011]
5  * Copyright (c) 1998-2012 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  * This file provides a location for all error handling. Users who
14  * need special error handling are expected to write replacement functions
15  * and use png_set_error_fn() to use those functions. See the instructions
16  * at each function.
17  */
18 
19 #include "pngpriv.h"
20 
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
22 
23 static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
24  png_const_charp error_message)),PNG_NORETURN);
25 
26 #ifdef PNG_WARNINGS_SUPPORTED
27 static void /* PRIVATE */
29  png_const_charp warning_message));
30 #endif /* PNG_WARNINGS_SUPPORTED */
31 
32 /* This function is called whenever there is a fatal error. This function
33  * should not be changed. If there is a need to handle errors differently,
34  * you should supply a replacement error function and use png_set_error_fn()
35  * to replace the error function at run-time.
36  */
37 #ifdef PNG_ERROR_TEXT_SUPPORTED
39 png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN)
40 {
41 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
42  char msg[16];
43  if (png_ptr != NULL)
44  {
45  if (png_ptr->flags&
47  {
48  if (*error_message == PNG_LITERAL_SHARP)
49  {
50  /* Strip "#nnnn " from beginning of error message. */
51  int offset;
52  for (offset = 1; offset<15; offset++)
53  if (error_message[offset] == ' ')
54  break;
55 
56  if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
57  {
58  int i;
59  for (i = 0; i < offset - 1; i++)
60  msg[i] = error_message[i + 1];
61  msg[i - 1] = '\0';
62  error_message = msg;
63  }
64 
65  else
66  error_message += offset;
67  }
68 
69  else
70  {
71  if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
72  {
73  msg[0] = '0';
74  msg[1] = '\0';
75  error_message = msg;
76  }
77  }
78  }
79  }
80 #endif
81  if (png_ptr != NULL && png_ptr->error_fn != NULL)
82  (*(png_ptr->error_fn))(png_ptr, error_message);
83 
84  /* If the custom handler doesn't exist, or if it returns,
85  use the default handler, which will not return. */
86  png_default_error(png_ptr, error_message);
87 }
88 #else
90 png_err,(png_structp png_ptr),PNG_NORETURN)
91 {
92  /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
93  * erroneously as '\0', instead of the empty string "". This was
94  * apparently an error, introduced in libpng-1.2.20, and png_default_error
95  * will crash in this case.
96  */
97  if (png_ptr != NULL && png_ptr->error_fn != NULL)
98  (*(png_ptr->error_fn))(png_ptr, "");
99 
100  /* If the custom handler doesn't exist, or if it returns,
101  use the default handler, which will not return. */
102  png_default_error(png_ptr, "");
103 }
104 #endif /* PNG_ERROR_TEXT_SUPPORTED */
105 
106 /* Utility to safely appends strings to a buffer. This never errors out so
107  * error checking is not required in the caller.
108  */
109 size_t
110 png_safecat(png_charp buffer, size_t bufsize, size_t pos,
111  png_const_charp string)
112 {
113  if (buffer != NULL && pos < bufsize)
114  {
115  if (string != NULL)
116  while (*string != '\0' && pos < bufsize-1)
117  buffer[pos++] = *string++;
118 
119  buffer[pos] = '\0';
120  }
121 
122  return pos;
123 }
124 
125 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
126 /* Utility to dump an unsigned value into a buffer, given a start pointer and
127  * and end pointer (which should point just *beyond* the end of the buffer!)
128  * Returns the pointer to the start of the formatted string.
129  */
130 png_charp
132  png_alloc_size_t number)
133 {
134  int count = 0; /* number of digits output */
135  int mincount = 1; /* minimum number required */
136  int output = 0; /* digit output (for the fixed point format) */
137 
138  *--end = '\0';
139 
140  /* This is written so that the loop always runs at least once, even with
141  * number zero.
142  */
143  while (end > start && (number != 0 || count < mincount))
144  {
145 
146  static const char digits[] = "0123456789ABCDEF";
147 
148  switch (format)
149  {
151  /* Needs five digits (the fraction) */
152  mincount = 5;
153  if (output || number % 10 != 0)
154  {
155  *--end = digits[number % 10];
156  output = 1;
157  }
158  number /= 10;
159  break;
160 
162  /* Expects at least 2 digits. */
163  mincount = 2;
164  /* fall through */
165 
166  case PNG_NUMBER_FORMAT_u:
167  *--end = digits[number % 10];
168  number /= 10;
169  break;
170 
172  /* This format expects at least two digits */
173  mincount = 2;
174  /* fall through */
175 
176  case PNG_NUMBER_FORMAT_x:
177  *--end = digits[number & 0xf];
178  number >>= 4;
179  break;
180 
181  default: /* an error */
182  number = 0;
183  break;
184  }
185 
186  /* Keep track of the number of digits added */
187  ++count;
188 
189  /* Float a fixed number here: */
190  if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)
191  {
192  /* End of the fraction, but maybe nothing was output? In that case
193  * drop the decimal point. If the number is a true zero handle that
194  * here.
195  */
196  if (output)
197  *--end = '.';
198  else if (number == 0) /* and !output */
199  *--end = '0';
200  }
201  }
202 
203  return end;
204 }
205 #endif
206 
207 #ifdef PNG_WARNINGS_SUPPORTED
208 /* This function is called whenever there is a non-fatal error. This function
209  * should not be changed. If there is a need to handle warnings differently,
210  * you should supply a replacement warning function and use
211  * png_set_error_fn() to replace the warning function at run-time.
212  */
213 void PNGAPI
214 png_warning(png_structp png_ptr, png_const_charp warning_message)
215 {
216  int offset = 0;
217  if (png_ptr != NULL)
218  {
219 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
220  if (png_ptr->flags&
222 #endif
223  {
224  if (*warning_message == PNG_LITERAL_SHARP)
225  {
226  for (offset = 1; offset < 15; offset++)
227  if (warning_message[offset] == ' ')
228  break;
229  }
230  }
231  }
232  if (png_ptr != NULL && png_ptr->warning_fn != NULL)
233  (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
234  else
235  png_default_warning(png_ptr, warning_message + offset);
236 }
237 
238 /* These functions support 'formatted' warning messages with up to
239  * PNG_WARNING_PARAMETER_COUNT parameters. In the format string the parameter
240  * is introduced by @<number>, where 'number' starts at 1. This follows the
241  * standard established by X/Open for internationalizable error messages.
242  */
243 void
245  png_const_charp string)
246 {
247  if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
248  (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
249 }
250 
251 void
254 {
256  png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
257 }
258 
259 void
262 {
264  png_charp str;
266 
267  /* Avoid overflow by doing the negate in a png_alloc_size_t: */
268  u = (png_alloc_size_t)value;
269  if (value < 0)
270  u = ~u + 1;
271 
272  str = PNG_FORMAT_NUMBER(buffer, format, u);
273 
274  if (value < 0 && str > buffer)
275  *--str = '-';
276 
277  png_warning_parameter(p, number, str);
278 }
279 
280 void
283 {
284  /* The internal buffer is just 192 bytes - enough for all our messages,
285  * overflow doesn't happen because this code checks! If someone figures
286  * out how to send us a message longer than 192 bytes, all that will
287  * happen is that the message will be truncated appropriately.
288  */
289  size_t i = 0; /* Index in the msg[] buffer: */
290  char msg[192];
291 
292  /* Each iteration through the following loop writes at most one character
293  * to msg[i++] then returns here to validate that there is still space for
294  * the trailing '\0'. It may (in the case of a parameter) read more than
295  * one character from message[]; it must check for '\0' and continue to the
296  * test if it finds the end of string.
297  */
298  while (i<(sizeof msg)-1 && *message != '\0')
299  {
300  /* '@' at end of string is now just printed (previously it was skipped);
301  * it is an error in the calling code to terminate the string with @.
302  */
303  if (p != NULL && *message == '@' && message[1] != '\0')
304  {
305  int parameter_char = *++message; /* Consume the '@' */
306  static const char valid_parameters[] = "123456789";
307  int parameter = 0;
308 
309  /* Search for the parameter digit, the index in the string is the
310  * parameter to use.
311  */
312  while (valid_parameters[parameter] != parameter_char &&
313  valid_parameters[parameter] != '\0')
314  ++parameter;
315 
316  /* If the parameter digit is out of range it will just get printed. */
317  if (parameter < PNG_WARNING_PARAMETER_COUNT)
318  {
319  /* Append this parameter */
320  png_const_charp parm = p[parameter];
321  png_const_charp pend = p[parameter] + (sizeof p[parameter]);
322 
323  /* No need to copy the trailing '\0' here, but there is no guarantee
324  * that parm[] has been initialized, so there is no guarantee of a
325  * trailing '\0':
326  */
327  while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)
328  msg[i++] = *parm++;
329 
330  /* Consume the parameter digit too: */
331  ++message;
332  continue;
333  }
334 
335  /* else not a parameter and there is a character after the @ sign; just
336  * copy that. This is known not to be '\0' because of the test above.
337  */
338  }
339 
340  /* At this point *message can't be '\0', even in the bad parameter case
341  * above where there is a lone '@' at the end of the message string.
342  */
343  msg[i++] = *message++;
344  }
345 
346  /* i is always less than (sizeof msg), so: */
347  msg[i] = '\0';
348 
349  /* And this is the formatted message, it may be larger than
350  * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these are
351  * not (currently) formatted.
352  */
353  png_warning(png_ptr, msg);
354 }
355 #endif /* PNG_WARNINGS_SUPPORTED */
356 
357 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
358 void PNGAPI
360 {
361  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
362  png_warning(png_ptr, error_message);
363  else
364  png_error(png_ptr, error_message);
365 }
366 #endif
367 
368 /* These utilities are used internally to build an error message that relates
369  * to the current chunk. The chunk name comes from png_ptr->chunk_name,
370  * this is used to prefix the message. The message is limited in length
371  * to 63 bytes, the name characters are output as hex digits wrapped in []
372  * if the character is invalid.
373  */
374 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
375 static PNG_CONST char png_digit[16] = {
376  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
377  'A', 'B', 'C', 'D', 'E', 'F'
378 };
379 
380 #define PNG_MAX_ERROR_TEXT 64
381 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
382 static void /* PRIVATE */
384  error_message)
385 {
386  png_uint_32 chunk_name = png_ptr->chunk_name;
387  int iout = 0, ishift = 24;
388 
389  while (ishift >= 0)
390  {
391  int c = (int)(chunk_name >> ishift) & 0xff;
392 
393  ishift -= 8;
394  if (isnonalpha(c))
395  {
396  buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
397  buffer[iout++] = png_digit[(c & 0xf0) >> 4];
398  buffer[iout++] = png_digit[c & 0x0f];
399  buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
400  }
401 
402  else
403  {
404  buffer[iout++] = (char)c;
405  }
406  }
407 
408  if (error_message == NULL)
409  buffer[iout] = '\0';
410 
411  else
412  {
413  int iin = 0;
414 
415  buffer[iout++] = ':';
416  buffer[iout++] = ' ';
417 
418  while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
419  buffer[iout++] = error_message[iin++];
420 
421  /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
422  buffer[iout] = '\0';
423  }
424 }
425 #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
426 
427 #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
428 PNG_FUNCTION(void,PNGAPI
429 png_chunk_error,(png_structp png_ptr, png_const_charp error_message),
430  PNG_NORETURN)
431 {
432  char msg[18+PNG_MAX_ERROR_TEXT];
433  if (png_ptr == NULL)
434  png_error(png_ptr, error_message);
435 
436  else
437  {
438  png_format_buffer(png_ptr, msg, error_message);
439  png_error(png_ptr, msg);
440  }
441 }
442 #endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
443 
444 #ifdef PNG_WARNINGS_SUPPORTED
445 void PNGAPI
447 {
448  char msg[18+PNG_MAX_ERROR_TEXT];
449  if (png_ptr == NULL)
450  png_warning(png_ptr, warning_message);
451 
452  else
453  {
454  png_format_buffer(png_ptr, msg, warning_message);
455  png_warning(png_ptr, msg);
456  }
457 }
458 #endif /* PNG_WARNINGS_SUPPORTED */
459 
460 #ifdef PNG_READ_SUPPORTED
461 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
462 void PNGAPI
464 {
465  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
466  png_chunk_warning(png_ptr, error_message);
467 
468  else
469  png_chunk_error(png_ptr, error_message);
470 }
471 #endif
472 #endif /* PNG_READ_SUPPORTED */
473 
474 #ifdef PNG_ERROR_TEXT_SUPPORTED
475 #ifdef PNG_FLOATING_POINT_SUPPORTED
477 png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN)
478 {
479 # define fixed_message "fixed point overflow in "
480 # define fixed_message_ln ((sizeof fixed_message)-1)
481  int iin;
484  iin = 0;
485  if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
486  {
487  msg[fixed_message_ln + iin] = name[iin];
488  ++iin;
489  }
490  msg[fixed_message_ln + iin] = 0;
491  png_error(png_ptr, msg);
492 }
493 #endif
494 #endif
495 
496 #ifdef PNG_SETJMP_SUPPORTED
497 /* This API only exists if ANSI-C style error handling is used,
498  * otherwise it is necessary for png_default_error to be overridden.
499  */
500 jmp_buf* PNGAPI
501 png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
502  size_t jmp_buf_size)
503 {
504  if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
505  return NULL;
506 
507  png_ptr->longjmp_fn = longjmp_fn;
508  return &png_ptr->longjmp_buffer;
509 }
510 #endif
511 
512 /* This is the default error handling function. Note that replacements for
513  * this function MUST NOT RETURN, or the program will likely crash. This
514  * function is used by default, or if the program supplies NULL for the
515  * error function pointer in png_set_error_fn().
516  */
517 static PNG_FUNCTION(void /* PRIVATE */,
518 png_default_error,(png_structp png_ptr, png_const_charp error_message),
519  PNG_NORETURN)
520 {
521 #ifdef PNG_CONSOLE_IO_SUPPORTED
522 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
523  /* Check on NULL only added in 1.5.4 */
524  if (error_message != NULL && *error_message == PNG_LITERAL_SHARP)
525  {
526  /* Strip "#nnnn " from beginning of error message. */
527  int offset;
528  char error_number[16];
529  for (offset = 0; offset<15; offset++)
530  {
531  error_number[offset] = error_message[offset + 1];
532  if (error_message[offset] == ' ')
533  break;
534  }
535 
536  if ((offset > 1) && (offset < 15))
537  {
538  error_number[offset - 1] = '\0';
539  fprintf(stderr, "libpng error no. %s: %s",
540  error_number, error_message + offset + 1);
541  fprintf(stderr, PNG_STRING_NEWLINE);
542  }
543 
544  else
545  {
546  fprintf(stderr, "libpng error: %s, offset=%d",
547  error_message, offset);
548  fprintf(stderr, PNG_STRING_NEWLINE);
549  }
550  }
551  else
552 #endif
553  {
554  fprintf(stderr, "libpng error: %s", error_message ? error_message :
555  "undefined");
556  fprintf(stderr, PNG_STRING_NEWLINE);
557  }
558 #else
559  PNG_UNUSED(error_message) /* Make compiler happy */
560 #endif
561  png_longjmp(png_ptr, 1);
562 }
563 
565 png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
566 {
567 #ifdef PNG_SETJMP_SUPPORTED
568  if (png_ptr && png_ptr->longjmp_fn)
569  {
570 # ifdef USE_FAR_KEYWORD
571  {
572  jmp_buf tmp_jmpbuf;
573  png_memcpy(tmp_jmpbuf, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
574  png_ptr->longjmp_fn(tmp_jmpbuf, val);
575  }
576 
577 # else
578  png_ptr->longjmp_fn(png_ptr->longjmp_buffer, val);
579 # endif
580  }
581 #endif
582  /* Here if not setjmp support or if png_ptr is null. */
583  PNG_ABORT();
584 }
585 
586 #ifdef PNG_WARNINGS_SUPPORTED
587 /* This function is called when there is a warning, but the library thinks
588  * it can continue anyway. Replacement functions don't have to do anything
589  * here if you don't want them to. In the default configuration, png_ptr is
590  * not used, but it is passed in case it may be useful.
591  */
592 static void /* PRIVATE */
594 {
595 #ifdef PNG_CONSOLE_IO_SUPPORTED
596 # ifdef PNG_ERROR_NUMBERS_SUPPORTED
597  if (*warning_message == PNG_LITERAL_SHARP)
598  {
599  int offset;
600  char warning_number[16];
601  for (offset = 0; offset < 15; offset++)
602  {
603  warning_number[offset] = warning_message[offset + 1];
604  if (warning_message[offset] == ' ')
605  break;
606  }
607 
608  if ((offset > 1) && (offset < 15))
609  {
610  warning_number[offset + 1] = '\0';
611  fprintf(stderr, "libpng warning no. %s: %s",
612  warning_number, warning_message + offset);
613  fprintf(stderr, PNG_STRING_NEWLINE);
614  }
615 
616  else
617  {
618  fprintf(stderr, "libpng warning: %s",
619  warning_message);
620  fprintf(stderr, PNG_STRING_NEWLINE);
621  }
622  }
623  else
624 # endif
625 
626  {
627  fprintf(stderr, "libpng warning: %s", warning_message);
628  fprintf(stderr, PNG_STRING_NEWLINE);
629  }
630 #else
631  PNG_UNUSED(warning_message) /* Make compiler happy */
632 #endif
633  PNG_UNUSED(png_ptr) /* Make compiler happy */
634 }
635 #endif /* PNG_WARNINGS_SUPPORTED */
636 
637 /* This function is called when the application wants to use another method
638  * of handling errors and warnings. Note that the error function MUST NOT
639  * return to the calling routine or serious problems will occur. The return
640  * method used in the default routine calls longjmp(png_ptr->longjmp_buffer, 1)
641  */
642 void PNGAPI
644  png_error_ptr error_fn, png_error_ptr warning_fn)
645 {
646  if (png_ptr == NULL)
647  return;
648 
649  png_ptr->error_ptr = error_ptr;
650  png_ptr->error_fn = error_fn;
651 #ifdef PNG_WARNINGS_SUPPORTED
652  png_ptr->warning_fn = warning_fn;
653 #else
654  PNG_UNUSED(warning_fn)
655 #endif
656 }
657 
658 
659 /* This function returns a pointer to the error_ptr associated with the user
660  * functions. The application should free any memory associated with this
661  * pointer before png_write_destroy and png_read_destroy are called.
662  */
665 {
666  if (png_ptr == NULL)
667  return NULL;
668 
669  return ((png_voidp)png_ptr->error_ptr);
670 }
671 
672 
673 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
674 void PNGAPI
675 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
676 {
677  if (png_ptr != NULL)
678  {
679  png_ptr->flags &=
681  PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
682  }
683 }
684 #endif
685 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
GLuint const GLfloat * val
Definition: glew.h:2715
png_error_ptr error_fn
Definition: pngstruct.h:35
#define png_memcpy
Definition: pngpriv.h:353
static PNG_CONST char png_digit[16]
Definition: pngerror.c:375
#define PNG_FLAG_STRIP_ERROR_TEXT
Definition: pngpriv.h:491
#define PNG_NORETURN
Definition: pngconf.h:392
GLvoid **typedef void(GLAPIENTRY *PFNGLGETVERTEXATTRIBDVPROC)(GLuint
Definition: glew.h:1824
#define PNG_FLAG_STRIP_ERROR_NUMBERS
Definition: pngpriv.h:490
#define PNG_UNUSED(param)
Definition: pngpriv.h:181
GLsizei GLenum GLuint GLuint GLsizei GLchar * message
Definition: glew.h:2540
void png_warning_parameter(png_warning_parameters p, int number, png_const_charp string)
Definition: pngerror.c:244
char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][PNG_WARNING_PARAMETER_SIZE]
Definition: pngpriv.h:1422
#define NULL
Definition: ftobjs.h:61
#define fixed_message_ln
png_voidp error_ptr
Definition: pngstruct.h:39
GLuint start
Definition: glew.h:1239
PNG_CONST png_struct FAR * png_const_structp
Definition: png.h:848
#define fixed_message
void PNGAPI png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:446
#define PNG_FORMAT_NUMBER(buffer, format, number)
Definition: pngpriv.h:1395
static void png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp error_message)
Definition: pngerror.c:383
char FAR * png_charp
Definition: pngconf.h:536
#define isnonalpha(c)
Definition: pngerror.c:374
png_error(png_ptr,"Missing IHDR before iCCP")
int png_int_32
Definition: pngconf.h:442
#define PNG_ABORT()
Definition: pngpriv.h:326
#define PNG_LITERAL_RIGHT_SQUARE_BRACKET
Definition: pngdebug.h:46
unsigned int png_uint_32
Definition: pngconf.h:441
#define PNG_LITERAL_SHARP
Definition: pngdebug.h:40
EGLImageKHR EGLint * name
Definition: eglext.h:284
PNG_CONST char FAR * png_const_charp
Definition: pngconf.h:537
png_charp png_format_number(png_const_charp start, png_charp end, int format, png_alloc_size_t number)
Definition: pngerror.c:131
#define PNG_NUMBER_FORMAT_02x
Definition: pngpriv.h:1409
png_voidp PNGAPI png_get_error_ptr(png_const_structp png_ptr)
Definition: pngerror.c:664
#define PNG_WARNING_PARAMETER_COUNT
Definition: pngpriv.h:1416
#define PNG_NUMBER_FORMAT_02u
Definition: pngpriv.h:1405
void PNGAPI png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
Definition: pngerror.c:463
size_t png_safecat(png_charp buffer, size_t bufsize, size_t pos, png_const_charp string)
Definition: pngerror.c:110
png_size_t png_alloc_size_t
Definition: pngconf.h:591
#define PNGARG(arglist)
Definition: pngconf.h:91
png_uint_32 chunk_name
Definition: pngstruct.h:107
EGLContext EGLenum EGLClientBuffer buffer
Definition: eglext.h:87
#define PNG_NUMBER_BUFFER_SIZE
Definition: pngpriv.h:1399
#define PNG_NUMBER_FORMAT_u
Definition: pngpriv.h:1404
#define PNGAPI
Definition: pngconf.h:260
png_struct FAR * png_structp
Definition: png.h:849
ALuint u
Definition: alMain.h:58
void png_warning_parameter_signed(png_warning_parameters p, int number, int format, png_int_32 value)
Definition: pngerror.c:260
#define PNG_CONST
Definition: pngconf.h:426
int
Definition: SDL_systhread.c:37
GLint GLsizei count
Definition: gl2ext.h:1011
GLfloat GLfloat p
Definition: glew.h:14938
void PNGAPI png_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:214
const GLfloat * c
Definition: glew.h:14913
#define PNG_FLAG_BENIGN_ERRORS_WARN
Definition: pngpriv.h:495
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl2ext.h:845
#define PNG_STRING_NEWLINE
Definition: pngdebug.h:49
static void png_default_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:593
EGLSurface EGLint void ** value
Definition: eglext.h:301
GLintptr offset
Definition: glew.h:1668
#define PNG_LITERAL_LEFT_SQUARE_BRACKET
Definition: pngdebug.h:43
GLsizei const GLcharARB ** string
Definition: glew.h:5638
void FAR * png_voidp
Definition: pngconf.h:524
GLuint GLuint end
Definition: glew.h:1239
#define PNG_FUNCTION(type, name, args, attributes)
Definition: pngconf.h:286
jmp_buf *PNGAPI png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)
Definition: pngerror.c:501
#define str(s)
int i
Definition: pngrutil.c:1377
GLsizei bufsize
Definition: gl2ext.h:994
#define PNG_NUMBER_FORMAT_x
Definition: pngpriv.h:1408
#define PNG_NUMBER_FORMAT_fixed
Definition: pngpriv.h:1410
void PNGAPI png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)
Definition: pngerror.c:643
void png_formatted_warning(png_structp png_ptr, png_warning_parameters p, png_const_charp message)
Definition: pngerror.c:281
void png_warning_parameter_unsigned(png_warning_parameters p, int number, int format, png_alloc_size_t value)
Definition: pngerror.c:252
#define PNG_MAX_ERROR_TEXT
Definition: pngerror.c:380
void PNGAPI png_benign_error(png_structp png_ptr, png_const_charp error_message)
Definition: pngerror.c:359
#define png_sizeof(x)
Definition: pngconf.h:456