Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
96 | giacomo | 1 | |
2 | /* pngwrite.c - general routines to write a PNG file |
||
3 | * |
||
4 | * libpng 1.2.5 - October 3, 2002 |
||
5 | * For conditions of distribution and use, see copyright notice in png.h |
||
6 | * Copyright (c) 1998-2002 Glenn Randers-Pehrson |
||
7 | * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
||
8 | * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
||
9 | */ |
||
10 | |||
11 | /* get internal access to png.h */ |
||
12 | #define PNG_INTERNAL |
||
13 | #include "png.h" |
||
14 | #ifdef PNG_WRITE_SUPPORTED |
||
15 | |||
16 | /* Writes all the PNG information. This is the suggested way to use the |
||
17 | * library. If you have a new chunk to add, make a function to write it, |
||
18 | * and put it in the correct location here. If you want the chunk written |
||
19 | * after the image data, put it in png_write_end(). I strongly encourage |
||
20 | * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing |
||
21 | * the chunk, as that will keep the code from breaking if you want to just |
||
22 | * write a plain PNG file. If you have long comments, I suggest writing |
||
23 | * them in png_write_end(), and compressing them. |
||
24 | */ |
||
25 | void PNGAPI |
||
26 | png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) |
||
27 | { |
||
28 | png_debug(1, "in png_write_info_before_PLTE\n"); |
||
29 | if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
||
30 | { |
||
31 | png_write_sig(png_ptr); /* write PNG signature */ |
||
32 | #if defined(PNG_MNG_FEATURES_SUPPORTED) |
||
33 | if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) |
||
34 | { |
||
35 | png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); |
||
36 | png_ptr->mng_features_permitted=0; |
||
37 | } |
||
38 | #endif |
||
39 | /* write IHDR information. */ |
||
40 | png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, |
||
41 | info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, |
||
42 | info_ptr->filter_type, |
||
43 | #if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
||
44 | info_ptr->interlace_type); |
||
45 | #else |
||
46 | 0); |
||
47 | #endif |
||
48 | /* the rest of these check to see if the valid field has the appropriate |
||
49 | flag set, and if it does, writes the chunk. */ |
||
50 | #if defined(PNG_WRITE_gAMA_SUPPORTED) |
||
51 | if (info_ptr->valid & PNG_INFO_gAMA) |
||
52 | { |
||
53 | # ifdef PNG_FLOATING_POINT_SUPPORTED |
||
54 | png_write_gAMA(png_ptr, info_ptr->gamma); |
||
55 | #else |
||
56 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
57 | png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); |
||
58 | # endif |
||
59 | #endif |
||
60 | } |
||
61 | #endif |
||
62 | #if defined(PNG_WRITE_sRGB_SUPPORTED) |
||
63 | if (info_ptr->valid & PNG_INFO_sRGB) |
||
64 | png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); |
||
65 | #endif |
||
66 | #if defined(PNG_WRITE_iCCP_SUPPORTED) |
||
67 | if (info_ptr->valid & PNG_INFO_iCCP) |
||
68 | png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, |
||
69 | info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); |
||
70 | #endif |
||
71 | #if defined(PNG_WRITE_sBIT_SUPPORTED) |
||
72 | if (info_ptr->valid & PNG_INFO_sBIT) |
||
73 | png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); |
||
74 | #endif |
||
75 | #if defined(PNG_WRITE_cHRM_SUPPORTED) |
||
76 | if (info_ptr->valid & PNG_INFO_cHRM) |
||
77 | { |
||
78 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
79 | png_write_cHRM(png_ptr, |
||
80 | info_ptr->x_white, info_ptr->y_white, |
||
81 | info_ptr->x_red, info_ptr->y_red, |
||
82 | info_ptr->x_green, info_ptr->y_green, |
||
83 | info_ptr->x_blue, info_ptr->y_blue); |
||
84 | #else |
||
85 | # ifdef PNG_FIXED_POINT_SUPPORTED |
||
86 | png_write_cHRM_fixed(png_ptr, |
||
87 | info_ptr->int_x_white, info_ptr->int_y_white, |
||
88 | info_ptr->int_x_red, info_ptr->int_y_red, |
||
89 | info_ptr->int_x_green, info_ptr->int_y_green, |
||
90 | info_ptr->int_x_blue, info_ptr->int_y_blue); |
||
91 | # endif |
||
92 | #endif |
||
93 | } |
||
94 | #endif |
||
95 | #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
||
96 | if (info_ptr->unknown_chunks_num) |
||
97 | { |
||
98 | png_unknown_chunk *up; |
||
99 | |||
100 | png_debug(5, "writing extra chunks\n"); |
||
101 | |||
102 | for (up = info_ptr->unknown_chunks; |
||
103 | up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
||
104 | up++) |
||
105 | { |
||
106 | int keep=png_handle_as_unknown(png_ptr, up->name); |
||
107 | if (keep != HANDLE_CHUNK_NEVER && |
||
108 | up->location && (!(up->location & PNG_HAVE_PLTE)) && |
||
109 | ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
||
110 | (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
||
111 | { |
||
112 | png_write_chunk(png_ptr, up->name, up->data, up->size); |
||
113 | } |
||
114 | } |
||
115 | } |
||
116 | #endif |
||
117 | png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; |
||
118 | } |
||
119 | } |
||
120 | |||
121 | void PNGAPI |
||
122 | png_write_info(png_structp png_ptr, png_infop info_ptr) |
||
123 | { |
||
124 | #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
||
125 | int i; |
||
126 | #endif |
||
127 | |||
128 | png_debug(1, "in png_write_info\n"); |
||
129 | |||
130 | png_write_info_before_PLTE(png_ptr, info_ptr); |
||
131 | |||
132 | if (info_ptr->valid & PNG_INFO_PLTE) |
||
133 | png_write_PLTE(png_ptr, info_ptr->palette, |
||
134 | (png_uint_32)info_ptr->num_palette); |
||
135 | else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
136 | png_error(png_ptr, "Valid palette required for paletted images\n"); |
||
137 | |||
138 | #if defined(PNG_WRITE_tRNS_SUPPORTED) |
||
139 | if (info_ptr->valid & PNG_INFO_tRNS) |
||
140 | { |
||
141 | #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
||
142 | /* invert the alpha channel (in tRNS) */ |
||
143 | if ((png_ptr->transformations & PNG_INVERT_ALPHA) && |
||
144 | info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
145 | { |
||
146 | int j; |
||
147 | for (j=0; j<(int)info_ptr->num_trans; j++) |
||
148 | info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); |
||
149 | } |
||
150 | #endif |
||
151 | png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), |
||
152 | info_ptr->num_trans, info_ptr->color_type); |
||
153 | } |
||
154 | #endif |
||
155 | #if defined(PNG_WRITE_bKGD_SUPPORTED) |
||
156 | if (info_ptr->valid & PNG_INFO_bKGD) |
||
157 | png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); |
||
158 | #endif |
||
159 | #if defined(PNG_WRITE_hIST_SUPPORTED) |
||
160 | if (info_ptr->valid & PNG_INFO_hIST) |
||
161 | png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); |
||
162 | #endif |
||
163 | #if defined(PNG_WRITE_oFFs_SUPPORTED) |
||
164 | if (info_ptr->valid & PNG_INFO_oFFs) |
||
165 | png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, |
||
166 | info_ptr->offset_unit_type); |
||
167 | #endif |
||
168 | #if defined(PNG_WRITE_pCAL_SUPPORTED) |
||
169 | if (info_ptr->valid & PNG_INFO_pCAL) |
||
170 | png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, |
||
171 | info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, |
||
172 | info_ptr->pcal_units, info_ptr->pcal_params); |
||
173 | #endif |
||
174 | #if defined(PNG_WRITE_sCAL_SUPPORTED) |
||
175 | if (info_ptr->valid & PNG_INFO_sCAL) |
||
176 | #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
||
177 | png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, |
||
178 | info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); |
||
179 | #else |
||
180 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
181 | png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, |
||
182 | info_ptr->scal_s_width, info_ptr->scal_s_height); |
||
183 | #else |
||
184 | png_warning(png_ptr, |
||
185 | "png_write_sCAL not supported; sCAL chunk not written.\n"); |
||
186 | #endif |
||
187 | #endif |
||
188 | #endif |
||
189 | #if defined(PNG_WRITE_pHYs_SUPPORTED) |
||
190 | if (info_ptr->valid & PNG_INFO_pHYs) |
||
191 | png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, |
||
192 | info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); |
||
193 | #endif |
||
194 | #if defined(PNG_WRITE_tIME_SUPPORTED) |
||
195 | if (info_ptr->valid & PNG_INFO_tIME) |
||
196 | { |
||
197 | png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
||
198 | png_ptr->mode |= PNG_WROTE_tIME; |
||
199 | } |
||
200 | #endif |
||
201 | #if defined(PNG_WRITE_sPLT_SUPPORTED) |
||
202 | if (info_ptr->valid & PNG_INFO_sPLT) |
||
203 | for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
||
204 | png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); |
||
205 | #endif |
||
206 | #if defined(PNG_WRITE_TEXT_SUPPORTED) |
||
207 | /* Check to see if we need to write text chunks */ |
||
208 | for (i = 0; i < info_ptr->num_text; i++) |
||
209 | { |
||
210 | png_debug2(2, "Writing header text chunk %d, type %d\n", i, |
||
211 | info_ptr->text[i].compression); |
||
212 | /* an internationalized chunk? */ |
||
213 | if (info_ptr->text[i].compression > 0) |
||
214 | { |
||
215 | #if defined(PNG_WRITE_iTXt_SUPPORTED) |
||
216 | /* write international chunk */ |
||
217 | png_write_iTXt(png_ptr, |
||
218 | info_ptr->text[i].compression, |
||
219 | info_ptr->text[i].key, |
||
220 | info_ptr->text[i].lang, |
||
221 | info_ptr->text[i].lang_key, |
||
222 | info_ptr->text[i].text); |
||
223 | #else |
||
224 | png_warning(png_ptr, "Unable to write international text\n"); |
||
225 | #endif |
||
226 | /* Mark this chunk as written */ |
||
227 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
||
228 | } |
||
229 | /* If we want a compressed text chunk */ |
||
230 | else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) |
||
231 | { |
||
232 | #if defined(PNG_WRITE_zTXt_SUPPORTED) |
||
233 | /* write compressed chunk */ |
||
234 | png_write_zTXt(png_ptr, info_ptr->text[i].key, |
||
235 | info_ptr->text[i].text, 0, |
||
236 | info_ptr->text[i].compression); |
||
237 | #else |
||
238 | png_warning(png_ptr, "Unable to write compressed text\n"); |
||
239 | #endif |
||
240 | /* Mark this chunk as written */ |
||
241 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
||
242 | } |
||
243 | else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
||
244 | { |
||
245 | #if defined(PNG_WRITE_tEXt_SUPPORTED) |
||
246 | /* write uncompressed chunk */ |
||
247 | png_write_tEXt(png_ptr, info_ptr->text[i].key, |
||
248 | info_ptr->text[i].text, |
||
249 | 0); |
||
250 | #else |
||
251 | png_warning(png_ptr, "Unable to write uncompressed text\n"); |
||
252 | #endif |
||
253 | /* Mark this chunk as written */ |
||
254 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
||
255 | } |
||
256 | } |
||
257 | #endif |
||
258 | #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
||
259 | if (info_ptr->unknown_chunks_num) |
||
260 | { |
||
261 | png_unknown_chunk *up; |
||
262 | |||
263 | png_debug(5, "writing extra chunks\n"); |
||
264 | |||
265 | for (up = info_ptr->unknown_chunks; |
||
266 | up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
||
267 | up++) |
||
268 | { |
||
269 | int keep=png_handle_as_unknown(png_ptr, up->name); |
||
270 | if (keep != HANDLE_CHUNK_NEVER && |
||
271 | up->location && (up->location & PNG_HAVE_PLTE) && |
||
272 | !(up->location & PNG_HAVE_IDAT) && |
||
273 | ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
||
274 | (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
||
275 | { |
||
276 | png_write_chunk(png_ptr, up->name, up->data, up->size); |
||
277 | } |
||
278 | } |
||
279 | } |
||
280 | #endif |
||
281 | } |
||
282 | |||
283 | /* Writes the end of the PNG file. If you don't want to write comments or |
||
284 | * time information, you can pass NULL for info. If you already wrote these |
||
285 | * in png_write_info(), do not write them again here. If you have long |
||
286 | * comments, I suggest writing them here, and compressing them. |
||
287 | */ |
||
288 | void PNGAPI |
||
289 | png_write_end(png_structp png_ptr, png_infop info_ptr) |
||
290 | { |
||
291 | png_debug(1, "in png_write_end\n"); |
||
292 | if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
||
293 | png_error(png_ptr, "No IDATs written into file"); |
||
294 | |||
295 | /* see if user wants us to write information chunks */ |
||
296 | if (info_ptr != NULL) |
||
297 | { |
||
298 | #if defined(PNG_WRITE_TEXT_SUPPORTED) |
||
299 | int i; /* local index variable */ |
||
300 | #endif |
||
301 | #if defined(PNG_WRITE_tIME_SUPPORTED) |
||
302 | /* check to see if user has supplied a time chunk */ |
||
303 | if ((info_ptr->valid & PNG_INFO_tIME) && |
||
304 | !(png_ptr->mode & PNG_WROTE_tIME)) |
||
305 | png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
||
306 | #endif |
||
307 | #if defined(PNG_WRITE_TEXT_SUPPORTED) |
||
308 | /* loop through comment chunks */ |
||
309 | for (i = 0; i < info_ptr->num_text; i++) |
||
310 | { |
||
311 | png_debug2(2, "Writing trailer text chunk %d, type %d\n", i, |
||
312 | info_ptr->text[i].compression); |
||
313 | /* an internationalized chunk? */ |
||
314 | if (info_ptr->text[i].compression > 0) |
||
315 | { |
||
316 | #if defined(PNG_WRITE_iTXt_SUPPORTED) |
||
317 | /* write international chunk */ |
||
318 | png_write_iTXt(png_ptr, |
||
319 | info_ptr->text[i].compression, |
||
320 | info_ptr->text[i].key, |
||
321 | info_ptr->text[i].lang, |
||
322 | info_ptr->text[i].lang_key, |
||
323 | info_ptr->text[i].text); |
||
324 | #else |
||
325 | png_warning(png_ptr, "Unable to write international text\n"); |
||
326 | #endif |
||
327 | /* Mark this chunk as written */ |
||
328 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
||
329 | } |
||
330 | else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) |
||
331 | { |
||
332 | #if defined(PNG_WRITE_zTXt_SUPPORTED) |
||
333 | /* write compressed chunk */ |
||
334 | png_write_zTXt(png_ptr, info_ptr->text[i].key, |
||
335 | info_ptr->text[i].text, 0, |
||
336 | info_ptr->text[i].compression); |
||
337 | #else |
||
338 | png_warning(png_ptr, "Unable to write compressed text\n"); |
||
339 | #endif |
||
340 | /* Mark this chunk as written */ |
||
341 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
||
342 | } |
||
343 | else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
||
344 | { |
||
345 | #if defined(PNG_WRITE_tEXt_SUPPORTED) |
||
346 | /* write uncompressed chunk */ |
||
347 | png_write_tEXt(png_ptr, info_ptr->text[i].key, |
||
348 | info_ptr->text[i].text, 0); |
||
349 | #else |
||
350 | png_warning(png_ptr, "Unable to write uncompressed text\n"); |
||
351 | #endif |
||
352 | |||
353 | /* Mark this chunk as written */ |
||
354 | info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
||
355 | } |
||
356 | } |
||
357 | #endif |
||
358 | #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
||
359 | if (info_ptr->unknown_chunks_num) |
||
360 | { |
||
361 | png_unknown_chunk *up; |
||
362 | |||
363 | png_debug(5, "writing extra chunks\n"); |
||
364 | |||
365 | for (up = info_ptr->unknown_chunks; |
||
366 | up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
||
367 | up++) |
||
368 | { |
||
369 | int keep=png_handle_as_unknown(png_ptr, up->name); |
||
370 | if (keep != HANDLE_CHUNK_NEVER && |
||
371 | up->location && (up->location & PNG_AFTER_IDAT) && |
||
372 | ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
||
373 | (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
||
374 | { |
||
375 | png_write_chunk(png_ptr, up->name, up->data, up->size); |
||
376 | } |
||
377 | } |
||
378 | } |
||
379 | #endif |
||
380 | } |
||
381 | |||
382 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
383 | |||
384 | /* write end of PNG file */ |
||
385 | png_write_IEND(png_ptr); |
||
386 | #if 0 |
||
387 | /* This flush, added in libpng-1.0.8, causes some applications to crash |
||
388 | because they do not set png_ptr->output_flush_fn */ |
||
389 | png_flush(png_ptr); |
||
390 | #endif |
||
391 | } |
||
392 | |||
393 | #if defined(PNG_WRITE_tIME_SUPPORTED) |
||
394 | #if !defined(_WIN32_WCE) |
||
395 | /* "time.h" functions are not supported on WindowsCE */ |
||
396 | void PNGAPI |
||
397 | png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) |
||
398 | { |
||
399 | png_debug(1, "in png_convert_from_struct_tm\n"); |
||
400 | ptime->year = (png_uint_16)(1900 + ttime->tm_year); |
||
401 | ptime->month = (png_byte)(ttime->tm_mon + 1); |
||
402 | ptime->day = (png_byte)ttime->tm_mday; |
||
403 | ptime->hour = (png_byte)ttime->tm_hour; |
||
404 | ptime->minute = (png_byte)ttime->tm_min; |
||
405 | ptime->second = (png_byte)ttime->tm_sec; |
||
406 | } |
||
407 | |||
408 | void PNGAPI |
||
409 | png_convert_from_time_t(png_timep ptime, time_t ttime) |
||
410 | { |
||
411 | struct tm *tbuf; |
||
412 | |||
413 | png_debug(1, "in png_convert_from_time_t\n"); |
||
414 | tbuf = gmtime(&ttime); |
||
415 | png_convert_from_struct_tm(ptime, tbuf); |
||
416 | } |
||
417 | #endif |
||
418 | #endif |
||
419 | |||
420 | /* Initialize png_ptr structure, and allocate any memory needed */ |
||
421 | png_structp PNGAPI |
||
422 | png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, |
||
423 | png_error_ptr error_fn, png_error_ptr warn_fn) |
||
424 | { |
||
425 | #ifdef PNG_USER_MEM_SUPPORTED |
||
426 | return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
||
427 | warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); |
||
428 | } |
||
429 | |||
430 | /* Alternate initialize png_ptr structure, and allocate any memory needed */ |
||
431 | png_structp PNGAPI |
||
432 | png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, |
||
433 | png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
||
434 | png_malloc_ptr malloc_fn, png_free_ptr free_fn) |
||
435 | { |
||
436 | #endif /* PNG_USER_MEM_SUPPORTED */ |
||
437 | png_structp png_ptr; |
||
438 | #ifdef PNG_SETJMP_SUPPORTED |
||
439 | #ifdef USE_FAR_KEYWORD |
||
440 | jmp_buf jmpbuf; |
||
441 | #endif |
||
442 | #endif |
||
443 | int i; |
||
444 | png_debug(1, "in png_create_write_struct\n"); |
||
445 | #ifdef PNG_USER_MEM_SUPPORTED |
||
446 | png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
||
447 | (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
||
448 | #else |
||
449 | png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
||
450 | #endif /* PNG_USER_MEM_SUPPORTED */ |
||
451 | if (png_ptr == NULL) |
||
452 | return (NULL); |
||
453 | |||
454 | #if !defined(PNG_1_0_X) |
||
455 | #ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
||
456 | png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
||
457 | #endif |
||
458 | #endif /* PNG_1_0_X */ |
||
459 | |||
460 | #ifdef PNG_SETJMP_SUPPORTED |
||
461 | #ifdef USE_FAR_KEYWORD |
||
462 | if (setjmp(jmpbuf)) |
||
463 | #else |
||
464 | if (setjmp(png_ptr->jmpbuf)) |
||
465 | #endif |
||
466 | { |
||
467 | png_free(png_ptr, png_ptr->zbuf); |
||
468 | png_ptr->zbuf=NULL; |
||
469 | png_destroy_struct(png_ptr); |
||
470 | return (NULL); |
||
471 | } |
||
472 | #ifdef USE_FAR_KEYWORD |
||
473 | png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
||
474 | #endif |
||
475 | #endif |
||
476 | |||
477 | #ifdef PNG_USER_MEM_SUPPORTED |
||
478 | png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
||
479 | #endif /* PNG_USER_MEM_SUPPORTED */ |
||
480 | png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
||
481 | |||
482 | i=0; |
||
483 | do |
||
484 | { |
||
485 | if(user_png_ver[i] != png_libpng_ver[i]) |
||
486 | png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
||
487 | } while (png_libpng_ver[i++]); |
||
488 | |||
489 | if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
||
490 | { |
||
491 | /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
||
492 | * we must recompile any applications that use any older library version. |
||
493 | * For versions after libpng 1.0, we will be compatible, so we need |
||
494 | * only check the first digit. |
||
495 | */ |
||
496 | if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
||
497 | (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
||
498 | (user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
||
499 | { |
||
500 | #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
||
501 | char msg[80]; |
||
502 | if (user_png_ver) |
||
503 | { |
||
504 | sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
||
505 | user_png_ver); |
||
506 | png_warning(png_ptr, msg); |
||
507 | } |
||
508 | sprintf(msg, "Application is running with png.c from libpng-%.20s", |
||
509 | png_libpng_ver); |
||
510 | png_warning(png_ptr, msg); |
||
511 | #endif |
||
512 | #ifdef PNG_ERROR_NUMBERS_SUPPORTED |
||
513 | png_ptr->flags=0; |
||
514 | #endif |
||
515 | png_error(png_ptr, |
||
516 | "Incompatible libpng version in application and library"); |
||
517 | } |
||
518 | } |
||
519 | |||
520 | /* initialize zbuf - compression buffer */ |
||
521 | png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
||
522 | png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
||
523 | (png_uint_32)png_ptr->zbuf_size); |
||
524 | |||
525 | png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
||
526 | png_flush_ptr_NULL); |
||
527 | |||
528 | #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
||
529 | png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
||
530 | 1, png_doublep_NULL, png_doublep_NULL); |
||
531 | #endif |
||
532 | |||
533 | #ifdef PNG_SETJMP_SUPPORTED |
||
534 | /* Applications that neglect to set up their own setjmp() and then encounter |
||
535 | a png_error() will longjmp here. Since the jmpbuf is then meaningless we |
||
536 | abort instead of returning. */ |
||
537 | #ifdef USE_FAR_KEYWORD |
||
538 | if (setjmp(jmpbuf)) |
||
539 | PNG_ABORT(); |
||
540 | png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
||
541 | #else |
||
542 | if (setjmp(png_ptr->jmpbuf)) |
||
543 | PNG_ABORT(); |
||
544 | #endif |
||
545 | #endif |
||
546 | return (png_ptr); |
||
547 | } |
||
548 | |||
549 | /* Initialize png_ptr structure, and allocate any memory needed */ |
||
550 | #undef png_write_init |
||
551 | void PNGAPI |
||
552 | png_write_init(png_structp png_ptr) |
||
553 | { |
||
554 | /* We only come here via pre-1.0.7-compiled applications */ |
||
555 | png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); |
||
556 | } |
||
557 | |||
558 | void PNGAPI |
||
559 | png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, |
||
560 | png_size_t png_struct_size, png_size_t png_info_size) |
||
561 | { |
||
562 | /* We only come here via pre-1.0.12-compiled applications */ |
||
563 | #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
||
564 | if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size) |
||
565 | { |
||
566 | char msg[80]; |
||
567 | png_ptr->warning_fn=NULL; |
||
568 | if (user_png_ver) |
||
569 | { |
||
570 | sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
||
571 | user_png_ver); |
||
572 | png_warning(png_ptr, msg); |
||
573 | } |
||
574 | sprintf(msg, "Application is running with png.c from libpng-%.20s", |
||
575 | png_libpng_ver); |
||
576 | png_warning(png_ptr, msg); |
||
577 | } |
||
578 | #endif |
||
579 | if(sizeof(png_struct) > png_struct_size) |
||
580 | { |
||
581 | png_ptr->error_fn=NULL; |
||
582 | #ifdef PNG_ERROR_NUMBERS_SUPPORTED |
||
583 | png_ptr->flags=0; |
||
584 | #endif |
||
585 | png_error(png_ptr, |
||
586 | "The png struct allocated by the application for writing is too small."); |
||
587 | } |
||
588 | if(sizeof(png_info) > png_info_size) |
||
589 | { |
||
590 | png_ptr->error_fn=NULL; |
||
591 | #ifdef PNG_ERROR_NUMBERS_SUPPORTED |
||
592 | png_ptr->flags=0; |
||
593 | #endif |
||
594 | png_error(png_ptr, |
||
595 | "The info struct allocated by the application for writing is too small."); |
||
596 | } |
||
597 | png_write_init_3(&png_ptr, user_png_ver, png_struct_size); |
||
598 | } |
||
599 | |||
600 | |||
601 | void PNGAPI |
||
602 | png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, |
||
603 | png_size_t png_struct_size) |
||
604 | { |
||
605 | png_structp png_ptr=*ptr_ptr; |
||
606 | #ifdef PNG_SETJMP_SUPPORTED |
||
607 | jmp_buf tmp_jmp; /* to save current jump buffer */ |
||
608 | #endif |
||
609 | int i = 0; |
||
610 | do |
||
611 | { |
||
612 | if (user_png_ver[i] != png_libpng_ver[i]) |
||
613 | { |
||
614 | #ifdef PNG_LEGACY_SUPPORTED |
||
615 | png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
||
616 | #else |
||
617 | png_ptr->warning_fn=NULL; |
||
618 | png_warning(png_ptr, |
||
619 | "Application uses deprecated png_write_init() and should be recompiled."); |
||
620 | break; |
||
621 | #endif |
||
622 | } |
||
623 | } while (png_libpng_ver[i++]); |
||
624 | |||
625 | png_debug(1, "in png_write_init_3\n"); |
||
626 | |||
627 | #ifdef PNG_SETJMP_SUPPORTED |
||
628 | /* save jump buffer and error functions */ |
||
629 | png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
||
630 | #endif |
||
631 | |||
632 | if (sizeof(png_struct) > png_struct_size) |
||
633 | { |
||
634 | png_destroy_struct(png_ptr); |
||
635 | png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
||
636 | *ptr_ptr = png_ptr; |
||
637 | } |
||
638 | |||
639 | /* reset all variables to 0 */ |
||
640 | png_memset(png_ptr, 0, sizeof (png_struct)); |
||
641 | |||
642 | #if !defined(PNG_1_0_X) |
||
643 | #ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
||
644 | png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
||
645 | #endif |
||
646 | #endif /* PNG_1_0_X */ |
||
647 | |||
648 | #ifdef PNG_SETJMP_SUPPORTED |
||
649 | /* restore jump buffer */ |
||
650 | png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
||
651 | #endif |
||
652 | |||
653 | png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
||
654 | png_flush_ptr_NULL); |
||
655 | |||
656 | /* initialize zbuf - compression buffer */ |
||
657 | png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
||
658 | png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
||
659 | (png_uint_32)png_ptr->zbuf_size); |
||
660 | |||
661 | #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
||
662 | png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
||
663 | 1, png_doublep_NULL, png_doublep_NULL); |
||
664 | #endif |
||
665 | } |
||
666 | |||
667 | /* Write a few rows of image data. If the image is interlaced, |
||
668 | * either you will have to write the 7 sub images, or, if you |
||
669 | * have called png_set_interlace_handling(), you will have to |
||
670 | * "write" the image seven times. |
||
671 | */ |
||
672 | void PNGAPI |
||
673 | png_write_rows(png_structp png_ptr, png_bytepp row, |
||
674 | png_uint_32 num_rows) |
||
675 | { |
||
676 | png_uint_32 i; /* row counter */ |
||
677 | png_bytepp rp; /* row pointer */ |
||
678 | |||
679 | png_debug(1, "in png_write_rows\n"); |
||
680 | /* loop through the rows */ |
||
681 | for (i = 0, rp = row; i < num_rows; i++, rp++) |
||
682 | { |
||
683 | png_write_row(png_ptr, *rp); |
||
684 | } |
||
685 | } |
||
686 | |||
687 | /* Write the image. You only need to call this function once, even |
||
688 | * if you are writing an interlaced image. |
||
689 | */ |
||
690 | void PNGAPI |
||
691 | png_write_image(png_structp png_ptr, png_bytepp image) |
||
692 | { |
||
693 | png_uint_32 i; /* row index */ |
||
694 | int pass, num_pass; /* pass variables */ |
||
695 | png_bytepp rp; /* points to current row */ |
||
696 | |||
697 | png_debug(1, "in png_write_image\n"); |
||
698 | #if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
||
699 | /* intialize interlace handling. If image is not interlaced, |
||
700 | this will set pass to 1 */ |
||
701 | num_pass = png_set_interlace_handling(png_ptr); |
||
702 | #else |
||
703 | num_pass = 1; |
||
704 | #endif |
||
705 | /* loop through passes */ |
||
706 | for (pass = 0; pass < num_pass; pass++) |
||
707 | { |
||
708 | /* loop through image */ |
||
709 | for (i = 0, rp = image; i < png_ptr->height; i++, rp++) |
||
710 | { |
||
711 | png_write_row(png_ptr, *rp); |
||
712 | } |
||
713 | } |
||
714 | } |
||
715 | |||
716 | /* called by user to write a row of image data */ |
||
717 | void PNGAPI |
||
718 | png_write_row(png_structp png_ptr, png_bytep row) |
||
719 | { |
||
720 | png_debug2(1, "in png_write_row (row %ld, pass %d)\n", |
||
721 | png_ptr->row_number, png_ptr->pass); |
||
722 | /* initialize transformations and other stuff if first time */ |
||
723 | if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
||
724 | { |
||
725 | /* make sure we wrote the header info */ |
||
726 | if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
||
727 | png_error(png_ptr, |
||
728 | "png_write_info was never called before png_write_row."); |
||
729 | |||
730 | /* check for transforms that have been set but were defined out */ |
||
731 | #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) |
||
732 | if (png_ptr->transformations & PNG_INVERT_MONO) |
||
733 | png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); |
||
734 | #endif |
||
735 | #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) |
||
736 | if (png_ptr->transformations & PNG_FILLER) |
||
737 | png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); |
||
738 | #endif |
||
739 | #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
740 | if (png_ptr->transformations & PNG_PACKSWAP) |
||
741 | png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); |
||
742 | #endif |
||
743 | #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) |
||
744 | if (png_ptr->transformations & PNG_PACK) |
||
745 | png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); |
||
746 | #endif |
||
747 | #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) |
||
748 | if (png_ptr->transformations & PNG_SHIFT) |
||
749 | png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); |
||
750 | #endif |
||
751 | #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) |
||
752 | if (png_ptr->transformations & PNG_BGR) |
||
753 | png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); |
||
754 | #endif |
||
755 | #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) |
||
756 | if (png_ptr->transformations & PNG_SWAP_BYTES) |
||
757 | png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); |
||
758 | #endif |
||
759 | |||
760 | png_write_start_row(png_ptr); |
||
761 | } |
||
762 | |||
763 | #if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
||
764 | /* if interlaced and not interested in row, return */ |
||
765 | if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
||
766 | { |
||
767 | switch (png_ptr->pass) |
||
768 | { |
||
769 | case 0: |
||
770 | if (png_ptr->row_number & 0x07) |
||
771 | { |
||
772 | png_write_finish_row(png_ptr); |
||
773 | return; |
||
774 | } |
||
775 | break; |
||
776 | case 1: |
||
777 | if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
||
778 | { |
||
779 | png_write_finish_row(png_ptr); |
||
780 | return; |
||
781 | } |
||
782 | break; |
||
783 | case 2: |
||
784 | if ((png_ptr->row_number & 0x07) != 4) |
||
785 | { |
||
786 | png_write_finish_row(png_ptr); |
||
787 | return; |
||
788 | } |
||
789 | break; |
||
790 | case 3: |
||
791 | if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) |
||
792 | { |
||
793 | png_write_finish_row(png_ptr); |
||
794 | return; |
||
795 | } |
||
796 | break; |
||
797 | case 4: |
||
798 | if ((png_ptr->row_number & 0x03) != 2) |
||
799 | { |
||
800 | png_write_finish_row(png_ptr); |
||
801 | return; |
||
802 | } |
||
803 | break; |
||
804 | case 5: |
||
805 | if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) |
||
806 | { |
||
807 | png_write_finish_row(png_ptr); |
||
808 | return; |
||
809 | } |
||
810 | break; |
||
811 | case 6: |
||
812 | if (!(png_ptr->row_number & 0x01)) |
||
813 | { |
||
814 | png_write_finish_row(png_ptr); |
||
815 | return; |
||
816 | } |
||
817 | break; |
||
818 | } |
||
819 | } |
||
820 | #endif |
||
821 | |||
822 | /* set up row info for transformations */ |
||
823 | png_ptr->row_info.color_type = png_ptr->color_type; |
||
824 | png_ptr->row_info.width = png_ptr->usr_width; |
||
825 | png_ptr->row_info.channels = png_ptr->usr_channels; |
||
826 | png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; |
||
827 | png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
||
828 | png_ptr->row_info.channels); |
||
829 | |||
830 | png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
||
831 | (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
||
832 | |||
833 | png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type); |
||
834 | png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width); |
||
835 | png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels); |
||
836 | png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); |
||
837 | png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); |
||
838 | png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes); |
||
839 | |||
840 | /* Copy user's row into buffer, leaving room for filter byte. */ |
||
841 | png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row, |
||
842 | png_ptr->row_info.rowbytes); |
||
843 | |||
844 | #if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
||
845 | /* handle interlacing */ |
||
846 | if (png_ptr->interlaced && png_ptr->pass < 6 && |
||
847 | (png_ptr->transformations & PNG_INTERLACE)) |
||
848 | { |
||
849 | png_do_write_interlace(&(png_ptr->row_info), |
||
850 | png_ptr->row_buf + 1, png_ptr->pass); |
||
851 | /* this should always get caught above, but still ... */ |
||
852 | if (!(png_ptr->row_info.width)) |
||
853 | { |
||
854 | png_write_finish_row(png_ptr); |
||
855 | return; |
||
856 | } |
||
857 | } |
||
858 | #endif |
||
859 | |||
860 | /* handle other transformations */ |
||
861 | if (png_ptr->transformations) |
||
862 | png_do_write_transformations(png_ptr); |
||
863 | |||
864 | #if defined(PNG_MNG_FEATURES_SUPPORTED) |
||
865 | /* Write filter_method 64 (intrapixel differencing) only if |
||
866 | * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
||
867 | * 2. Libpng did not write a PNG signature (this filter_method is only |
||
868 | * used in PNG datastreams that are embedded in MNG datastreams) and |
||
869 | * 3. The application called png_permit_mng_features with a mask that |
||
870 | * included PNG_FLAG_MNG_FILTER_64 and |
||
871 | * 4. The filter_method is 64 and |
||
872 | * 5. The color_type is RGB or RGBA |
||
873 | */ |
||
874 | if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
||
875 | (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
||
876 | { |
||
877 | /* Intrapixel differencing */ |
||
878 | png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
||
879 | } |
||
880 | #endif |
||
881 | |||
882 | /* Find a filter if necessary, filter the row and write it out. */ |
||
883 | png_write_find_filter(png_ptr, &(png_ptr->row_info)); |
||
884 | |||
885 | if (png_ptr->write_row_fn != NULL) |
||
886 | (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
||
887 | } |
||
888 | |||
889 | #if defined(PNG_WRITE_FLUSH_SUPPORTED) |
||
890 | /* Set the automatic flush interval or 0 to turn flushing off */ |
||
891 | void PNGAPI |
||
892 | png_set_flush(png_structp png_ptr, int nrows) |
||
893 | { |
||
894 | png_debug(1, "in png_set_flush\n"); |
||
895 | png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); |
||
896 | } |
||
897 | |||
898 | /* flush the current output buffers now */ |
||
899 | void PNGAPI |
||
900 | png_write_flush(png_structp png_ptr) |
||
901 | { |
||
902 | int wrote_IDAT; |
||
903 | |||
904 | png_debug(1, "in png_write_flush\n"); |
||
905 | /* We have already written out all of the data */ |
||
906 | if (png_ptr->row_number >= png_ptr->num_rows) |
||
907 | return; |
||
908 | |||
909 | do |
||
910 | { |
||
911 | int ret; |
||
912 | |||
913 | /* compress the data */ |
||
914 | ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); |
||
915 | wrote_IDAT = 0; |
||
916 | |||
917 | /* check for compression errors */ |
||
918 | if (ret != Z_OK) |
||
919 | { |
||
920 | if (png_ptr->zstream.msg != NULL) |
||
921 | png_error(png_ptr, png_ptr->zstream.msg); |
||
922 | else |
||
923 | png_error(png_ptr, "zlib error"); |
||
924 | } |
||
925 | |||
926 | if (!(png_ptr->zstream.avail_out)) |
||
927 | { |
||
928 | /* write the IDAT and reset the zlib output buffer */ |
||
929 | png_write_IDAT(png_ptr, png_ptr->zbuf, |
||
930 | png_ptr->zbuf_size); |
||
931 | png_ptr->zstream.next_out = png_ptr->zbuf; |
||
932 | png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
||
933 | wrote_IDAT = 1; |
||
934 | } |
||
935 | } while(wrote_IDAT == 1); |
||
936 | |||
937 | /* If there is any data left to be output, write it into a new IDAT */ |
||
938 | if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) |
||
939 | { |
||
940 | /* write the IDAT and reset the zlib output buffer */ |
||
941 | png_write_IDAT(png_ptr, png_ptr->zbuf, |
||
942 | png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
||
943 | png_ptr->zstream.next_out = png_ptr->zbuf; |
||
944 | png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
||
945 | } |
||
946 | png_ptr->flush_rows = 0; |
||
947 | png_flush(png_ptr); |
||
948 | } |
||
949 | #endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
||
950 | |||
951 | /* free all memory used by the write */ |
||
952 | void PNGAPI |
||
953 | png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) |
||
954 | { |
||
955 | png_structp png_ptr = NULL; |
||
956 | png_infop info_ptr = NULL; |
||
957 | #ifdef PNG_USER_MEM_SUPPORTED |
||
958 | png_free_ptr free_fn = NULL; |
||
959 | png_voidp mem_ptr = NULL; |
||
960 | #endif |
||
961 | |||
962 | png_debug(1, "in png_destroy_write_struct\n"); |
||
963 | if (png_ptr_ptr != NULL) |
||
964 | { |
||
965 | png_ptr = *png_ptr_ptr; |
||
966 | #ifdef PNG_USER_MEM_SUPPORTED |
||
967 | free_fn = png_ptr->free_fn; |
||
968 | mem_ptr = png_ptr->mem_ptr; |
||
969 | #endif |
||
970 | } |
||
971 | |||
972 | if (info_ptr_ptr != NULL) |
||
973 | info_ptr = *info_ptr_ptr; |
||
974 | |||
975 | if (info_ptr != NULL) |
||
976 | { |
||
977 | png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
||
978 | |||
979 | #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
||
980 | if (png_ptr->num_chunk_list) |
||
981 | { |
||
982 | png_free(png_ptr, png_ptr->chunk_list); |
||
983 | png_ptr->chunk_list=NULL; |
||
984 | png_ptr->num_chunk_list=0; |
||
985 | } |
||
986 | #endif |
||
987 | |||
988 | #ifdef PNG_USER_MEM_SUPPORTED |
||
989 | png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
||
990 | (png_voidp)mem_ptr); |
||
991 | #else |
||
992 | png_destroy_struct((png_voidp)info_ptr); |
||
993 | #endif |
||
994 | *info_ptr_ptr = NULL; |
||
995 | } |
||
996 | |||
997 | if (png_ptr != NULL) |
||
998 | { |
||
999 | png_write_destroy(png_ptr); |
||
1000 | #ifdef PNG_USER_MEM_SUPPORTED |
||
1001 | png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
||
1002 | (png_voidp)mem_ptr); |
||
1003 | #else |
||
1004 | png_destroy_struct((png_voidp)png_ptr); |
||
1005 | #endif |
||
1006 | *png_ptr_ptr = NULL; |
||
1007 | } |
||
1008 | } |
||
1009 | |||
1010 | |||
1011 | /* Free any memory used in png_ptr struct (old method) */ |
||
1012 | void /* PRIVATE */ |
||
1013 | png_write_destroy(png_structp png_ptr) |
||
1014 | { |
||
1015 | #ifdef PNG_SETJMP_SUPPORTED |
||
1016 | jmp_buf tmp_jmp; /* save jump buffer */ |
||
1017 | #endif |
||
1018 | png_error_ptr error_fn; |
||
1019 | png_error_ptr warning_fn; |
||
1020 | png_voidp error_ptr; |
||
1021 | #ifdef PNG_USER_MEM_SUPPORTED |
||
1022 | png_free_ptr free_fn; |
||
1023 | #endif |
||
1024 | |||
1025 | png_debug(1, "in png_write_destroy\n"); |
||
1026 | /* free any memory zlib uses */ |
||
1027 | deflateEnd(&png_ptr->zstream); |
||
1028 | |||
1029 | /* free our memory. png_free checks NULL for us. */ |
||
1030 | png_free(png_ptr, png_ptr->zbuf); |
||
1031 | png_free(png_ptr, png_ptr->row_buf); |
||
1032 | png_free(png_ptr, png_ptr->prev_row); |
||
1033 | png_free(png_ptr, png_ptr->sub_row); |
||
1034 | png_free(png_ptr, png_ptr->up_row); |
||
1035 | png_free(png_ptr, png_ptr->avg_row); |
||
1036 | png_free(png_ptr, png_ptr->paeth_row); |
||
1037 | |||
1038 | #if defined(PNG_TIME_RFC1123_SUPPORTED) |
||
1039 | png_free(png_ptr, png_ptr->time_buffer); |
||
1040 | #endif |
||
1041 | |||
1042 | #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
||
1043 | png_free(png_ptr, png_ptr->prev_filters); |
||
1044 | png_free(png_ptr, png_ptr->filter_weights); |
||
1045 | png_free(png_ptr, png_ptr->inv_filter_weights); |
||
1046 | png_free(png_ptr, png_ptr->filter_costs); |
||
1047 | png_free(png_ptr, png_ptr->inv_filter_costs); |
||
1048 | #endif |
||
1049 | |||
1050 | #ifdef PNG_SETJMP_SUPPORTED |
||
1051 | /* reset structure */ |
||
1052 | png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
||
1053 | #endif |
||
1054 | |||
1055 | error_fn = png_ptr->error_fn; |
||
1056 | warning_fn = png_ptr->warning_fn; |
||
1057 | error_ptr = png_ptr->error_ptr; |
||
1058 | #ifdef PNG_USER_MEM_SUPPORTED |
||
1059 | free_fn = png_ptr->free_fn; |
||
1060 | #endif |
||
1061 | |||
1062 | png_memset(png_ptr, 0, sizeof (png_struct)); |
||
1063 | |||
1064 | png_ptr->error_fn = error_fn; |
||
1065 | png_ptr->warning_fn = warning_fn; |
||
1066 | png_ptr->error_ptr = error_ptr; |
||
1067 | #ifdef PNG_USER_MEM_SUPPORTED |
||
1068 | png_ptr->free_fn = free_fn; |
||
1069 | #endif |
||
1070 | |||
1071 | #ifdef PNG_SETJMP_SUPPORTED |
||
1072 | png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
||
1073 | #endif |
||
1074 | } |
||
1075 | |||
1076 | /* Allow the application to select one or more row filters to use. */ |
||
1077 | void PNGAPI |
||
1078 | png_set_filter(png_structp png_ptr, int method, int filters) |
||
1079 | { |
||
1080 | png_debug(1, "in png_set_filter\n"); |
||
1081 | #if defined(PNG_MNG_FEATURES_SUPPORTED) |
||
1082 | if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
||
1083 | (method == PNG_INTRAPIXEL_DIFFERENCING)) |
||
1084 | method = PNG_FILTER_TYPE_BASE; |
||
1085 | #endif |
||
1086 | if (method == PNG_FILTER_TYPE_BASE) |
||
1087 | { |
||
1088 | switch (filters & (PNG_ALL_FILTERS | 0x07)) |
||
1089 | { |
||
1090 | case 5: |
||
1091 | case 6: |
||
1092 | case 7: png_warning(png_ptr, "Unknown row filter for method 0"); |
||
1093 | case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break; |
||
1094 | case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break; |
||
1095 | case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break; |
||
1096 | case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break; |
||
1097 | case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break; |
||
1098 | default: png_ptr->do_filter = (png_byte)filters; break; |
||
1099 | } |
||
1100 | |||
1101 | /* If we have allocated the row_buf, this means we have already started |
||
1102 | * with the image and we should have allocated all of the filter buffers |
||
1103 | * that have been selected. If prev_row isn't already allocated, then |
||
1104 | * it is too late to start using the filters that need it, since we |
||
1105 | * will be missing the data in the previous row. If an application |
||
1106 | * wants to start and stop using particular filters during compression, |
||
1107 | * it should start out with all of the filters, and then add and |
||
1108 | * remove them after the start of compression. |
||
1109 | */ |
||
1110 | if (png_ptr->row_buf != NULL) |
||
1111 | { |
||
1112 | if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) |
||
1113 | { |
||
1114 | png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, |
||
1115 | (png_ptr->rowbytes + 1)); |
||
1116 | png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; |
||
1117 | } |
||
1118 | |||
1119 | if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) |
||
1120 | { |
||
1121 | if (png_ptr->prev_row == NULL) |
||
1122 | { |
||
1123 | png_warning(png_ptr, "Can't add Up filter after starting"); |
||
1124 | png_ptr->do_filter &= ~PNG_FILTER_UP; |
||
1125 | } |
||
1126 | else |
||
1127 | { |
||
1128 | png_ptr->up_row = (png_bytep)png_malloc(png_ptr, |
||
1129 | (png_ptr->rowbytes + 1)); |
||
1130 | png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
||
1131 | } |
||
1132 | } |
||
1133 | |||
1134 | if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) |
||
1135 | { |
||
1136 | if (png_ptr->prev_row == NULL) |
||
1137 | { |
||
1138 | png_warning(png_ptr, "Can't add Average filter after starting"); |
||
1139 | png_ptr->do_filter &= ~PNG_FILTER_AVG; |
||
1140 | } |
||
1141 | else |
||
1142 | { |
||
1143 | png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, |
||
1144 | (png_ptr->rowbytes + 1)); |
||
1145 | png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; |
||
1146 | } |
||
1147 | } |
||
1148 | |||
1149 | if ((png_ptr->do_filter & PNG_FILTER_PAETH) && |
||
1150 | png_ptr->paeth_row == NULL) |
||
1151 | { |
||
1152 | if (png_ptr->prev_row == NULL) |
||
1153 | { |
||
1154 | png_warning(png_ptr, "Can't add Paeth filter after starting"); |
||
1155 | png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); |
||
1156 | } |
||
1157 | else |
||
1158 | { |
||
1159 | png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, |
||
1160 | (png_ptr->rowbytes + 1)); |
||
1161 | png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
||
1162 | } |
||
1163 | } |
||
1164 | |||
1165 | if (png_ptr->do_filter == PNG_NO_FILTERS) |
||
1166 | png_ptr->do_filter = PNG_FILTER_NONE; |
||
1167 | } |
||
1168 | } |
||
1169 | else |
||
1170 | png_error(png_ptr, "Unknown custom filter method"); |
||
1171 | } |
||
1172 | |||
1173 | /* This allows us to influence the way in which libpng chooses the "best" |
||
1174 | * filter for the current scanline. While the "minimum-sum-of-absolute- |
||
1175 | * differences metric is relatively fast and effective, there is some |
||
1176 | * question as to whether it can be improved upon by trying to keep the |
||
1177 | * filtered data going to zlib more consistent, hopefully resulting in |
||
1178 | * better compression. |
||
1179 | */ |
||
1180 | #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ |
||
1181 | void PNGAPI |
||
1182 | png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, |
||
1183 | int num_weights, png_doublep filter_weights, |
||
1184 | png_doublep filter_costs) |
||
1185 | { |
||
1186 | int i; |
||
1187 | |||
1188 | png_debug(1, "in png_set_filter_heuristics\n"); |
||
1189 | if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) |
||
1190 | { |
||
1191 | png_warning(png_ptr, "Unknown filter heuristic method"); |
||
1192 | return; |
||
1193 | } |
||
1194 | |||
1195 | if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) |
||
1196 | { |
||
1197 | heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; |
||
1198 | } |
||
1199 | |||
1200 | if (num_weights < 0 || filter_weights == NULL || |
||
1201 | heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) |
||
1202 | { |
||
1203 | num_weights = 0; |
||
1204 | } |
||
1205 | |||
1206 | png_ptr->num_prev_filters = (png_byte)num_weights; |
||
1207 | png_ptr->heuristic_method = (png_byte)heuristic_method; |
||
1208 | |||
1209 | if (num_weights > 0) |
||
1210 | { |
||
1211 | if (png_ptr->prev_filters == NULL) |
||
1212 | { |
||
1213 | png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, |
||
1214 | (png_uint_32)(sizeof(png_byte) * num_weights)); |
||
1215 | |||
1216 | /* To make sure that the weighting starts out fairly */ |
||
1217 | for (i = 0; i < num_weights; i++) |
||
1218 | { |
||
1219 | png_ptr->prev_filters[i] = 255; |
||
1220 | } |
||
1221 | } |
||
1222 | |||
1223 | if (png_ptr->filter_weights == NULL) |
||
1224 | { |
||
1225 | png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, |
||
1226 | (png_uint_32)(sizeof(png_uint_16) * num_weights)); |
||
1227 | |||
1228 | png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, |
||
1229 | (png_uint_32)(sizeof(png_uint_16) * num_weights)); |
||
1230 | for (i = 0; i < num_weights; i++) |
||
1231 | { |
||
1232 | png_ptr->inv_filter_weights[i] = |
||
1233 | png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
||
1234 | } |
||
1235 | } |
||
1236 | |||
1237 | for (i = 0; i < num_weights; i++) |
||
1238 | { |
||
1239 | if (filter_weights[i] < 0.0) |
||
1240 | { |
||
1241 | png_ptr->inv_filter_weights[i] = |
||
1242 | png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
||
1243 | } |
||
1244 | else |
||
1245 | { |
||
1246 | png_ptr->inv_filter_weights[i] = |
||
1247 | (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); |
||
1248 | png_ptr->filter_weights[i] = |
||
1249 | (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); |
||
1250 | } |
||
1251 | } |
||
1252 | } |
||
1253 | |||
1254 | /* If, in the future, there are other filter methods, this would |
||
1255 | * need to be based on png_ptr->filter. |
||
1256 | */ |
||
1257 | if (png_ptr->filter_costs == NULL) |
||
1258 | { |
||
1259 | png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, |
||
1260 | (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
||
1261 | |||
1262 | png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, |
||
1263 | (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
||
1264 | |||
1265 | for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
||
1266 | { |
||
1267 | png_ptr->inv_filter_costs[i] = |
||
1268 | png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
||
1269 | } |
||
1270 | } |
||
1271 | |||
1272 | /* Here is where we set the relative costs of the different filters. We |
||
1273 | * should take the desired compression level into account when setting |
||
1274 | * the costs, so that Paeth, for instance, has a high relative cost at low |
||
1275 | * compression levels, while it has a lower relative cost at higher |
||
1276 | * compression settings. The filter types are in order of increasing |
||
1277 | * relative cost, so it would be possible to do this with an algorithm. |
||
1278 | */ |
||
1279 | for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
||
1280 | { |
||
1281 | if (filter_costs == NULL || filter_costs[i] < 0.0) |
||
1282 | { |
||
1283 | png_ptr->inv_filter_costs[i] = |
||
1284 | png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
||
1285 | } |
||
1286 | else if (filter_costs[i] >= 1.0) |
||
1287 | { |
||
1288 | png_ptr->inv_filter_costs[i] = |
||
1289 | (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); |
||
1290 | png_ptr->filter_costs[i] = |
||
1291 | (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); |
||
1292 | } |
||
1293 | } |
||
1294 | } |
||
1295 | #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
||
1296 | |||
1297 | void PNGAPI |
||
1298 | png_set_compression_level(png_structp png_ptr, int level) |
||
1299 | { |
||
1300 | png_debug(1, "in png_set_compression_level\n"); |
||
1301 | png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; |
||
1302 | png_ptr->zlib_level = level; |
||
1303 | } |
||
1304 | |||
1305 | void PNGAPI |
||
1306 | png_set_compression_mem_level(png_structp png_ptr, int mem_level) |
||
1307 | { |
||
1308 | png_debug(1, "in png_set_compression_mem_level\n"); |
||
1309 | png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; |
||
1310 | png_ptr->zlib_mem_level = mem_level; |
||
1311 | } |
||
1312 | |||
1313 | void PNGAPI |
||
1314 | png_set_compression_strategy(png_structp png_ptr, int strategy) |
||
1315 | { |
||
1316 | png_debug(1, "in png_set_compression_strategy\n"); |
||
1317 | png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; |
||
1318 | png_ptr->zlib_strategy = strategy; |
||
1319 | } |
||
1320 | |||
1321 | void PNGAPI |
||
1322 | png_set_compression_window_bits(png_structp png_ptr, int window_bits) |
||
1323 | { |
||
1324 | if (window_bits > 15) |
||
1325 | png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); |
||
1326 | else if (window_bits < 8) |
||
1327 | png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); |
||
1328 | #ifndef WBITS_8_OK |
||
1329 | /* avoid libpng bug with 256-byte windows */ |
||
1330 | if (window_bits == 8) |
||
1331 | { |
||
1332 | png_warning(png_ptr, "Compression window is being reset to 512"); |
||
1333 | window_bits=9; |
||
1334 | } |
||
1335 | #endif |
||
1336 | png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; |
||
1337 | png_ptr->zlib_window_bits = window_bits; |
||
1338 | } |
||
1339 | |||
1340 | void PNGAPI |
||
1341 | png_set_compression_method(png_structp png_ptr, int method) |
||
1342 | { |
||
1343 | png_debug(1, "in png_set_compression_method\n"); |
||
1344 | if (method != 8) |
||
1345 | png_warning(png_ptr, "Only compression method 8 is supported by PNG"); |
||
1346 | png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; |
||
1347 | png_ptr->zlib_method = method; |
||
1348 | } |
||
1349 | |||
1350 | void PNGAPI |
||
1351 | png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) |
||
1352 | { |
||
1353 | png_ptr->write_row_fn = write_row_fn; |
||
1354 | } |
||
1355 | |||
1356 | #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
||
1357 | void PNGAPI |
||
1358 | png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
||
1359 | write_user_transform_fn) |
||
1360 | { |
||
1361 | png_debug(1, "in png_set_write_user_transform_fn\n"); |
||
1362 | png_ptr->transformations |= PNG_USER_TRANSFORM; |
||
1363 | png_ptr->write_user_transform_fn = write_user_transform_fn; |
||
1364 | } |
||
1365 | #endif |
||
1366 | |||
1367 | |||
1368 | #if defined(PNG_INFO_IMAGE_SUPPORTED) |
||
1369 | void PNGAPI |
||
1370 | png_write_png(png_structp png_ptr, png_infop info_ptr, |
||
1371 | int transforms, voidp params) |
||
1372 | { |
||
1373 | #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
||
1374 | /* invert the alpha channel from opacity to transparency */ |
||
1375 | if (transforms & PNG_TRANSFORM_INVERT_ALPHA) |
||
1376 | png_set_invert_alpha(png_ptr); |
||
1377 | #endif |
||
1378 | |||
1379 | /* Write the file header information. */ |
||
1380 | png_write_info(png_ptr, info_ptr); |
||
1381 | |||
1382 | /* ------ these transformations don't touch the info structure ------- */ |
||
1383 | |||
1384 | #if defined(PNG_WRITE_INVERT_SUPPORTED) |
||
1385 | /* invert monochrome pixels */ |
||
1386 | if (transforms & PNG_TRANSFORM_INVERT_MONO) |
||
1387 | png_set_invert_mono(png_ptr); |
||
1388 | #endif |
||
1389 | |||
1390 | #if defined(PNG_WRITE_SHIFT_SUPPORTED) |
||
1391 | /* Shift the pixels up to a legal bit depth and fill in |
||
1392 | * as appropriate to correctly scale the image. |
||
1393 | */ |
||
1394 | if ((transforms & PNG_TRANSFORM_SHIFT) |
||
1395 | && (info_ptr->valid & PNG_INFO_sBIT)) |
||
1396 | png_set_shift(png_ptr, &info_ptr->sig_bit); |
||
1397 | #endif |
||
1398 | |||
1399 | #if defined(PNG_WRITE_PACK_SUPPORTED) |
||
1400 | /* pack pixels into bytes */ |
||
1401 | if (transforms & PNG_TRANSFORM_PACKING) |
||
1402 | png_set_packing(png_ptr); |
||
1403 | #endif |
||
1404 | |||
1405 | #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
||
1406 | /* swap location of alpha bytes from ARGB to RGBA */ |
||
1407 | if (transforms & PNG_TRANSFORM_SWAP_ALPHA) |
||
1408 | png_set_swap_alpha(png_ptr); |
||
1409 | #endif |
||
1410 | |||
1411 | #if defined(PNG_WRITE_FILLER_SUPPORTED) |
||
1412 | /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
||
1413 | * RGB (4 channels -> 3 channels). The second parameter is not used. |
||
1414 | */ |
||
1415 | if (transforms & PNG_TRANSFORM_STRIP_FILLER) |
||
1416 | png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
||
1417 | #endif |
||
1418 | |||
1419 | #if defined(PNG_WRITE_BGR_SUPPORTED) |
||
1420 | /* flip BGR pixels to RGB */ |
||
1421 | if (transforms & PNG_TRANSFORM_BGR) |
||
1422 | png_set_bgr(png_ptr); |
||
1423 | #endif |
||
1424 | |||
1425 | #if defined(PNG_WRITE_SWAP_SUPPORTED) |
||
1426 | /* swap bytes of 16-bit files to most significant byte first */ |
||
1427 | if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
||
1428 | png_set_swap(png_ptr); |
||
1429 | #endif |
||
1430 | |||
1431 | #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
||
1432 | /* swap bits of 1, 2, 4 bit packed pixel formats */ |
||
1433 | if (transforms & PNG_TRANSFORM_PACKSWAP) |
||
1434 | png_set_packswap(png_ptr); |
||
1435 | #endif |
||
1436 | |||
1437 | /* ----------------------- end of transformations ------------------- */ |
||
1438 | |||
1439 | /* write the bits */ |
||
1440 | if (info_ptr->valid & PNG_INFO_IDAT) |
||
1441 | png_write_image(png_ptr, info_ptr->row_pointers); |
||
1442 | |||
1443 | /* It is REQUIRED to call this to finish writing the rest of the file */ |
||
1444 | png_write_end(png_ptr, info_ptr); |
||
1445 | |||
1446 | if(transforms == 0 || params == NULL) |
||
1447 | /* quiet compiler warnings */ return; |
||
1448 | } |
||
1449 | #endif |
||
1450 | #endif /* PNG_WRITE_SUPPORTED */ |