src/png/pngrio.c

   1
   2 /* pngrio.c - functions for data input
   3  *
   4  * libpng 1.0.1
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
   7  * Copyright (c) 1996, 1997 Andreas Dilger
   8  * Copyright (c) 1998, Glenn Randers-Pehrson
   9  * March 15, 1998
  10  *
  11  * This file provides a location for all input.  Users which need
  12  * special handling are expected to write a function which has the same
  13  * arguments as this, and perform a similar function, but possibly has
  14  * a different input method.  Note that you shouldn't change this
  15  * function, but rather write a replacement function and then make
  16  * libpng use it at run time with png_set_read_fn(...).
  17  */
  18
  19 #define PNG_INTERNAL
  20 #include "../png/png.h"
  21
  22 /* Read the data from whatever input you are using.  The default routine
  23    reads from a file pointer.  Note that this routine sometimes gets called
  24    with very small lengths, so you should implement some kind of simple
  25    buffering if you are using unbuffered reads.  This should never be asked
  26    to read more then 64K on a 16 bit machine. */
  27 void
  28 png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  29 {
  30    png_debug1(4,"reading %d bytes\n", length);
  31    if (png_ptr->read_data_fn != NULL)
  32       (*(png_ptr->read_data_fn))(png_ptr, data, length);
  33    else
  34       png_error(png_ptr, "Call to NULL read function");
  35 }
  36
  37 #if !defined(PNG_NO_STDIO)
  38 /* This is the function which does the actual reading of data.  If you are
  39    not reading from a standard C stream, you should create a replacement
  40    read_data function and use it at run time with png_set_read_fn(), rather
  41    than changing the library. */
  42 #ifndef USE_FAR_KEYWORD
  43 static void
  44 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  45 {
  46    png_size_t check;
  47
  48    /* fread() returns 0 on error, so it is OK to store this in a png_size_t
  49     * instead of an int, which is what fread() actually returns.
  50     */
  51    check = (png_size_t)fread(data, (png_size_t)1, length,
  52       (FILE *)png_ptr->io_ptr);
  53
  54    if (check != length)
  55    {
  56       png_error(png_ptr, "Read Error");
  57    }
  58 }
  59 #else
  60 /* this is the model-independent version. Since the standard I/O library
  61    can't handle far buffers in the medium and small models, we have to copy
  62    the data.
  63 */
  64
  65 #define NEAR_BUF_SIZE 1024
  66 #define MIN(a,b) (a <= b ? a : b)
  67
  68 static void
  69 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  70 {
  71    int check;
  72    png_byte *n_data;
  73    FILE *io_ptr;
  74
  75    /* Check if data really is near. If so, use usual code. */
  76    n_data = (png_byte *)CVT_PTR_NOCHECK(data);
  77    io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
  78    if ((png_bytep)n_data == data)
  79    {
  80       check = fread(n_data, 1, length, io_ptr);
  81    }
  82    else
  83    {
  84       png_byte buf[NEAR_BUF_SIZE];
  85       png_size_t read, remaining, err;
  86       check = 0;
  87       remaining = length;
  88       do
  89       {
  90          read = MIN(NEAR_BUF_SIZE, remaining);
  91          err = fread(buf, (png_size_t)1, read, io_ptr);
  92          png_memcpy(data, buf, read); /* copy far buffer to near buffer */
  93          if(err != read)
  94             break;
  95          else
  96             check += err;
  97          data += read;
  98          remaining -= read;
  99       }
 100       while (remaining != 0);
 101    }
 102    if ((png_uint_32)check != (png_uint_32)length)
 103    {
 104       png_error(png_ptr, "read Error");
 105    }
 106 }
 107 #endif
 108 #endif
 109
 110 /* This function allows the application to supply a new input function
 111    for libpng if standard C streams aren't being used.
 112
 113    This function takes as its arguments:
 114    png_ptr      - pointer to a png input data structure
 115    io_ptr       - pointer to user supplied structure containing info about
 116                   the input functions.  May be NULL.
 117    read_data_fn - pointer to a new input function which takes as it's
 118                   arguments a pointer to a png_struct, a pointer to
 119                   a location where input data can be stored, and a 32-bit
 120                   unsigned int which is the number of bytes to be read.
 121                   To exit and output any fatal error messages the new write
 122                   function should call png_error(png_ptr, "Error msg"). */
 123 void
 124 png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
 125    png_rw_ptr read_data_fn)
 126 {
 127    png_ptr->io_ptr = io_ptr;
 128
 129 #if !defined(PNG_NO_STDIO)
 130    if (read_data_fn != NULL)
 131       png_ptr->read_data_fn = read_data_fn;
 132    else
 133       png_ptr->read_data_fn = png_default_read_data;
 134 #else
 135    png_ptr->read_data_fn = read_data_fn;
 136 #endif
 137
 138    /* It is an error to write to a read device */
 139    png_ptr->write_data_fn = NULL;
 140
 141 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 142    png_ptr->output_flush_fn = NULL;
 143 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 144 }
 145