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


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat Apr 13 2019 02:14:25