This repository has been archived on 2023-11-11. You can view files and clone it, but cannot push or open issues or pull requests.
libpng/pngwio.c

261 lines
7.9 KiB
C
Raw Normal View History

1996-06-05 20:50:50 +00:00
/* pngwio.c - functions for data output
1998-01-01 13:13:13 +00:00
*
* Last changed in libpng 1.2.41 [December 3, 2009]
2009-02-04 19:11:41 +00:00
* Copyright (c) 1998-2009 Glenn Randers-Pehrson
2000-06-04 19:29:29 +00:00
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
1998-01-01 13:13:13 +00:00
*
* This code is released under the libpng license.
* For conditions of distribution and use, see the disclaimer
* and license in png.h
*
1998-05-21 14:27:50 +00:00
* This file provides a location for all output. Users who need
* special handling are expected to write functions that have the same
* arguments as these and perform similar functions, but that possibly
* use different output methods. Note that you shouldn't change these
1998-01-01 13:13:13 +00:00
* functions, but rather write replacement functions and then change
* them at run time with png_set_write_fn(...).
*/
1996-06-05 20:50:50 +00:00
#define PNG_INTERNAL
2009-11-25 22:04:13 +00:00
#define PNG_NO_PEDANTIC_WARNINGS
1996-06-05 20:50:50 +00:00
#include "png.h"
2001-05-07 19:52:45 +00:00
#ifdef PNG_WRITE_SUPPORTED
1996-06-05 20:50:50 +00:00
/* Write the data to whatever output you are using. The default routine
2009-05-20 17:43:52 +00:00
* writes to a file pointer. Note that this routine sometimes gets called
* with very small lengths, so you should implement some kind of simple
* buffering if you are using unbuffered writes. This should never be asked
* to write more than 64K on a 16 bit machine.
*/
1996-06-05 20:50:50 +00:00
2000-05-06 19:09:57 +00:00
void /* PRIVATE */
1997-05-16 07:46:07 +00:00
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1996-06-05 20:50:50 +00:00
{
1997-05-16 07:46:07 +00:00
if (png_ptr->write_data_fn != NULL )
1996-06-05 20:50:50 +00:00
(*(png_ptr->write_data_fn))(png_ptr, data, length);
else
png_error(png_ptr, "Call to NULL write function");
}
#ifdef PNG_STDIO_SUPPORTED
1998-05-21 14:27:50 +00:00
/* This is the function that does the actual writing of data. If you are
2009-05-20 17:43:52 +00:00
* 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
* than changing the library.
*/
1996-06-05 20:50:50 +00:00
#ifndef USE_FAR_KEYWORD
2002-05-01 16:51:26 +00:00
void PNGAPI
1997-05-16 07:46:07 +00:00
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1996-06-05 20:50:50 +00:00
{
png_uint_32 check;
if (png_ptr == NULL)
return;
#ifdef _WIN32_WCE
2000-07-08 18:19:41 +00:00
if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
2000-07-10 12:48:54 +00:00
check = 0;
2000-07-08 18:19:41 +00:00
#else
check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
#endif
1996-06-05 20:50:50 +00:00
if (check != length)
png_error(png_ptr, "Write Error");
}
#else
2009-05-20 17:43:52 +00:00
/* 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.
*/
1996-06-05 20:50:50 +00:00
#define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b)
2002-05-01 16:51:26 +00:00
void PNGAPI
1997-05-16 07:46:07 +00:00
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
1996-06-05 20:50:50 +00:00
{
png_uint_32 check;
1997-05-16 07:46:07 +00:00
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
2000-07-08 18:19:41 +00:00
png_FILE_p io_ptr;
1996-06-05 20:50:50 +00:00
if (png_ptr == NULL)
return;
1996-06-05 20:50:50 +00:00
/* Check if data really is near. If so, use usual code. */
1997-05-16 07:46:07 +00:00
near_data = (png_byte *)CVT_PTR_NOCHECK(data);
2000-07-08 18:19:41 +00:00
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
1997-05-16 07:46:07 +00:00
if ((png_bytep)near_data == data)
1996-06-05 20:50:50 +00:00
{
#ifdef _WIN32_WCE
2000-07-10 12:48:54 +00:00
if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )
check = 0;
#else
1997-05-16 07:46:07 +00:00
check = fwrite(near_data, 1, length, io_ptr);
2000-07-10 12:48:54 +00:00
#endif
1996-06-05 20:50:50 +00:00
}
else
{
png_byte buf[NEAR_BUF_SIZE];
png_size_t written, remaining, err;
check = 0;
1997-05-16 07:46:07 +00:00
remaining = length;
1996-06-05 20:50:50 +00:00
do
{
written = MIN(NEAR_BUF_SIZE, remaining);
2009-05-20 17:43:52 +00:00
png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
#ifdef _WIN32_WCE
2000-07-10 12:48:54 +00:00
if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
err = 0;
#else
1997-01-17 07:34:35 +00:00
err = fwrite(buf, 1, written, io_ptr);
2000-07-10 12:48:54 +00:00
#endif
1996-06-05 20:50:50 +00:00
if (err != written)
break;
2009-05-20 17:43:52 +00:00
1996-06-05 20:50:50 +00:00
else
check += err;
2009-05-20 17:43:52 +00:00
1996-06-05 20:50:50 +00:00
data += written;
remaining -= written;
}
while (remaining != 0);
}
if (check != length)
png_error(png_ptr, "Write Error");
}
1998-01-04 04:40:55 +00:00
#endif
1996-06-05 20:50:50 +00:00
#endif
/* This function is called to output any data pending writing (normally
2009-05-20 17:43:52 +00:00
* to disk). After png_flush is called, there should be no data pending
* writing in any buffers.
*/
#ifdef PNG_WRITE_FLUSH_SUPPORTED
2000-05-06 19:09:57 +00:00
void /* PRIVATE */
1996-06-05 20:50:50 +00:00
png_flush(png_structp png_ptr)
{
1997-05-16 07:46:07 +00:00
if (png_ptr->output_flush_fn != NULL)
1996-06-05 20:50:50 +00:00
(*(png_ptr->output_flush_fn))(png_ptr);
}
#ifdef PNG_STDIO_SUPPORTED
2002-05-01 16:51:26 +00:00
void PNGAPI
1996-06-05 20:50:50 +00:00
png_default_flush(png_structp png_ptr)
{
#ifndef _WIN32_WCE
2000-07-08 18:19:41 +00:00
png_FILE_p io_ptr;
2006-11-17 02:51:41 +00:00
#endif
2009-05-20 17:43:52 +00:00
if (png_ptr == NULL)
return;
#ifndef _WIN32_WCE
2000-07-08 18:19:41 +00:00
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
2009-03-21 13:10:28 +00:00
fflush(io_ptr);
2000-07-08 18:19:41 +00:00
#endif
1996-06-05 20:50:50 +00:00
}
#endif
1998-01-04 04:40:55 +00:00
#endif
1996-06-05 20:50:50 +00:00
/* This function allows the application to supply new output functions for
2009-05-20 17:43:52 +00:00
* libpng if standard C streams aren't being used.
*
* This function takes as its arguments:
* png_ptr - pointer to a png output data structure
* io_ptr - pointer to user supplied structure containing info about
* the output functions. May be NULL.
* write_data_fn - pointer to a new output function that takes as its
* arguments a pointer to a png_struct, a pointer to
* data to be written, and a 32-bit unsigned int that is
* the number of bytes to be written. The new write
* function should call png_error(png_ptr, "Error msg")
* to exit and output any fatal error messages. May be
* NULL, in which case libpng's default function will
* be used.
* flush_data_fn - pointer to a new flush function that takes as its
* arguments a pointer to a png_struct. After a call to
* the flush function, there should be no data in any buffers
* or pending transmission. If the output method doesn't do
* any buffering of ouput, a function prototype must still be
* supplied although it doesn't have to do anything. If
* PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
* time, output_flush_fn will be ignored, although it must be
* supplied for compatibility. May be NULL, in which case
* libpng's default function will be used, if
* PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
* a good idea if io_ptr does not point to a standard
* *FILE structure.
*/
2000-05-06 19:09:57 +00:00
void PNGAPI
1996-06-05 20:50:50 +00:00
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
{
2009-05-20 17:43:52 +00:00
if (png_ptr == NULL)
return;
1996-06-05 20:50:50 +00:00
png_ptr->io_ptr = io_ptr;
#ifdef PNG_STDIO_SUPPORTED
1997-05-16 07:46:07 +00:00
if (write_data_fn != NULL)
1996-06-05 20:50:50 +00:00
png_ptr->write_data_fn = write_data_fn;
2009-05-20 17:43:52 +00:00
1996-06-05 20:50:50 +00:00
else
2002-05-01 16:51:26 +00:00
png_ptr->write_data_fn = png_default_write_data;
1998-01-04 04:40:55 +00:00
#else
png_ptr->write_data_fn = write_data_fn;
#endif
1996-06-05 20:50:50 +00:00
#ifdef PNG_WRITE_FLUSH_SUPPORTED
#ifdef PNG_STDIO_SUPPORTED
1997-05-16 07:46:07 +00:00
if (output_flush_fn != NULL)
1996-06-05 20:50:50 +00:00
png_ptr->output_flush_fn = output_flush_fn;
2009-05-20 17:43:52 +00:00
1996-06-05 20:50:50 +00:00
else
2002-05-01 16:51:26 +00:00
png_ptr->output_flush_fn = png_default_flush;
1998-01-04 04:40:55 +00:00
#else
png_ptr->output_flush_fn = output_flush_fn;
#endif
1996-06-05 20:50:50 +00:00
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* It is an error to read while writing a png file */
1998-06-06 20:31:35 +00:00
if (png_ptr->read_data_fn != NULL)
{
png_ptr->read_data_fn = NULL;
png_warning(png_ptr,
"Attempted to set both read_data_fn and write_data_fn in");
png_warning(png_ptr,
"the same structure. Resetting read_data_fn to NULL.");
}
1996-06-05 20:50:50 +00:00
}
#ifdef USE_FAR_KEYWORD
#ifdef _MSC_VER
2008-07-06 11:05:04 +00:00
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
1997-01-17 07:34:35 +00:00
{
1998-12-29 17:47:59 +00:00
void *near_ptr;
1997-01-17 07:34:35 +00:00
void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr);
far_ptr = (void FAR *)near_ptr;
2009-05-20 17:43:52 +00:00
2008-07-10 14:10:58 +00:00
if (check != 0)
if (FP_SEG(ptr) != FP_SEG(far_ptr))
2008-07-06 11:05:04 +00:00
png_error(png_ptr, "segment lost in conversion");
2009-05-20 17:43:52 +00:00
1997-01-17 07:34:35 +00:00
return(near_ptr);
}
# else
2008-07-06 11:05:04 +00:00
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
1997-01-17 07:34:35 +00:00
{
1998-12-29 17:47:59 +00:00
void *near_ptr;
1997-01-17 07:34:35 +00:00
void FAR *far_ptr;
near_ptr = (void FAR *)ptr;
far_ptr = (void FAR *)near_ptr;
2009-05-20 17:43:52 +00:00
2008-07-10 14:10:58 +00:00
if (check != 0)
if (far_ptr != ptr)
2008-07-06 11:05:04 +00:00
png_error(png_ptr, "segment lost in conversion");
2009-05-20 17:43:52 +00:00
1997-01-17 07:34:35 +00:00
return(near_ptr);
}
# endif
# endif
2001-05-07 19:52:45 +00:00
#endif /* PNG_WRITE_SUPPORTED */