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