The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-24 15:01:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update libpng to 1.2.50 so it can be built with Clang 3.2

Browse Source
This commit is contained in:
Ryan Houdek 2013-04-18 22:11:07 -05:00
parent 3a6492d3a9
commit 75efe7d315
21 changed files with 28314 additions and 26152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
Externals/libpng/CMakeLists.txt vendored
View File

@ -1,19 +1,21 @@
set(SRCS # OUR SOURCES
"png.c" set(SRCS
"pngerror.c" png.h
"pngget.c" pngconf.h
"pngmem.c" png.c
"pngpread.c" pngerror.c
"pngread.c" pngget.c
"pngrio.c" pngmem.c
"pngrtran.c" pngpread.c
"pngrutil.c" pngread.c
"pngset.c" pngrio.c
"pngtrans.c" pngrtran.c
"pngwio.c" pngrutil.c
"pngwrite.c" pngset.c
"pngwtran.c" pngtrans.c
"pngwutil.c" pngwio.c
) pngwrite.c
pngwtran.c
add_library(png STATIC ${SRCS}) pngwutil.c
)
add_library(png STATIC ${SRCS})

3462
Externals/libpng/png.c vendored
View File

File diff suppressed because it is too large Load Diff

6090
Externals/libpng/png.h vendored
View File

File diff suppressed because it is too large Load Diff

2297
Externals/libpng/pngconf.h vendored
View File

File diff suppressed because it is too large Load Diff

843
Externals/libpng/pngerror.c vendored
View File

@ -1,447 +1,396 @@
/* pngerror.c - stub functions for i/o and memory allocation /* pngerror.c - stub functions for i/o and memory allocation
* *
* Last changed in libpng 1.5.1 [February 3, 2011] * Last changed in libpng 1.2.45 [July 7, 2011]
* Copyright (c) 1998-2011 Glenn Randers-Pehrson * Copyright (c) 1998-2011 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer * For conditions of distribution and use, see the disclaimer
* and license in png.h * and license in png.h
* *
* This file provides a location for all error handling. Users who * This file provides a location for all error handling. Users who
* need special error handling are expected to write replacement functions * need special error handling are expected to write replacement functions
* and use png_set_error_fn() to use those functions. See the instructions * and use png_set_error_fn() to use those functions. See the instructions
* at each function. * at each function.
*/ */
#include "pngpriv.h" #define PNG_INTERNAL
#define PNG_NO_PEDANTIC_WARNINGS
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) #include "png.h"
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
png_const_charp error_message)),PNG_NORETURN); static void /* PRIVATE */
png_default_error PNGARG((png_structp png_ptr,
#ifdef PNG_WARNINGS_SUPPORTED png_const_charp error_message)) PNG_NORETURN;
static void /* PRIVATE */ #ifdef PNG_WARNINGS_SUPPORTED
png_default_warning PNGARG((png_structp png_ptr, static void /* PRIVATE */
png_const_charp warning_message)); png_default_warning PNGARG((png_structp png_ptr,
#endif /* PNG_WARNINGS_SUPPORTED */ png_const_charp warning_message));
#endif /* PNG_WARNINGS_SUPPORTED */
/* This function is called whenever there is a fatal error. This function
* should not be changed. If there is a need to handle errors differently, /* This function is called whenever there is a fatal error. This function
* you should supply a replacement error function and use png_set_error_fn() * should not be changed. If there is a need to handle errors differently,
* to replace the error function at run-time. * you should supply a replacement error function and use png_set_error_fn()
*/ * to replace the error function at run-time.
#ifdef PNG_ERROR_TEXT_SUPPORTED */
PNG_FUNCTION(void,PNGAPI #ifdef PNG_ERROR_TEXT_SUPPORTED
png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN) void PNGAPI
{ png_error(png_structp png_ptr, png_const_charp error_message)
#ifdef PNG_ERROR_NUMBERS_SUPPORTED {
char msg[16]; #ifdef PNG_ERROR_NUMBERS_SUPPORTED
if (png_ptr != NULL) char msg[16];
{ if (png_ptr != NULL)
if (png_ptr->flags& {
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) if (png_ptr->flags&
{ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
if (*error_message == PNG_LITERAL_SHARP) {
{ if (*error_message == PNG_LITERAL_SHARP)
/* Strip "#nnnn " from beginning of error message. */ {
int offset; /* Strip "#nnnn " from beginning of error message. */
for (offset = 1; offset<15; offset++) int offset;
if (error_message[offset] == ' ') for (offset = 1; offset<15; offset++)
break; if (error_message[offset] == ' ')
break;
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
{ {
int i; int i;
for (i = 0; i < offset - 1; i++) for (i = 0; i < offset - 1; i++)
msg[i] = error_message[i + 1]; msg[i] = error_message[i + 1];
msg[i - 1] = '\0'; msg[i - 1] = '\0';
error_message = msg; error_message = msg;
} }
else
else error_message += offset;
error_message += offset; }
} else
{
else if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
{ {
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) msg[0] = '0';
{ msg[1] = '\0';
msg[0] = '0'; error_message = msg;
msg[1] = '\0'; }
error_message = msg; }
} }
} }
} #endif
} if (png_ptr != NULL && png_ptr->error_fn != NULL)
#endif (*(png_ptr->error_fn))(png_ptr, error_message);
if (png_ptr != NULL && png_ptr->error_fn != NULL)
(*(png_ptr->error_fn))(png_ptr, error_message); /* If the custom handler doesn't exist, or if it returns,
use the default handler, which will not return. */
/* If the custom handler doesn't exist, or if it returns, png_default_error(png_ptr, error_message);
use the default handler, which will not return. */ }
png_default_error(png_ptr, error_message); #else
} void PNGAPI
#else png_err(png_structp png_ptr)
PNG_FUNCTION(void,PNGAPI {
png_err,(png_structp png_ptr),PNG_NORETURN) /* Prior to 1.2.45 the error_fn received a NULL pointer, expressed
{ * erroneously as '\0', instead of the empty string "". This was
if (png_ptr != NULL && png_ptr->error_fn != NULL) * apparently an error, introduced in libpng-1.2.20, and png_default_error
(*(png_ptr->error_fn))(png_ptr, '\0'); * will crash in this case.
*/
/* If the custom handler doesn't exist, or if it returns, if (png_ptr != NULL && png_ptr->error_fn != NULL)
use the default handler, which will not return. */ (*(png_ptr->error_fn))(png_ptr, "");
png_default_error(png_ptr, '\0');
} /* If the custom handler doesn't exist, or if it returns,
#endif /* PNG_ERROR_TEXT_SUPPORTED */ use the default handler, which will not return. */
png_default_error(png_ptr, "");
#ifdef PNG_WARNINGS_SUPPORTED }
/* This function is called whenever there is a non-fatal error. This function #endif /* PNG_ERROR_TEXT_SUPPORTED */
* should not be changed. If there is a need to handle warnings differently,
* you should supply a replacement warning function and use #ifdef PNG_WARNINGS_SUPPORTED
* png_set_error_fn() to replace the warning function at run-time. /* This function is called whenever there is a non-fatal error. This function
*/ * should not be changed. If there is a need to handle warnings differently,
void PNGAPI * you should supply a replacement warning function and use
png_warning(png_structp png_ptr, png_const_charp warning_message) * png_set_error_fn() to replace the warning function at run-time.
{ */
int offset = 0; void PNGAPI
if (png_ptr != NULL) png_warning(png_structp png_ptr, png_const_charp warning_message)
{ {
#ifdef PNG_ERROR_NUMBERS_SUPPORTED int offset = 0;
if (png_ptr->flags& if (png_ptr != NULL)
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) {
#endif #ifdef PNG_ERROR_NUMBERS_SUPPORTED
{ if (png_ptr->flags&
if (*warning_message == PNG_LITERAL_SHARP) (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
{ #endif
for (offset = 1; offset < 15; offset++) {
if (warning_message[offset] == ' ') if (*warning_message == PNG_LITERAL_SHARP)
break; {
} for (offset = 1; offset < 15; offset++)
} if (warning_message[offset] == ' ')
} break;
if (png_ptr != NULL && png_ptr->warning_fn != NULL) }
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset); }
else }
png_default_warning(png_ptr, warning_message + offset); if (png_ptr != NULL && png_ptr->warning_fn != NULL)
} (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
#endif /* PNG_WARNINGS_SUPPORTED */ else
png_default_warning(png_ptr, warning_message + offset);
#ifdef PNG_BENIGN_ERRORS_SUPPORTED }
void PNGAPI #endif /* PNG_WARNINGS_SUPPORTED */
png_benign_error(png_structp png_ptr, png_const_charp error_message)
{ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) void PNGAPI
png_warning(png_ptr, error_message); png_benign_error(png_structp png_ptr, png_const_charp error_message)
else {
png_error(png_ptr, error_message); if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
} png_warning(png_ptr, error_message);
#endif else
png_error(png_ptr, error_message);
/* These utilities are used internally to build an error message that relates }
* to the current chunk. The chunk name comes from png_ptr->chunk_name, #endif
* this is used to prefix the message. The message is limited in length
* to 63 bytes, the name characters are output as hex digits wrapped in [] /* These utilities are used internally to build an error message that relates
* if the character is invalid. * to the current chunk. The chunk name comes from png_ptr->chunk_name,
*/ * this is used to prefix the message. The message is limited in length
#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) * to 63 bytes, the name characters are output as hex digits wrapped in []
static PNG_CONST char png_digit[16] = { * if the character is invalid.
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', */
'A', 'B', 'C', 'D', 'E', 'F' #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
}; static PNG_CONST char png_digit[16] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
#define PNG_MAX_ERROR_TEXT 64 'A', 'B', 'C', 'D', 'E', 'F'
#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) };
static void /* PRIVATE */
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp #define PNG_MAX_ERROR_TEXT 64
error_message) #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
{ static void /* PRIVATE */
int iout = 0, iin = 0; png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
error_message)
while (iin < 4) {
{ int iout = 0, iin = 0;
int c = png_ptr->chunk_name[iin++];
if (isnonalpha(c)) while (iin < 4)
{ {
buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET; int c = png_ptr->chunk_name[iin++];
buffer[iout++] = png_digit[(c & 0xf0) >> 4]; if (isnonalpha(c))
buffer[iout++] = png_digit[c & 0x0f]; {
buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET; buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
} buffer[iout++] = png_digit[(c & 0xf0) >> 4];
buffer[iout++] = png_digit[c & 0x0f];
else buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
{ }
buffer[iout++] = (png_byte)c; else
} {
} buffer[iout++] = (png_byte)c;
}
if (error_message == NULL) }
buffer[iout] = '\0';
if (error_message == NULL)
else buffer[iout] = '\0';
{ else
buffer[iout++] = ':'; {
buffer[iout++] = ' '; buffer[iout++] = ':';
png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT); buffer[iout++] = ' ';
buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
} iin = 0;
} while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ buffer[iout++] = error_message[iin++];
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
PNG_FUNCTION(void,PNGAPI buffer[iout] = '\0';
png_chunk_error,(png_structp png_ptr, png_const_charp error_message), }
PNG_NORETURN) }
{
char msg[18+PNG_MAX_ERROR_TEXT]; #ifdef PNG_READ_SUPPORTED
if (png_ptr == NULL) void PNGAPI
png_error(png_ptr, error_message); png_chunk_error(png_structp png_ptr, png_const_charp error_message)
{
else char msg[18+PNG_MAX_ERROR_TEXT];
{ if (png_ptr == NULL)
png_format_buffer(png_ptr, msg, error_message); png_error(png_ptr, error_message);
png_error(png_ptr, msg); else
} {
} png_format_buffer(png_ptr, msg, error_message);
#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */ png_error(png_ptr, msg);
}
#ifdef PNG_WARNINGS_SUPPORTED }
void PNGAPI #endif /* PNG_READ_SUPPORTED */
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
{
char msg[18+PNG_MAX_ERROR_TEXT]; #ifdef PNG_WARNINGS_SUPPORTED
if (png_ptr == NULL) void PNGAPI
png_warning(png_ptr, warning_message); png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
{
else char msg[18+PNG_MAX_ERROR_TEXT];
{ if (png_ptr == NULL)
png_format_buffer(png_ptr, msg, warning_message); png_warning(png_ptr, warning_message);
png_warning(png_ptr, msg); else
} {
} png_format_buffer(png_ptr, msg, warning_message);
#endif /* PNG_WARNINGS_SUPPORTED */ png_warning(png_ptr, msg);
}
#ifdef PNG_READ_SUPPORTED }
#ifdef PNG_BENIGN_ERRORS_SUPPORTED #endif /* PNG_WARNINGS_SUPPORTED */
void PNGAPI
png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message) #ifdef PNG_READ_SUPPORTED
{ #ifdef PNG_BENIGN_ERRORS_SUPPORTED
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) void PNGAPI
png_chunk_warning(png_ptr, error_message); png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
{
else if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
png_chunk_error(png_ptr, error_message); png_chunk_warning(png_ptr, error_message);
} else
#endif png_chunk_error(png_ptr, error_message);
#endif /* PNG_READ_SUPPORTED */ }
#endif
#ifdef PNG_ERROR_TEXT_SUPPORTED #endif /* PNG_READ_SUPPORTED */
#ifdef PNG_FLOATING_POINT_SUPPORTED
PNG_FUNCTION(void, /* This is the default error handling function. Note that replacements for
png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN) * this function MUST NOT RETURN, or the program will likely crash. This
{ * function is used by default, or if the program supplies NULL for the
# define fixed_message "fixed point overflow in " * error function pointer in png_set_error_fn().
# define fixed_message_ln ((sizeof fixed_message)-1) */
int iin; static void /* PRIVATE */
char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; png_default_error(png_structp png_ptr, png_const_charp error_message)
png_memcpy(msg, fixed_message, fixed_message_ln); {
iin = 0; #ifdef PNG_CONSOLE_IO_SUPPORTED
if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0) #ifdef PNG_ERROR_NUMBERS_SUPPORTED
{ if (*error_message == PNG_LITERAL_SHARP)
msg[fixed_message_ln + iin] = name[iin]; {
++iin; /* Strip "#nnnn " from beginning of error message. */
} int offset;
msg[fixed_message_ln + iin] = 0; char error_number[16];
png_error(png_ptr, msg); for (offset = 0; offset<15; offset++)
} {
#endif error_number[offset] = error_message[offset + 1];
#endif if (error_message[offset] == ' ')
break;
#ifdef PNG_SETJMP_SUPPORTED }
/* This API only exists if ANSI-C style error handling is used, if ((offset > 1) && (offset < 15))
* otherwise it is necessary for png_default_error to be overridden. {
*/ error_number[offset - 1] = '\0';
jmp_buf* PNGAPI fprintf(stderr, "libpng error no. %s: %s",
png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn, error_number, error_message + offset + 1);
size_t jmp_buf_size) fprintf(stderr, PNG_STRING_NEWLINE);
{ }
if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf)) else
return NULL; {
fprintf(stderr, "libpng error: %s, offset=%d",
png_ptr->longjmp_fn = longjmp_fn; error_message, offset);
return &png_ptr->png_jmpbuf; fprintf(stderr, PNG_STRING_NEWLINE);
} }
#endif }
else
/* This is the default error handling function. Note that replacements for #endif
* this function MUST NOT RETURN, or the program will likely crash. This {
* function is used by default, or if the program supplies NULL for the fprintf(stderr, "libpng error: %s", error_message);
* error function pointer in png_set_error_fn(). fprintf(stderr, PNG_STRING_NEWLINE);
*/ }
static PNG_FUNCTION(void /* PRIVATE */, #endif
png_default_error,(png_structp png_ptr, png_const_charp error_message),
PNG_NORETURN) #ifdef PNG_SETJMP_SUPPORTED
{ if (png_ptr)
#ifdef PNG_CONSOLE_IO_SUPPORTED {
#ifdef PNG_ERROR_NUMBERS_SUPPORTED # ifdef USE_FAR_KEYWORD
if (*error_message == PNG_LITERAL_SHARP) {
{ jmp_buf jmpbuf;
/* Strip "#nnnn " from beginning of error message. */ png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
int offset; longjmp(jmpbuf,1);
char error_number[16]; }
for (offset = 0; offset<15; offset++) # else
{ longjmp(png_ptr->jmpbuf, 1);
error_number[offset] = error_message[offset + 1]; # endif
if (error_message[offset] == ' ') }
break; #endif
} /* Here if not setjmp support or if png_ptr is null. */
PNG_ABORT();
if ((offset > 1) && (offset < 15)) #ifndef PNG_CONSOLE_IO_SUPPORTED
{ error_message = error_message; /* Make compiler happy */
error_number[offset - 1] = '\0'; #endif
fprintf(stderr, "libpng error no. %s: %s", }
error_number, error_message + offset + 1);
fprintf(stderr, PNG_STRING_NEWLINE); #ifdef PNG_WARNINGS_SUPPORTED
} /* This function is called when there is a warning, but the library thinks
* it can continue anyway. Replacement functions don't have to do anything
else * here if you don't want them to. In the default configuration, png_ptr is
{ * not used, but it is passed in case it may be useful.
fprintf(stderr, "libpng error: %s, offset=%d", */
error_message, offset); static void /* PRIVATE */
fprintf(stderr, PNG_STRING_NEWLINE); png_default_warning(png_structp png_ptr, png_const_charp warning_message)
} {
} #ifdef PNG_CONSOLE_IO_SUPPORTED
else # ifdef PNG_ERROR_NUMBERS_SUPPORTED
#endif if (*warning_message == PNG_LITERAL_SHARP)
{ {
fprintf(stderr, "libpng error: %s", error_message); int offset;
fprintf(stderr, PNG_STRING_NEWLINE); char warning_number[16];
} for (offset = 0; offset < 15; offset++)
#endif {
#ifndef PNG_CONSOLE_IO_SUPPORTED warning_number[offset] = warning_message[offset + 1];
PNG_UNUSED(error_message) /* Make compiler happy */ if (warning_message[offset] == ' ')
#endif break;
png_longjmp(png_ptr, 1); }
} if ((offset > 1) && (offset < 15))
{
PNG_FUNCTION(void,PNGAPI warning_number[offset + 1] = '\0';
png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN) fprintf(stderr, "libpng warning no. %s: %s",
{ warning_number, warning_message + offset);
#ifdef PNG_SETJMP_SUPPORTED fprintf(stderr, PNG_STRING_NEWLINE);
if (png_ptr && png_ptr->longjmp_fn) }
{ else
# ifdef USE_FAR_KEYWORD {
{ fprintf(stderr, "libpng warning: %s",
jmp_buf png_jmpbuf; warning_message);
png_memcpy(png_jmpbuf, png_ptr->png_jmpbuf, png_sizeof(jmp_buf)); fprintf(stderr, PNG_STRING_NEWLINE);
png_ptr->longjmp_fn(png_jmpbuf, val); }
} }
else
# else # endif
png_ptr->longjmp_fn(png_ptr->png_jmpbuf, val); {
# endif fprintf(stderr, "libpng warning: %s", warning_message);
} fprintf(stderr, PNG_STRING_NEWLINE);
#endif }
/* Here if not setjmp support or if png_ptr is null. */ #else
PNG_ABORT(); warning_message = warning_message; /* Make compiler happy */
} #endif
png_ptr = png_ptr; /* Make compiler happy */
#ifdef PNG_WARNINGS_SUPPORTED }
/* This function is called when there is a warning, but the library thinks #endif /* PNG_WARNINGS_SUPPORTED */
* it can continue anyway. Replacement functions don't have to do anything
* here if you don't want them to. In the default configuration, png_ptr is /* This function is called when the application wants to use another method
* not used, but it is passed in case it may be useful. * of handling errors and warnings. Note that the error function MUST NOT
*/ * return to the calling routine or serious problems will occur. The return
static void /* PRIVATE */ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
png_default_warning(png_structp png_ptr, png_const_charp warning_message) */
{ void PNGAPI
#ifdef PNG_CONSOLE_IO_SUPPORTED png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
# ifdef PNG_ERROR_NUMBERS_SUPPORTED png_error_ptr error_fn, png_error_ptr warning_fn)
if (*warning_message == PNG_LITERAL_SHARP) {
{ if (png_ptr == NULL)
int offset; return;
char warning_number[16]; png_ptr->error_ptr = error_ptr;
for (offset = 0; offset < 15; offset++) png_ptr->error_fn = error_fn;
{ png_ptr->warning_fn = warning_fn;
warning_number[offset] = warning_message[offset + 1]; }
if (warning_message[offset] == ' ')
break;
} /* This function returns a pointer to the error_ptr associated with the user
* functions. The application should free any memory associated with this
if ((offset > 1) && (offset < 15)) * pointer before png_write_destroy and png_read_destroy are called.
{ */
warning_number[offset + 1] = '\0'; png_voidp PNGAPI
fprintf(stderr, "libpng warning no. %s: %s", png_get_error_ptr(png_structp png_ptr)
warning_number, warning_message + offset); {
fprintf(stderr, PNG_STRING_NEWLINE); if (png_ptr == NULL)
} return NULL;
return ((png_voidp)png_ptr->error_ptr);
else }
{
fprintf(stderr, "libpng warning: %s",
warning_message); #ifdef PNG_ERROR_NUMBERS_SUPPORTED
fprintf(stderr, PNG_STRING_NEWLINE); void PNGAPI
} png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
} {
else if (png_ptr != NULL)
# endif {
png_ptr->flags &=
{ ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
fprintf(stderr, "libpng warning: %s", warning_message); }
fprintf(stderr, PNG_STRING_NEWLINE); }
} #endif
#else #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
PNG_UNUSED(warning_message) /* Make compiler happy */
#endif
PNG_UNUSED(png_ptr) /* Make compiler happy */
}
#endif /* PNG_WARNINGS_SUPPORTED */
/* This function is called when the application wants to use another method
* of handling errors and warnings. Note that the error function MUST NOT
* return to the calling routine or serious problems will occur. The return
* method used in the default routine calls longjmp(png_ptr->png_jmpbuf, 1)
*/
void PNGAPI
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warning_fn)
{
if (png_ptr == NULL)
return;
png_ptr->error_ptr = error_ptr;
png_ptr->error_fn = error_fn;
png_ptr->warning_fn = warning_fn;
}
/* This function returns a pointer to the error_ptr associated with the user
* functions. The application should free any memory associated with this
* pointer before png_write_destroy and png_read_destroy are called.
*/
png_voidp PNGAPI
png_get_error_ptr(png_const_structp png_ptr)
{
if (png_ptr == NULL)
return NULL;
return ((png_voidp)png_ptr->error_ptr);
}
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
void PNGAPI
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
{
if (png_ptr != NULL)
{
png_ptr->flags &=
((~(PNG_FLAG_STRIP_ERROR_NUMBERS |
PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
}
}
#endif
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

26
Externals/libpng/pnggccrd.c vendored Normal file
View File

@ -0,0 +1,26 @@
/* pnggccrd.c
*
* Last changed in libpng 1.2.48 [March 8, 2012]
* Copyright (c) 1998-2012 Glenn Randers-Pehrson
*
* This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer
* and license in png.h
*
* This code snippet is for use by configure's compilation test. Most of the
* remainder of the file was removed from libpng-1.2.20, and all of the
* assembler code was removed from libpng-1.2.48.
*/
#if (!defined _MSC_VER) && \
defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
defined(PNG_MMX_CODE_SUPPORTED)
int PNGAPI png_dummy_mmx_support(void);
int PNGAPI png_dummy_mmx_support(void)
{
/* 0: no MMX; 1: MMX supported; 2: not tested */
return 2;
}
#endif

1976
Externals/libpng/pngget.c vendored
View File

File diff suppressed because it is too large Load Diff

1299
Externals/libpng/pngmem.c vendored
View File

File diff suppressed because it is too large Load Diff

3095
Externals/libpng/pngpread.c vendored
View File

File diff suppressed because it is too large Load Diff

2981
Externals/libpng/pngread.c vendored
View File

File diff suppressed because it is too large Load Diff

356
Externals/libpng/pngrio.c vendored
View File

@ -1,176 +1,180 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
* *
* Last changed in libpng 1.5.0 [January 6, 2011] * Last changed in libpng 1.2.43 [February 25, 2010]
* Copyright (c) 1998-2011 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer * For conditions of distribution and use, see the disclaimer
* and license in png.h * and license in png.h
* *
* This file provides a location for all input. Users who need * This file provides a location for all input. Users who need
* special handling are expected to write a function that has the same * special handling are expected to write a function that has the same
* arguments as this and performs a similar function, but that possibly * arguments as this and performs a similar function, but that possibly
* has a different input method. Note that you shouldn't change this * has a different input method. Note that you shouldn't change this
* function, but rather write a replacement function and then make * function, but rather write a replacement function and then make
* libpng use it at run time with png_set_read_fn(...). * libpng use it at run time with png_set_read_fn(...).
*/ */
#include "pngpriv.h" #define PNG_INTERNAL
#define PNG_NO_PEDANTIC_WARNINGS
#ifdef PNG_READ_SUPPORTED #include "png.h"
#ifdef PNG_READ_SUPPORTED
/* Read the data from whatever input you are using. The default routine
* reads from a file pointer. Note that this routine sometimes gets called /* Read the data from whatever input you are using. The default routine
* with very small lengths, so you should implement some kind of simple * reads from a file pointer. Note that this routine sometimes gets called
* buffering if you are using unbuffered reads. This should never be asked * with very small lengths, so you should implement some kind of simple
* to read more then 64K on a 16 bit machine. * buffering if you are using unbuffered reads. This should never be asked
*/ * to read more then 64K on a 16 bit machine.
void /* PRIVATE */ */
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) void /* PRIVATE */
{ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_debug1(4, "reading %d bytes", (int)length); {
png_debug1(4, "reading %d bytes", (int)length);
if (png_ptr->read_data_fn != NULL)
(*(png_ptr->read_data_fn))(png_ptr, data, length); if (png_ptr->read_data_fn != NULL)
(*(png_ptr->read_data_fn))(png_ptr, data, length);
else else
png_error(png_ptr, "Call to NULL read function"); png_error(png_ptr, "Call to NULL read function");
} }
#ifdef PNG_STDIO_SUPPORTED #ifdef PNG_STDIO_SUPPORTED
/* This is the function that does the actual reading of data. If you are /* This is the function that does the actual reading of data. If you are
* not reading from a standard C stream, you should create a replacement * not reading from a standard C stream, you should create a replacement
* read_data function and use it at run time with png_set_read_fn(), rather * read_data function and use it at run time with png_set_read_fn(), rather
* than changing the library. * than changing the library.
*/ */
# ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
void PNGCBAPI void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
png_size_t check; png_size_t check;
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
/* fread() returns 0 on error, so it is OK to store this in a png_size_t
/* fread() returns 0 on error, so it is OK to store this in a png_size_t * instead of an int, which is what fread() actually returns.
* instead of an int, which is what fread() actually returns. */
*/ #ifdef _WIN32_WCE
check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr); if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
check = 0;
if (check != length) #else
png_error(png_ptr, "Read Error"); check = (png_size_t)fread(data, (png_size_t)1, length,
} (png_FILE_p)png_ptr->io_ptr);
# else #endif
/* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy if (check != length)
the data. png_error(png_ptr, "Read Error");
*/ }
#else
#define NEAR_BUF_SIZE 1024 /* This is the model-independent version. Since the standard I/O library
#define MIN(a,b) (a <= b ? a : b) can't handle far buffers in the medium and small models, we have to copy
the data.
static void PNGCBAPI */
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ #define NEAR_BUF_SIZE 1024
png_size_t check; #define MIN(a,b) (a <= b ? a : b)
png_byte *n_data;
png_FILE_p io_ptr; static void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
if (png_ptr == NULL) {
return; int check;
png_byte *n_data;
/* Check if data really is near. If so, use usual code. */ png_FILE_p io_ptr;
n_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); if (png_ptr == NULL)
return;
if ((png_bytep)n_data == data) /* Check if data really is near. If so, use usual code. */
{ n_data = (png_byte *)CVT_PTR_NOCHECK(data);
check = fread(n_data, 1, length, io_ptr); io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
} if ((png_bytep)n_data == data)
{
else #ifdef _WIN32_WCE
{ if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check,
png_byte buf[NEAR_BUF_SIZE]; NULL) )
png_size_t read, remaining, err; check = 0;
check = 0; #else
remaining = length; check = fread(n_data, 1, length, io_ptr);
#endif
do }
{ else
read = MIN(NEAR_BUF_SIZE, remaining); {
err = fread(buf, 1, read, io_ptr); png_byte buf[NEAR_BUF_SIZE];
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ png_size_t read, remaining, err;
check = 0;
if (err != read) remaining = length;
break; do
{
else read = MIN(NEAR_BUF_SIZE, remaining);
check += err; #ifdef _WIN32_WCE
if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )
data += read; err = 0;
remaining -= read; #else
} err = fread(buf, (png_size_t)1, read, io_ptr);
while (remaining != 0); #endif
} png_memcpy(data, buf, read); /* copy far buffer to near buffer */
if (err != read)
if ((png_uint_32)check != (png_uint_32)length) break;
png_error(png_ptr, "read Error"); else
} check += err;
# endif data += read;
#endif remaining -= read;
}
/* This function allows the application to supply a new input function while (remaining != 0);
* for libpng if standard C streams aren't being used. }
* if ((png_uint_32)check != (png_uint_32)length)
* This function takes as its arguments: png_error(png_ptr, "read Error");
* }
* png_ptr - pointer to a png input data structure #endif
* #endif
* io_ptr - pointer to user supplied structure containing info about
* the input functions. May be NULL. /* This function allows the application to supply a new input function
* * for libpng if standard C streams aren't being used.
* read_data_fn - pointer to a new input function that takes as its *
* arguments a pointer to a png_struct, a pointer to * This function takes as its arguments:
* a location where input data can be stored, and a 32-bit * png_ptr - pointer to a png input data structure
* unsigned int that is the number of bytes to be read. * io_ptr - pointer to user supplied structure containing info about
* To exit and output any fatal error messages the new write * the input functions. May be NULL.
* function should call png_error(png_ptr, "Error msg"). * read_data_fn - pointer to a new input function that takes as its
* May be NULL, in which case libpng's default function will * arguments a pointer to a png_struct, a pointer to
* be used. * a location where input data can be stored, and a 32-bit
*/ * unsigned int that is the number of bytes to be read.
void PNGAPI * To exit and output any fatal error messages the new write
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, * function should call png_error(png_ptr, "Error msg").
png_rw_ptr read_data_fn) * May be NULL, in which case libpng's default function will
{ * be used.
if (png_ptr == NULL) */
return; void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
png_ptr->io_ptr = io_ptr; png_rw_ptr read_data_fn)
{
#ifdef PNG_STDIO_SUPPORTED if (png_ptr == NULL)
if (read_data_fn != NULL) return;
png_ptr->read_data_fn = read_data_fn; png_ptr->io_ptr = io_ptr;
else #ifdef PNG_STDIO_SUPPORTED
png_ptr->read_data_fn = png_default_read_data; if (read_data_fn != NULL)
#else png_ptr->read_data_fn = read_data_fn;
png_ptr->read_data_fn = read_data_fn; else
#endif png_ptr->read_data_fn = png_default_read_data;
#else
/* It is an error to write to a read device */ png_ptr->read_data_fn = read_data_fn;
if (png_ptr->write_data_fn != NULL) #endif
{
png_ptr->write_data_fn = NULL; /* It is an error to write to a read device */
png_warning(png_ptr, if (png_ptr->write_data_fn != NULL)
"Can't set both read_data_fn and write_data_fn in the" {
" same structure"); png_ptr->write_data_fn = NULL;
} png_warning(png_ptr,
"It's an error to set both read_data_fn and write_data_fn in the ");
#ifdef PNG_WRITE_FLUSH_SUPPORTED png_warning(png_ptr,
png_ptr->output_flush_fn = NULL; "same structure. Resetting write_data_fn to NULL.");
#endif }
}
#endif /* PNG_READ_SUPPORTED */ #ifdef PNG_WRITE_FLUSH_SUPPORTED
png_ptr->output_flush_fn = NULL;
#endif
}
#endif /* PNG_READ_SUPPORTED */

8694
Externals/libpng/pngrtran.c vendored
View File

File diff suppressed because it is too large Load Diff

7002
Externals/libpng/pngrutil.c vendored
View File

File diff suppressed because it is too large Load Diff

2461
Externals/libpng/pngset.c vendored
View File

File diff suppressed because it is too large Load Diff

1705
Externals/libpng/pngtest.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1422
Externals/libpng/pngtrans.c vendored
View File

File diff suppressed because it is too large Load Diff

12
Externals/libpng/pngvcrd.c vendored Normal file
View File

@ -0,0 +1,12 @@
/* pngvcrd.c
*
* Last changed in libpng 1.2.48 [March 8, 2012]
* Copyright (c) 1998-2012 Glenn Randers-Pehrson
*
* This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer
* and license in png.h
*
* This nearly empty file is for use by configure's compilation test. The
* remainder of the file was removed from libpng-1.2.20.
*/

514
Externals/libpng/pngwio.c vendored
View File

@ -1,254 +1,260 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
* *
* Last changed in libpng 1.5.0 [January 6, 2011] * Last changed in libpng 1.2.41 [December 3, 2009]
* Copyright (c) 1998-2011 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer * For conditions of distribution and use, see the disclaimer
* and license in png.h * and license in png.h
* *
* This file provides a location for all output. Users who need * This file provides a location for all output. Users who need
* special handling are expected to write functions that have the same * special handling are expected to write functions that have the same
* arguments as these and perform similar functions, but that possibly * arguments as these and perform similar functions, but that possibly
* use different output methods. Note that you shouldn't change these * use different output methods. Note that you shouldn't change these
* functions, but rather write replacement functions and then change * functions, but rather write replacement functions and then change
* them at run time with png_set_write_fn(...). * them at run time with png_set_write_fn(...).
*/ */
#include "pngpriv.h" #define PNG_INTERNAL
#define PNG_NO_PEDANTIC_WARNINGS
#ifdef PNG_WRITE_SUPPORTED #include "png.h"
#ifdef PNG_WRITE_SUPPORTED
/* Write the data to whatever output you are using. The default routine
* writes to a file pointer. Note that this routine sometimes gets called /* Write the data to whatever output you are using. The default routine
* with very small lengths, so you should implement some kind of simple * writes to a file pointer. Note that this routine sometimes gets called
* buffering if you are using unbuffered writes. This should never be asked * with very small lengths, so you should implement some kind of simple
* to write more than 64K on a 16 bit machine. * buffering if you are using unbuffered writes. This should never be asked
*/ * to write more than 64K on a 16 bit machine.
*/
void /* PRIVATE */
png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length) void /* PRIVATE */
{ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
/* NOTE: write_data_fn must not change the buffer! */ {
if (png_ptr->write_data_fn != NULL ) if (png_ptr->write_data_fn != NULL )
(*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length); (*(png_ptr->write_data_fn))(png_ptr, data, length);
else
else png_error(png_ptr, "Call to NULL write function");
png_error(png_ptr, "Call to NULL write function"); }
}
#ifdef PNG_STDIO_SUPPORTED
#ifdef PNG_STDIO_SUPPORTED /* This is the function that does the actual writing of data. If you are
/* This is the function that does the actual writing of data. If you are * not writing to a standard C stream, you should create a replacement
* not writing to a standard C stream, you should create a replacement * write_data function and use it at run time with png_set_write_fn(), rather
* write_data function and use it at run time with png_set_write_fn(), rather * than changing the library.
* than changing the library. */
*/ #ifndef USE_FAR_KEYWORD
#ifndef USE_FAR_KEYWORD void PNGAPI
void PNGCBAPI png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) {
{ png_uint_32 check;
png_size_t check;
if (png_ptr == NULL)
if (png_ptr == NULL) return;
return; #ifdef _WIN32_WCE
if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); check = 0;
#else
if (check != length) check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
png_error(png_ptr, "Write Error"); #endif
} if (check != length)
#else png_error(png_ptr, "Write Error");
/* This is the model-independent version. Since the standard I/O library }
* can't handle far buffers in the medium and small models, we have to copy #else
* the data. /* This is the model-independent version. Since the standard I/O library
*/ * can't handle far buffers in the medium and small models, we have to copy
* the data.
#define NEAR_BUF_SIZE 1024 */
#define MIN(a,b) (a <= b ? a : b)
#define NEAR_BUF_SIZE 1024
void PNGCBAPI #define MIN(a,b) (a <= b ? a : b)
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ void PNGAPI
png_uint_32 check; png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ {
png_FILE_p io_ptr; png_uint_32 check;
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
if (png_ptr == NULL) png_FILE_p io_ptr;
return;
if (png_ptr == NULL)
/* Check if data really is near. If so, use usual code. */ return;
near_data = (png_byte *)CVT_PTR_NOCHECK(data); /* Check if data really is near. If so, use usual code. */
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); near_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
if ((png_bytep)near_data == data) if ((png_bytep)near_data == data)
{ {
check = fwrite(near_data, 1, length, io_ptr); #ifdef _WIN32_WCE
} if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )
check = 0;
else #else
{ check = fwrite(near_data, 1, length, io_ptr);
png_byte buf[NEAR_BUF_SIZE]; #endif
png_size_t written, remaining, err; }
check = 0; else
remaining = length; {
png_byte buf[NEAR_BUF_SIZE];
do png_size_t written, remaining, err;
{ check = 0;
written = MIN(NEAR_BUF_SIZE, remaining); remaining = length;
png_memcpy(buf, data, written); /* Copy far buffer to near buffer */ do
err = fwrite(buf, 1, written, io_ptr); {
written = MIN(NEAR_BUF_SIZE, remaining);
if (err != written) png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
break; #ifdef _WIN32_WCE
if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
else err = 0;
check += err; #else
err = fwrite(buf, 1, written, io_ptr);
data += written; #endif
remaining -= written; if (err != written)
} break;
while (remaining != 0);
} else
check += err;
if (check != length)
png_error(png_ptr, "Write Error"); data += written;
} remaining -= written;
}
#endif while (remaining != 0);
#endif }
if (check != length)
/* This function is called to output any data pending writing (normally png_error(png_ptr, "Write Error");
* to disk). After png_flush is called, there should be no data pending }
* writing in any buffers.
*/ #endif
#ifdef PNG_WRITE_FLUSH_SUPPORTED #endif
void /* PRIVATE */
png_flush(png_structp png_ptr) /* This function is called to output any data pending writing (normally
{ * to disk). After png_flush is called, there should be no data pending
if (png_ptr->output_flush_fn != NULL) * writing in any buffers.
(*(png_ptr->output_flush_fn))(png_ptr); */
} #ifdef PNG_WRITE_FLUSH_SUPPORTED
void /* PRIVATE */
# ifdef PNG_STDIO_SUPPORTED png_flush(png_structp png_ptr)
void PNGCBAPI {
png_default_flush(png_structp png_ptr) if (png_ptr->output_flush_fn != NULL)
{ (*(png_ptr->output_flush_fn))(png_ptr);
png_FILE_p io_ptr; }
if (png_ptr == NULL) #ifdef PNG_STDIO_SUPPORTED
return; void PNGAPI
png_default_flush(png_structp png_ptr)
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); {
fflush(io_ptr); #ifndef _WIN32_WCE
} png_FILE_p io_ptr;
# endif #endif
#endif if (png_ptr == NULL)
return;
/* This function allows the application to supply new output functions for #ifndef _WIN32_WCE
* libpng if standard C streams aren't being used. io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
* fflush(io_ptr);
* This function takes as its arguments: #endif
* png_ptr - pointer to a png output data structure }
* io_ptr - pointer to user supplied structure containing info about #endif
* the output functions. May be NULL. #endif
* write_data_fn - pointer to a new output function that takes as its
* arguments a pointer to a png_struct, a pointer to /* This function allows the application to supply new output functions for
* data to be written, and a 32-bit unsigned int that is * libpng if standard C streams aren't being used.
* the number of bytes to be written. The new write *
* function should call png_error(png_ptr, "Error msg") * This function takes as its arguments:
* to exit and output any fatal error messages. May be * png_ptr - pointer to a png output data structure
* NULL, in which case libpng's default function will * io_ptr - pointer to user supplied structure containing info about
* be used. * the output functions. May be NULL.
* flush_data_fn - pointer to a new flush function that takes as its * write_data_fn - pointer to a new output function that takes as its
* arguments a pointer to a png_struct. After a call to * arguments a pointer to a png_struct, a pointer to
* the flush function, there should be no data in any buffers * data to be written, and a 32-bit unsigned int that is
* or pending transmission. If the output method doesn't do * the number of bytes to be written. The new write
* any buffering of output, a function prototype must still be * function should call png_error(png_ptr, "Error msg")
* supplied although it doesn't have to do anything. If * to exit and output any fatal error messages. May be
* PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile * NULL, in which case libpng's default function will
* time, output_flush_fn will be ignored, although it must be * be used.
* supplied for compatibility. May be NULL, in which case * flush_data_fn - pointer to a new flush function that takes as its
* libpng's default function will be used, if * arguments a pointer to a png_struct. After a call to
* PNG_WRITE_FLUSH_SUPPORTED is defined. This is not * the flush function, there should be no data in any buffers
* a good idea if io_ptr does not point to a standard * or pending transmission. If the output method doesn't do
* *FILE structure. * any buffering of output, a function prototype must still be
*/ * supplied although it doesn't have to do anything. If
void PNGAPI * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, * time, output_flush_fn will be ignored, although it must be
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) * supplied for compatibility. May be NULL, in which case
{ * libpng's default function will be used, if
if (png_ptr == NULL) * PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
return; * a good idea if io_ptr does not point to a standard
* *FILE structure.
png_ptr->io_ptr = io_ptr; */
void PNGAPI
#ifdef PNG_STDIO_SUPPORTED png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
if (write_data_fn != NULL) png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
png_ptr->write_data_fn = write_data_fn; {
if (png_ptr == NULL)
else return;
png_ptr->write_data_fn = png_default_write_data;
#else png_ptr->io_ptr = io_ptr;
png_ptr->write_data_fn = write_data_fn;
#endif #ifdef PNG_STDIO_SUPPORTED
if (write_data_fn != NULL)
#ifdef PNG_WRITE_FLUSH_SUPPORTED png_ptr->write_data_fn = write_data_fn;
# ifdef PNG_STDIO_SUPPORTED
else
if (output_flush_fn != NULL) png_ptr->write_data_fn = png_default_write_data;
png_ptr->output_flush_fn = output_flush_fn; #else
png_ptr->write_data_fn = write_data_fn;
else #endif
png_ptr->output_flush_fn = png_default_flush;
#ifdef PNG_WRITE_FLUSH_SUPPORTED
# else #ifdef PNG_STDIO_SUPPORTED
png_ptr->output_flush_fn = output_flush_fn; if (output_flush_fn != NULL)
# endif png_ptr->output_flush_fn = output_flush_fn;
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
else
/* It is an error to read while writing a png file */ png_ptr->output_flush_fn = png_default_flush;
if (png_ptr->read_data_fn != NULL) #else
{ png_ptr->output_flush_fn = output_flush_fn;
png_ptr->read_data_fn = NULL; #endif
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
png_warning(png_ptr,
"Can't set both read_data_fn and write_data_fn in the" /* It is an error to read while writing a png file */
" same structure"); if (png_ptr->read_data_fn != NULL)
} {
} png_ptr->read_data_fn = NULL;
png_warning(png_ptr,
#ifdef USE_FAR_KEYWORD "Attempted to set both read_data_fn and write_data_fn in");
# ifdef _MSC_VER png_warning(png_ptr,
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) "the same structure. Resetting read_data_fn to NULL.");
{ }
void *near_ptr; }
void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr); #ifdef USE_FAR_KEYWORD
far_ptr = (void FAR *)near_ptr; #ifdef _MSC_VER
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
if (check != 0) {
if (FP_SEG(ptr) != FP_SEG(far_ptr)) void *near_ptr;
png_error(png_ptr, "segment lost in conversion"); void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr);
return(near_ptr); far_ptr = (void FAR *)near_ptr;
}
# else if (check != 0)
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) if (FP_SEG(ptr) != FP_SEG(far_ptr))
{ png_error(png_ptr, "segment lost in conversion");
void *near_ptr;
void FAR *far_ptr; return(near_ptr);
near_ptr = (void FAR *)ptr; }
far_ptr = (void FAR *)near_ptr; # else
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
if (check != 0) {
if (far_ptr != ptr) void *near_ptr;
png_error(png_ptr, "segment lost in conversion"); void FAR *far_ptr;
near_ptr = (void FAR *)ptr;
return(near_ptr); far_ptr = (void FAR *)near_ptr;
}
# endif if (check != 0)
#endif if (far_ptr != ptr)
#endif /* PNG_WRITE_SUPPORTED */ png_error(png_ptr, "segment lost in conversion");
return(near_ptr);
}
# endif
# endif
#endif /* PNG_WRITE_SUPPORTED */

3198
Externals/libpng/pngwrite.c vendored
View File

File diff suppressed because it is too large Load Diff

1213
Externals/libpng/pngwtran.c vendored
View File

File diff suppressed because it is too large Load Diff

5780
Externals/libpng/pngwutil.c vendored
View File

File diff suppressed because it is too large Load Diff