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