src/png/pngwio.c

   1
   2 /* pngwio.c - functions for data output
   3  *
   4  * libpng 1.0.3 - January 14, 1999
   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, 1999 Glenn Randers-Pehrson
   9  *
  10  * This file provides a location for all output.  Users who need
  11  * special handling are expected to write functions that have the same
  12  * arguments as these and perform similar functions, but that possibly
  13  * use different output methods.  Note that you shouldn't change these
  14  * functions, but rather write replacement functions and then change
  15  * them at run time with png_set_write_fn(...).
  16  */
  17
  18 #define PNG_INTERNAL
  19 #include "png.h"
  20
  21 /* Write the data to whatever output you are using.  The default routine
  22    writes to a file pointer.  Note that this routine sometimes gets called
  23    with very small lengths, so you should implement some kind of simple
  24    buffering if you are using unbuffered writes.  This should never be asked
  25    to write more than 64K on a 16 bit machine.  */
  26
  27 void
  28 png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  29 {
  30    if (png_ptr->write_data_fn != NULL )
  31       (*(png_ptr->write_data_fn))(png_ptr, data, length);
  32    else
  33       png_error(png_ptr, "Call to NULL write function");
  34 }
  35
  36 #if !defined(PNG_NO_STDIO)
  37 /* This is the function that does the actual writing of data.  If you are
  38    not writing to a standard C stream, you should create a replacement
  39    write_data function and use it at run time with png_set_write_fn(), rather
  40    than changing the library. */
  41 #ifndef USE_FAR_KEYWORD
  42 #ifdef __VISAGECPP__
  43 static void _Optlink
  44 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  45 #else
  46 static void
  47 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  48 #endif
  49 {
  50    png_uint_32 check;
  51
  52    check = fwrite(data, 1, length, (FILE *)(png_ptr->io_ptr));
  53    if (check != length)
  54    {
  55       png_error(png_ptr, "Write Error");
  56    }
  57 }
  58 #else
  59 /* this is the model-independent version. Since the standard I/O library
  60    can't handle far buffers in the medium and small models, we have to copy
  61    the data.
  62 */
  63
  64 #define NEAR_BUF_SIZE 1024
  65 #define MIN(a,b) (a <= b ? a : b)
  66
  67 #ifdef __VISAGECPP__
  68 static void _Optlink
  69 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  70 #else
  71 static void
  72 png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
  73 #endif
  74 {
  75    png_uint_32 check;
  76    png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
  77    FILE *io_ptr;
  78
  79    /* Check if data really is near. If so, use usual code. */
  80    near_data = (png_byte *)CVT_PTR_NOCHECK(data);
  81    io_ptr = (FILE *)CVT_PTR(png_ptr->io_ptr);
  82    if ((png_bytep)near_data == data)
  83    {
  84       check = fwrite(near_data, 1, length, io_ptr);
  85    }
  86    else
  87    {
  88       png_byte buf[NEAR_BUF_SIZE];
  89       png_size_t written, remaining, err;
  90       check = 0;
  91       remaining = length;
  92       do
  93       {
  94          written = MIN(NEAR_BUF_SIZE, remaining);
  95          png_memcpy(buf, data, written); /* copy far buffer to near buffer */
  96          err = fwrite(buf, 1, written, io_ptr);
  97          if (err != written)
  98             break;
  99          else
 100             check += err;
 101          data += written;
 102          remaining -= written;
 103       }
 104       while (remaining != 0);
 105    }
 106    if (check != length)
 107    {
 108       png_error(png_ptr, "Write Error");
 109    }
 110 }
 111
 112 #endif
 113 #endif
 114
 115 /* This function is called to output any data pending writing (normally
 116    to disk).  After png_flush is called, there should be no data pending
 117    writing in any buffers. */
 118 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 119 void
 120 png_flush(png_structp png_ptr)
 121 {
 122    if (png_ptr->output_flush_fn != NULL)
 123       (*(png_ptr->output_flush_fn))(png_ptr);
 124 }
 125
 126 #if !defined(PNG_NO_STDIO)
 127 #ifdef __VISAGECPP__
 128 static void _Optlink
 129 png_default_flush(png_structp png_ptr)
 130 #else
 131 static void
 132 png_default_flush(png_structp png_ptr)
 133 #endif
 134 {
 135    FILE *io_ptr;
 136    io_ptr = (FILE *)CVT_PTR((png_ptr->io_ptr));
 137    if (io_ptr != NULL)
 138       fflush(io_ptr);
 139 }
 140 #endif
 141 #endif
 142
 143 /* This function allows the application to supply new output functions for
 144    libpng if standard C streams aren't being used.
 145
 146    This function takes as its arguments:
 147    png_ptr       - pointer to a png output data structure
 148    io_ptr        - pointer to user supplied structure containing info about
 149                    the output functions.  May be NULL.
 150    write_data_fn - pointer to a new output function that takes as its
 151                    arguments a pointer to a png_struct, a pointer to
 152                    data to be written, and a 32-bit unsigned int that is
 153                    the number of bytes to be written.  The new write
 154                    function should call png_error(png_ptr, "Error msg")
 155                    to exit and output any fatal error messages.
 156    flush_data_fn - pointer to a new flush function that takes as its
 157                    arguments a pointer to a png_struct.  After a call to
 158                    the flush function, there should be no data in any buffers
 159                    or pending transmission.  If the output method doesn't do
 160                    any buffering of ouput, a function prototype must still be
 161                    supplied although it doesn't have to do anything.  If
 162                    PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
 163                    time, output_flush_fn will be ignored, although it must be
 164                    supplied for compatibility. */
 165 void
 166 png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
 167    png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
 168 {
 169    png_ptr->io_ptr = io_ptr;
 170
 171 #if !defined(PNG_NO_STDIO)
 172    if (write_data_fn != NULL)
 173       png_ptr->write_data_fn = write_data_fn;
 174    else
 175       png_ptr->write_data_fn = png_default_write_data;
 176 #else
 177    png_ptr->write_data_fn = write_data_fn;
 178 #endif
 179
 180 #if defined(PNG_WRITE_FLUSH_SUPPORTED)
 181 #if !defined(PNG_NO_STDIO)
 182    if (output_flush_fn != NULL)
 183       png_ptr->output_flush_fn = output_flush_fn;
 184    else
 185       png_ptr->output_flush_fn = png_default_flush;
 186 #else
 187    png_ptr->output_flush_fn = output_flush_fn;
 188 #endif
 189 #endif /* PNG_WRITE_FLUSH_SUPPORTED */
 190
 191    /* It is an error to read while writing a png file */
 192    if (png_ptr->read_data_fn != NULL)
 193    {
 194       png_ptr->read_data_fn = NULL;
 195       png_warning(png_ptr,
 196          "Attempted to set both read_data_fn and write_data_fn in");
 197       png_warning(png_ptr,
 198          "the same structure.  Resetting read_data_fn to NULL.");
 199    }
 200 }
 201
 202 #if defined(USE_FAR_KEYWORD)
 203 #if defined(_MSC_VER)
 204 void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
 205 {
 206    void *near_ptr;
 207    void FAR *far_ptr;
 208    FP_OFF(near_ptr) = FP_OFF(ptr);
 209    far_ptr = (void FAR *)near_ptr;
 210    if(check != 0)
 211       if(FP_SEG(ptr) != FP_SEG(far_ptr))
 212          png_error(png_ptr,"segment lost in conversion");
 213    return(near_ptr);
 214 }
 215 #  else
 216 void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)
 217 {
 218    void *near_ptr;
 219    void FAR *far_ptr;
 220    near_ptr = (void FAR *)ptr;
 221    far_ptr = (void FAR *)near_ptr;
 222    if(check != 0)
 223       if(far_ptr != ptr)
 224          png_error(png_ptr,"segment lost in conversion");
 225    return(near_ptr);
 226 }
 227 #   endif
 228 #   endif