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/pngio.c

412 lines
13 KiB
C
Raw Normal View History

1995-09-26 10:22:39 +00:00
1995-11-28 17:22:13 +00:00
/* pngio.c - default functions for data I/O and error/warning messages
1995-09-26 10:22:39 +00:00
1995-11-28 17:22:13 +00:00
libpng 1.0 beta 3 - version 0.82
1995-09-26 10:22:39 +00:00
For conditions of distribution and use, see copyright notice in png.h
Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
1995-11-28 17:22:13 +00:00
Some portions Copyright (C) 1995 Andreas Dilger
Sept 24, 1995
1995-09-26 10:22:39 +00:00
This file provides a location for all input/output. Users which need
1995-11-28 17:22:13 +00:00
special handling are expected to write functions which have the same
arguments as these, and perform similar functions, but possibly have
different I/O methods. Note that you shouldn't change these functions,
but rather write replacement functions and then change them at run
time with png_set_write_fn(...) or png_set_read_fn(...), etc */
1995-09-26 10:22:39 +00:00
#include "png.h"
1995-11-28 17:22:13 +00:00
1995-09-26 10:22:39 +00:00
/* Write the data to whatever output you are using. The default
routine writes to a file pointer. If you need to write to something
1995-11-28 17:22:13 +00:00
else, this is a good example of how to do it. 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 then 64K on a 16 bit machine. The
cast to png_size_t is there for insurance. */
1995-09-26 10:22:39 +00:00
#ifndef USE_FAR_KEYWORD
1995-11-28 17:22:13 +00:00
static void
1995-09-26 10:22:39 +00:00
png_write_data(png_struct *png_ptr, png_bytef *data, png_uint_32 length)
{
png_uint_32 check;
check = fwrite(data, 1, (png_size_t)length, png_ptr->fp);
if (check != length)
{
1995-11-28 17:22:13 +00:00
(*(png_ptr->error_fn))(png_ptr, "Write error");
1995-09-26 10:22:39 +00:00
}
}
#else
/* 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)
#ifdef _MSC_VER
/* for FP_OFF */
#include <dos.h>
#endif
1995-11-28 17:22:13 +00:00
static void
1995-09-26 10:22:39 +00:00
png_write_data(png_struct *png_ptr, png_bytef *data, png_uint_32 length)
{
png_uint_32 check;
png_byte *n_data;
/* Check if data really is near. If so, use usual code. */
#ifdef _MSC_VER
/* do it this way just to quiet warning */
FP_OFF(n_data) = FP_OFF(data);
if(FP_SEG(n_data) == FP_SEG(data))
#else
/* this works in MSC also but with lost segment warning */
n_data = (png_byte *)data;
if((png_bytef *)n_data == data)
#endif
{
check = fwrite(n_data, 1, (png_size_t)length, png_ptr->fp);
}
else
{
png_byte buf[NEAR_BUF_SIZE];
png_size_t written, remaining, err;
check = 0;
remaining = (png_size_t)length;
do
{
written = MIN(NEAR_BUF_SIZE,remaining);
png_memcpy(buf,data,written); /* copy far buffer to near buffer */
err = fwrite(buf, 1, written, png_ptr->fp);
if(err != written)
break;
else
check += err;
data += written;
remaining -= written;
}
while(remaining != 0);
}
if (check != length)
{
1995-11-28 17:22:13 +00:00
(*(png_ptr->error_fn))(png_ptr, "Write error");
1995-09-26 10:22:39 +00:00
}
}
#endif
1995-11-28 17:22:13 +00:00
1995-09-26 10:22:39 +00:00
/* Read the data from whatever input you are using. The default
routine reads from a file pointer. If you need to read from something
1995-11-28 17:22:13 +00:00
else, this is a good example of how to do it. 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 reads. This
should never be asked to read more then 64K on a 16 bit machine. The
cast to png_size_t is there for insurance. */
1995-09-26 10:22:39 +00:00
#ifndef USE_FAR_KEYWORD
1995-11-28 17:22:13 +00:00
static void
1995-09-26 10:22:39 +00:00
png_read_data(png_struct *png_ptr, png_bytef *data, png_uint_32 length)
{
png_uint_32 check;
check = fread(data, 1, (size_t)length, png_ptr->fp);
if (check != length)
{
1995-11-28 17:22:13 +00:00
(*(png_ptr->error_fn))(png_ptr, "Read error");
1995-09-26 10:22:39 +00:00
}
}
#else
1995-11-28 17:22:13 +00:00
static void
1995-09-26 10:22:39 +00:00
png_read_data(png_struct *png_ptr, png_bytef *data, png_uint_32 length)
{
png_uint_32 check;
png_byte *n_data;
/* Check if data really is near. If so, use usual code. */
#ifdef _MSC_VER
/* do it this way just to quiet warning */
FP_OFF(n_data) = FP_OFF(data);
if(FP_SEG(n_data) == FP_SEG(data))
#else
/* this works in MSC also but with lost segment warning */
n_data = (png_byte *)data;
if((png_bytef *)n_data == data)
#endif
{
check = fread(n_data, 1, (size_t)length, png_ptr->fp);
}
else
{
png_byte buf[NEAR_BUF_SIZE];
png_size_t read, remaining, err;
check = 0;
remaining = (png_size_t)length;
do
{
read = MIN(NEAR_BUF_SIZE,remaining);
err = fread(buf, 1, read, png_ptr->fp);
png_memcpy(data,buf,read); /* copy far buffer to near buffer */
if(err != read)
break;
else
check += err;
data += read;
remaining -= read;
}
while(remaining != 0);
}
if (check != length)
{
1995-11-28 17:22:13 +00:00
(*(png_ptr->error_fn))(png_ptr, "Read error");
1995-09-26 10:22:39 +00:00
}
}
#endif
1995-11-28 17:22:13 +00:00
/* This function does nothing, and is used for the write function on
a read, and vice-versa. It is an error if this function is
actually called. */
static void
png_empty_rw(png_struct *png_ptr, png_bytef *data, png_uint_32 length)
{
if (png_ptr->read_data_fn == png_empty_rw)
{
(*(png_ptr->error_fn))(png_ptr, "Invalid read on a write device");
}
else /* if (png_ptr->write_data_fn == png_empty_rw) */
{
(*(png_ptr->error_fn))(png_ptr, "Invalid write on a read device");
}
}
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
/* This function does nothing, and is supplied for user I/O functions which
do not do any buffering. This function is set when NULL is supplied for
the flush function pointer. */
static void
png_empty_flush(png_struct *png_ptr)
{
}
/* Write out any remaining output that is stored in the output buffers.
If you supply a new write routine, you will probably need to supply a
replacement for this routine as well. */
static void
png_output_flush(png_struct *png_ptr)
{
fflush(png_ptr->fp);
}
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* This function does nothing, and is called if the user supplies null
when setting the error function. */
static void
png_empty_error(png_structf *png_ptr, char *message)
{
#ifdef USE_FAR_KEYWORD
{
jmp_buf jmpbuf;
png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
longjmp(jmpbuf, 1);
}
#else
longjmp(png_ptr->jmpbuf, 1);
#endif
}
/* This function is called whenever there is an error. Replace with a
function you wish to handle the error. Note that this function
MUST NOT return, or the program will crash. To be consistent with
the examples for the library and this function, you could call
longjmp(pnt_ptr->jmpbuf) to return to the program at the location of
the last setjmp(png_ptr->jmpbuf) after an error. */
static void
png_error(png_structf *png_ptr, char *message)
{
fprintf(stderr, "libpng error: %s\n", message);
png_empty_error(png_ptr, message);
}
/* This function does nothing, and is called if the user supplies null
when setting the warning function. */
static void
png_empty_warning(png_struct *png_ptr, char *message)
{
}
/* This function is called when there is a warning, but the library
thinks it can continue anyway. You don't have to do anything here
if you don't want to. In the default configuration, png_ptr is
not used, but it is passed in case it may be useful. */
static void
png_warning(png_struct *png_ptr, char *message)
{
fprintf(stderr, "libpng warning: %s\n", message);
}
/* This function allows the application to supply new output functions for
libpng if standard C streams aren't being used. The new write function
should call (*(png_ptr->error_fn))("Error message") to exit and output
any fatal error messages if it cannot output the correct number of bytes.
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 which takes as its
arguments a pointer to a png_struct, a pointer to
data to be written, and a 32-bit unsigned int which is
the number of bytes to be written. The new write
function should call (*(png_ptr->error_fn))("Error msg")
to exit and output any fatal error messages.
flush_data_fn - pointer to a new flush function which 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, this parameter can be NULL. 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. */
void
png_set_write_fn(png_struct *png_ptr, void *io_ptr, png_rw_ptr write_data_fn,
png_flush_ptr output_flush_fn)
{
png_ptr->io_ptr = io_ptr;
if (write_data_fn == NULL)
{
(*(png_ptr->error_fn))(png_ptr, "NULL write function pointer given");
}
png_ptr->write_data_fn = write_data_fn;
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
if (output_flush_fn == NULL)
{
png_ptr->output_flush_fn = png_empty_flush;
}
else
{
png_ptr->output_flush_fn = output_flush_fn;
}
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* It is an error to write to a read device */
png_ptr->read_data_fn = png_empty_rw;
}
/* This function allows the application to supply a new input function
for libpng if standard C streams aren't being used. The new read function
should call (*(png_ptr->error_fn))("Error message") to exit and output
any fatal error messages if the desired number of bytes is not available.
This function takes as its arguments:
png_ptr - pointer to a png input data structure
io_ptr - pointer to user supplied structure containing info about
the input functions. May be NULL.
read_data_fn - pointer to a new input function which takes as it's
arguments a pointer to a png_struct, a pointer to
a location where input data can be stored, and a 32-bit
unsigned int which is the number of bytes to be read. */
void
png_set_read_fn(png_struct *png_ptr, void *io_ptr, png_rw_ptr read_data_fn)
{
png_ptr->io_ptr = io_ptr;
if (read_data_fn == NULL)
{
(*(png_ptr->error_fn))(png_ptr, "NULL read function pointer given");
}
png_ptr->read_data_fn = read_data_fn;
/* It is an error to write to a read device */
png_ptr->write_data_fn = png_empty_rw;
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
png_ptr->output_flush_fn = png_empty_flush;
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
}
/* This function returns a pointer to the io_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. */
void *
png_get_io_ptr(png_struct *png_ptr)
{
return png_ptr->io_ptr;
}
/* 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
error return method used in the default routine calls
longjmp(png_ptr->jmpbuf, 1), or exits if setjmp(png_ptr->jmpbuf) has never
been called. */
void
png_set_msg_fn(png_struct *png_ptr, void *msg_ptr, png_msg_ptr error_fn,
png_msg_ptr warning_fn)
{
png_ptr->msg_ptr = msg_ptr;
if (error_fn == NULL)
{
png_ptr->error_fn = png_empty_error;
}
else
{
png_ptr->error_fn = error_fn;
}
if (warning_fn == NULL)
{
png_ptr->warning_fn = png_empty_warning;
}
else
{
png_ptr->warning_fn = warning_fn;
}
}
/* This function returns a pointer to the msg_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. */
void *
png_get_msg_ptr(png_struct *png_ptr)
{
return png_ptr->msg_ptr;
}
/* Initialize the default input/output functions for the png file.
If you change the read, write or message routines, can call
either png_set_read_fn(...), png_set_write_fn(...), etc. to change
individual functions after a call to png_init_io(...). You can also
call one of png_set_read_fn(...) or png_set_write_fn(...), AND
png_set_msg_fn(...) instead of png_init_io(...) if you aren't using
any of the default libpng functions. */
1995-09-26 10:22:39 +00:00
void
png_init_io(png_struct *png_ptr, FILE *fp)
{
png_ptr->fp = fp;
1995-11-28 17:22:13 +00:00
png_ptr->error_fn = png_error;
png_ptr->warning_fn = png_warning;
png_ptr->write_data_fn = png_write_data;
png_ptr->read_data_fn = png_read_data;
1995-09-26 10:22:39 +00:00
1995-11-28 17:22:13 +00:00
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
png_ptr->output_flush_fn = png_output_flush;
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
}