← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/libpng/pngwrite.c

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

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