Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | |
2 | /* pngwio.c - functions for data output | |
3 | * | |
a626cc03 | 4 | * libpng 1.0.3 - January 14, 1999 |
c801d85f KB |
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 | |
a626cc03 | 8 | * Copyright (c) 1998, 1999 Glenn Randers-Pehrson |
c801d85f | 9 | * |
a626cc03 RR |
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 | |
c801d85f KB |
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 | |
a626cc03 | 19 | #include "png.h" |
c801d85f KB |
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 | |
a626cc03 | 25 | to write more than 64K on a 16 bit machine. */ |
c801d85f KB |
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) | |
a626cc03 | 37 | /* This is the function that does the actual writing of data. If you are |
c801d85f KB |
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 | |
e6ebb514 DW |
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 | |
c801d85f KB |
46 | static void |
47 | png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) | |
e6ebb514 | 48 | #endif |
c801d85f KB |
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 | ||
e6ebb514 DW |
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 | |
c801d85f KB |
71 | static void |
72 | png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) | |
e6ebb514 | 73 | #endif |
c801d85f KB |
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) | |
e6ebb514 DW |
127 | #ifdef __VISAGECPP__ |
128 | static void _Optlink | |
129 | png_default_flush(png_structp png_ptr) | |
130 | #else | |
c801d85f KB |
131 | static void |
132 | png_default_flush(png_structp png_ptr) | |
e6ebb514 | 133 | #endif |
c801d85f KB |
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. | |
a626cc03 | 150 | write_data_fn - pointer to a new output function that takes as its |
c801d85f | 151 | arguments a pointer to a png_struct, a pointer to |
a626cc03 | 152 | data to be written, and a 32-bit unsigned int that is |
c801d85f KB |
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. | |
a626cc03 | 156 | flush_data_fn - pointer to a new flush function that takes as its |
c801d85f KB |
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 */ | |
a626cc03 RR |
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 | } | |
c801d85f KB |
200 | } |
201 | ||
a626cc03 RR |
202 | #if defined(USE_FAR_KEYWORD) |
203 | #if defined(_MSC_VER) | |
c801d85f KB |
204 | void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) |
205 | { | |
a626cc03 | 206 | void *near_ptr; |
c801d85f KB |
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 | { | |
a626cc03 | 218 | void *near_ptr; |
c801d85f KB |
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 |