← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/libpng/png.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/libpng/png.c
 
1
 
 
2
/* png.c - location for general purpose libpng functions
 
3
 *
 
4
 * libpng version 1.2.8 - December 3, 2004
 
5
 * For conditions of distribution and use, see copyright notice in png.h
 
6
 * Copyright (c) 1998-2004 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
#define PNG_INTERNAL
 
12
#define PNG_NO_EXTERN
 
13
#include "png.h"
 
14
 
 
15
/* Generate a compiler error if there is an old png.h in the search path. */
 
16
typedef version_1_2_8 Your_png_h_is_not_version_1_2_8;
 
17
 
 
18
/* Version information for C files.  This had better match the version
 
19
 * string defined in png.h.  */
 
20
 
 
21
#ifdef PNG_USE_GLOBAL_ARRAYS
 
22
/* png_libpng_ver was changed to a function in version 1.0.5c */
 
23
const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
 
24
 
 
25
/* png_sig was changed to a function in version 1.0.5c */
 
26
/* Place to hold the signature string for a PNG file. */
 
27
const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
28
 
 
29
/* Invoke global declarations for constant strings for known chunk types */
 
30
PNG_IHDR;
 
31
PNG_IDAT;
 
32
PNG_IEND;
 
33
PNG_PLTE;
 
34
PNG_bKGD;
 
35
PNG_cHRM;
 
36
PNG_gAMA;
 
37
PNG_hIST;
 
38
PNG_iCCP;
 
39
PNG_iTXt;
 
40
PNG_oFFs;
 
41
PNG_pCAL;
 
42
PNG_sCAL;
 
43
PNG_pHYs;
 
44
PNG_sBIT;
 
45
PNG_sPLT;
 
46
PNG_sRGB;
 
47
PNG_tEXt;
 
48
PNG_tIME;
 
49
PNG_tRNS;
 
50
PNG_zTXt;
 
51
 
 
52
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
53
 
 
54
/* start of interlace block */
 
55
const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 
56
 
 
57
/* offset to next interlace block */
 
58
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 
59
 
 
60
/* start of interlace block in the y direction */
 
61
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 
62
 
 
63
/* offset to next interlace block in the y direction */
 
64
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
 
65
 
 
66
/* width of interlace block (used in assembler routines only) */
 
67
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
 
68
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
 
69
#endif
 
70
 
 
71
/* Height of interlace block.  This is not currently used - if you need
 
72
 * it, uncomment it here and in png.h
 
73
const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
 
74
*/
 
75
 
 
76
/* Mask to determine which pixels are valid in a pass */
 
77
const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
 
78
 
 
79
/* Mask to determine which pixels to overwrite while displaying */
 
80
const int FARDATA png_pass_dsp_mask[]
 
81
   = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
 
82
 
 
83
#endif /* PNG_USE_GLOBAL_ARRAYS */
 
84
 
 
85
/* Tells libpng that we have already handled the first "num_bytes" bytes
 
86
 * of the PNG file signature.  If the PNG data is embedded into another
 
87
 * stream we can set num_bytes = 8 so that libpng will not attempt to read
 
88
 * or write any of the magic bytes before it starts on the IHDR.
 
89
 */
 
90
 
 
91
void PNGAPI
 
92
png_set_sig_bytes(png_structp png_ptr, int num_bytes)
 
93
{
 
94
   png_debug(1, "in png_set_sig_bytes\n");
 
95
   if (num_bytes > 8)
 
96
      png_error(png_ptr, "Too many bytes for PNG signature.");
 
97
 
 
98
   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
 
99
}
 
100
 
 
101
/* Checks whether the supplied bytes match the PNG signature.  We allow
 
102
 * checking less than the full 8-byte signature so that those apps that
 
103
 * already read the first few bytes of a file to determine the file type
 
104
 * can simply check the remaining bytes for extra assurance.  Returns
 
105
 * an integer less than, equal to, or greater than zero if sig is found,
 
106
 * respectively, to be less than, to match, or be greater than the correct
 
107
 * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
 
108
 */
 
109
int PNGAPI
 
110
png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
 
111
{
 
112
   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
113
   if (num_to_check > 8)
 
114
      num_to_check = 8;
 
115
   else if (num_to_check < 1)
 
116
      return (0);
 
117
 
 
118
   if (start > 7)
 
119
      return (0);
 
120
 
 
121
   if (start + num_to_check > 8)
 
122
      num_to_check = 8 - start;
 
123
 
 
124
   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
 
125
}
 
126
 
 
127
/* (Obsolete) function to check signature bytes.  It does not allow one
 
128
 * to check a partial signature.  This function might be removed in the
 
129
 * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
 
130
 */
 
131
int PNGAPI
 
132
png_check_sig(png_bytep sig, int num)
 
133
{
 
134
  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
 
135
}
 
136
 
 
137
/* Function to allocate memory for zlib and clear it to 0. */
 
138
#ifdef PNG_1_0_X
 
139
voidpf PNGAPI
 
140
#else
 
141
voidpf /* private */
 
142
#endif
 
143
png_zalloc(voidpf png_ptr, uInt items, uInt size)
 
144
{
 
145
   png_voidp ptr;
 
146
   png_structp p=png_ptr;
 
147
   png_uint_32 save_flags=p->flags;
 
148
   png_uint_32 num_bytes;
 
149
 
 
150
   if (items > PNG_UINT_32_MAX/size)
 
151
   {
 
152
     png_warning (png_ptr, "Potential overflow in png_zalloc()");
 
153
     return (NULL);
 
154
   }
 
155
   num_bytes = (png_uint_32)items * size;
 
156
 
 
157
   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
 
158
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
 
159
   p->flags=save_flags;
 
160
 
 
161
#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
 
162
   if (ptr == NULL)
 
163
       return ((voidpf)ptr);
 
164
 
 
165
   if (num_bytes > (png_uint_32)0x8000L)
 
166
   {
 
167
      png_memset(ptr, 0, (png_size_t)0x8000L);
 
168
      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
 
169
         (png_size_t)(num_bytes - (png_uint_32)0x8000L));
 
170
   }
 
171
   else
 
172
   {
 
173
      png_memset(ptr, 0, (png_size_t)num_bytes);
 
174
   }
 
175
#endif
 
176
   return ((voidpf)ptr);
 
177
}
 
178
 
 
179
/* function to free memory for zlib */
 
180
#ifdef PNG_1_0_X
 
181
void PNGAPI
 
182
#else
 
183
void /* private */
 
184
#endif
 
185
png_zfree(voidpf png_ptr, voidpf ptr)
 
186
{
 
187
   png_free((png_structp)png_ptr, (png_voidp)ptr);
 
188
}
 
189
 
 
190
/* Reset the CRC variable to 32 bits of 1's.  Care must be taken
 
191
 * in case CRC is > 32 bits to leave the top bits 0.
 
192
 */
 
193
void /* PRIVATE */
 
194
png_reset_crc(png_structp png_ptr)
 
195
{
 
196
   png_ptr->crc = crc32(0, Z_NULL, 0);
 
197
}
 
198
 
 
199
/* Calculate the CRC over a section of data.  We can only pass as
 
200
 * much data to this routine as the largest single buffer size.  We
 
201
 * also check that this data will actually be used before going to the
 
202
 * trouble of calculating it.
 
203
 */
 
204
void /* PRIVATE */
 
205
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
 
206
{
 
207
   int need_crc = 1;
 
208
 
 
209
   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
 
210
   {
 
211
      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
 
212
          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
 
213
         need_crc = 0;
 
214
   }
 
215
   else                                                    /* critical */
 
216
   {
 
217
      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
 
218
         need_crc = 0;
 
219
   }
 
220
 
 
221
   if (need_crc)
 
222
      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
 
223
}
 
224
 
 
225
/* Allocate the memory for an info_struct for the application.  We don't
 
226
 * really need the png_ptr, but it could potentially be useful in the
 
227
 * future.  This should be used in favour of malloc(png_sizeof(png_info))
 
228
 * and png_info_init() so that applications that want to use a shared
 
229
 * libpng don't have to be recompiled if png_info changes size.
 
230
 */
 
231
png_infop PNGAPI
 
232
png_create_info_struct(png_structp png_ptr)
 
233
{
 
234
   png_infop info_ptr;
 
235
 
 
236
   png_debug(1, "in png_create_info_struct\n");
 
237
   if(png_ptr == NULL) return (NULL);
 
238
#ifdef PNG_USER_MEM_SUPPORTED
 
239
   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
 
240
      png_ptr->malloc_fn, png_ptr->mem_ptr);
 
241
#else
 
242
   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
 
243
#endif
 
244
   if (info_ptr != NULL)
 
245
      png_info_init_3(&info_ptr, png_sizeof(png_info));
 
246
 
 
247
   return (info_ptr);
 
248
}
 
249
 
 
250
/* This function frees the memory associated with a single info struct.
 
251
 * Normally, one would use either png_destroy_read_struct() or
 
252
 * png_destroy_write_struct() to free an info struct, but this may be
 
253
 * useful for some applications.
 
254
 */
 
255
void PNGAPI
 
256
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
 
257
{
 
258
   png_infop info_ptr = NULL;
 
259
 
 
260
   png_debug(1, "in png_destroy_info_struct\n");
 
261
   if (info_ptr_ptr != NULL)
 
262
      info_ptr = *info_ptr_ptr;
 
263
 
 
264
   if (info_ptr != NULL)
 
265
   {
 
266
      png_info_destroy(png_ptr, info_ptr);
 
267
 
 
268
#ifdef PNG_USER_MEM_SUPPORTED
 
269
      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
 
270
          png_ptr->mem_ptr);
 
271
#else
 
272
      png_destroy_struct((png_voidp)info_ptr);
 
273
#endif
 
274
      *info_ptr_ptr = NULL;
 
275
   }
 
276
}
 
277
 
 
278
/* Initialize the info structure.  This is now an internal function (0.89)
 
279
 * and applications using it are urged to use png_create_info_struct()
 
280
 * instead.
 
281
 */
 
282
#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
 
283
#undef png_info_init
 
284
void PNGAPI
 
285
png_info_init(png_infop info_ptr)
 
286
{
 
287
   /* We only come here via pre-1.0.12-compiled applications */
 
288
   png_info_init_3(&info_ptr, 0);
 
289
}
 
290
#endif
 
291
 
 
292
void PNGAPI
 
293
png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
 
294
{
 
295
   png_infop info_ptr = *ptr_ptr;
 
296
 
 
297
   png_debug(1, "in png_info_init_3\n");
 
298
 
 
299
   if(png_sizeof(png_info) > png_info_struct_size)
 
300
     {
 
301
       png_destroy_struct(info_ptr);
 
302
       info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
 
303
       *ptr_ptr = info_ptr;
 
304
     }
 
305
 
 
306
   /* set everything to 0 */
 
307
   png_memset(info_ptr, 0, png_sizeof (png_info));
 
308
}
 
309
 
 
310
#ifdef PNG_FREE_ME_SUPPORTED
 
311
void PNGAPI
 
312
png_data_freer(png_structp png_ptr, png_infop info_ptr,
 
313
   int freer, png_uint_32 mask)
 
314
{
 
315
   png_debug(1, "in png_data_freer\n");
 
316
   if (png_ptr == NULL || info_ptr == NULL)
 
317
      return;
 
318
   if(freer == PNG_DESTROY_WILL_FREE_DATA)
 
319
      info_ptr->free_me |= mask;
 
320
   else if(freer == PNG_USER_WILL_FREE_DATA)
 
321
      info_ptr->free_me &= ~mask;
 
322
   else
 
323
      png_warning(png_ptr,
 
324
         "Unknown freer parameter in png_data_freer.");
 
325
}
 
326
#endif
 
327
 
 
328
void PNGAPI
 
329
png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
 
330
   int num)
 
331
{
 
332
   png_debug(1, "in png_free_data\n");
 
333
   if (png_ptr == NULL || info_ptr == NULL)
 
334
      return;
 
335
 
 
336
#if defined(PNG_TEXT_SUPPORTED)
 
337
/* free text item num or (if num == -1) all text items */
 
338
#ifdef PNG_FREE_ME_SUPPORTED
 
339
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
 
340
#else
 
341
if (mask & PNG_FREE_TEXT)
 
342
#endif
 
343
{
 
344
   if (num != -1)
 
345
   {
 
346
     if (info_ptr->text && info_ptr->text[num].key)
 
347
     {
 
348
         png_free(png_ptr, info_ptr->text[num].key);
 
349
         info_ptr->text[num].key = NULL;
 
350
     }
 
351
   }
 
352
   else
 
353
   {
 
354
       int i;
 
355
       for (i = 0; i < info_ptr->num_text; i++)
 
356
           png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
 
357
       png_free(png_ptr, info_ptr->text);
 
358
       info_ptr->text = NULL;
 
359
       info_ptr->num_text=0;
 
360
   }
 
361
}
 
362
#endif
 
363
 
 
364
#if defined(PNG_tRNS_SUPPORTED)
 
365
/* free any tRNS entry */
 
366
#ifdef PNG_FREE_ME_SUPPORTED
 
367
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
 
368
#else
 
369
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
 
370
#endif
 
371
{
 
372
    png_free(png_ptr, info_ptr->trans);
 
373
    info_ptr->valid &= ~PNG_INFO_tRNS;
 
374
#ifndef PNG_FREE_ME_SUPPORTED
 
375
    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
 
376
#endif
 
377
    info_ptr->trans = NULL;
 
378
}
 
379
#endif
 
380
 
 
381
#if defined(PNG_sCAL_SUPPORTED)
 
382
/* free any sCAL entry */
 
383
#ifdef PNG_FREE_ME_SUPPORTED
 
384
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
 
385
#else
 
386
if (mask & PNG_FREE_SCAL)
 
387
#endif
 
388
{
 
389
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
 
390
    png_free(png_ptr, info_ptr->scal_s_width);
 
391
    png_free(png_ptr, info_ptr->scal_s_height);
 
392
    info_ptr->scal_s_width = NULL;
 
393
    info_ptr->scal_s_height = NULL;
 
394
#endif
 
395
    info_ptr->valid &= ~PNG_INFO_sCAL;
 
396
}
 
397
#endif
 
398
 
 
399
#if defined(PNG_pCAL_SUPPORTED)
 
400
/* free any pCAL entry */
 
401
#ifdef PNG_FREE_ME_SUPPORTED
 
402
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
 
403
#else
 
404
if (mask & PNG_FREE_PCAL)
 
405
#endif
 
406
{
 
407
    png_free(png_ptr, info_ptr->pcal_purpose);
 
408
    png_free(png_ptr, info_ptr->pcal_units);
 
409
    info_ptr->pcal_purpose = NULL;
 
410
    info_ptr->pcal_units = NULL;
 
411
    if (info_ptr->pcal_params != NULL)
 
412
    {
 
413
        int i;
 
414
        for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
 
415
        {
 
416
          png_free(png_ptr, info_ptr->pcal_params[i]);
 
417
          info_ptr->pcal_params[i]=NULL;
 
418
        }
 
419
        png_free(png_ptr, info_ptr->pcal_params);
 
420
        info_ptr->pcal_params = NULL;
 
421
    }
 
422
    info_ptr->valid &= ~PNG_INFO_pCAL;
 
423
}
 
424
#endif
 
425
 
 
426
#if defined(PNG_iCCP_SUPPORTED)
 
427
/* free any iCCP entry */
 
428
#ifdef PNG_FREE_ME_SUPPORTED
 
429
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
 
430
#else
 
431
if (mask & PNG_FREE_ICCP)
 
432
#endif
 
433
{
 
434
    png_free(png_ptr, info_ptr->iccp_name);
 
435
    png_free(png_ptr, info_ptr->iccp_profile);
 
436
    info_ptr->iccp_name = NULL;
 
437
    info_ptr->iccp_profile = NULL;
 
438
    info_ptr->valid &= ~PNG_INFO_iCCP;
 
439
}
 
440
#endif
 
441
 
 
442
#if defined(PNG_sPLT_SUPPORTED)
 
443
/* free a given sPLT entry, or (if num == -1) all sPLT entries */
 
444
#ifdef PNG_FREE_ME_SUPPORTED
 
445
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
 
446
#else
 
447
if (mask & PNG_FREE_SPLT)
 
448
#endif
 
449
{
 
450
   if (num != -1)
 
451
   {
 
452
      if(info_ptr->splt_palettes)
 
453
      {
 
454
          png_free(png_ptr, info_ptr->splt_palettes[num].name);
 
455
          png_free(png_ptr, info_ptr->splt_palettes[num].entries);
 
456
          info_ptr->splt_palettes[num].name = NULL;
 
457
          info_ptr->splt_palettes[num].entries = NULL;
 
458
      }
 
459
   }
 
460
   else
 
461
   {
 
462
       if(info_ptr->splt_palettes_num)
 
463
       {
 
464
         int i;
 
465
         for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
 
466
            png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
 
467
 
 
468
         png_free(png_ptr, info_ptr->splt_palettes);
 
469
         info_ptr->splt_palettes = NULL;
 
470
         info_ptr->splt_palettes_num = 0;
 
471
       }
 
472
       info_ptr->valid &= ~PNG_INFO_sPLT;
 
473
   }
 
474
}
 
475
#endif
 
476
 
 
477
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
 
478
#ifdef PNG_FREE_ME_SUPPORTED
 
479
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
 
480
#else
 
481
if (mask & PNG_FREE_UNKN)
 
482
#endif
 
483
{
 
484
   if (num != -1)
 
485
   {
 
486
       if(info_ptr->unknown_chunks)
 
487
       {
 
488
          png_free(png_ptr, info_ptr->unknown_chunks[num].data);
 
489
          info_ptr->unknown_chunks[num].data = NULL;
 
490
       }
 
491
   }
 
492
   else
 
493
   {
 
494
       int i;
 
495
 
 
496
       if(info_ptr->unknown_chunks_num)
 
497
       {
 
498
         for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
 
499
            png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
 
500
 
 
501
         png_free(png_ptr, info_ptr->unknown_chunks);
 
502
         info_ptr->unknown_chunks = NULL;
 
503
         info_ptr->unknown_chunks_num = 0;
 
504
       }
 
505
   }
 
506
}
 
507
#endif
 
508
 
 
509
#if defined(PNG_hIST_SUPPORTED)
 
510
/* free any hIST entry */
 
511
#ifdef PNG_FREE_ME_SUPPORTED
 
512
if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
 
513
#else
 
514
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
 
515
#endif
 
516
{
 
517
    png_free(png_ptr, info_ptr->hist);
 
518
    info_ptr->hist = NULL;
 
519
    info_ptr->valid &= ~PNG_INFO_hIST;
 
520
#ifndef PNG_FREE_ME_SUPPORTED
 
521
    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
 
522
#endif
 
523
}
 
524
#endif
 
525
 
 
526
/* free any PLTE entry that was internally allocated */
 
527
#ifdef PNG_FREE_ME_SUPPORTED
 
528
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
 
529
#else
 
530
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
 
531
#endif
 
532
{
 
533
    png_zfree(png_ptr, info_ptr->palette);
 
534
    info_ptr->palette = NULL;
 
535
    info_ptr->valid &= ~PNG_INFO_PLTE;
 
536
#ifndef PNG_FREE_ME_SUPPORTED
 
537
    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
 
538
#endif
 
539
    info_ptr->num_palette = 0;
 
540
}
 
541
 
 
542
#if defined(PNG_INFO_IMAGE_SUPPORTED)
 
543
/* free any image bits attached to the info structure */
 
544
#ifdef PNG_FREE_ME_SUPPORTED
 
545
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
 
546
#else
 
547
if (mask & PNG_FREE_ROWS)
 
548
#endif
 
549
{
 
550
    if(info_ptr->row_pointers)
 
551
    {
 
552
       int row;
 
553
       for (row = 0; row < (int)info_ptr->height; row++)
 
554
       {
 
555
          png_free(png_ptr, info_ptr->row_pointers[row]);
 
556
          info_ptr->row_pointers[row]=NULL;
 
557
       }
 
558
       png_free(png_ptr, info_ptr->row_pointers);
 
559
       info_ptr->row_pointers=NULL;
 
560
    }
 
561
    info_ptr->valid &= ~PNG_INFO_IDAT;
 
562
}
 
563
#endif
 
564
 
 
565
#ifdef PNG_FREE_ME_SUPPORTED
 
566
   if(num == -1)
 
567
     info_ptr->free_me &= ~mask;
 
568
   else
 
569
     info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
 
570
#endif
 
571
}
 
572
 
 
573
/* This is an internal routine to free any memory that the info struct is
 
574
 * pointing to before re-using it or freeing the struct itself.  Recall
 
575
 * that png_free() checks for NULL pointers for us.
 
576
 */
 
577
void /* PRIVATE */
 
578
png_info_destroy(png_structp png_ptr, png_infop info_ptr)
 
579
{
 
580
   png_debug(1, "in png_info_destroy\n");
 
581
 
 
582
   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
 
583
 
 
584
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
 
585
   if (png_ptr->num_chunk_list)
 
586
   {
 
587
       png_free(png_ptr, png_ptr->chunk_list);
 
588
       png_ptr->chunk_list=NULL;
 
589
       png_ptr->num_chunk_list=0;
 
590
   }
 
591
#endif
 
592
 
 
593
   png_info_init_3(&info_ptr, png_sizeof(png_info));
 
594
}
 
595
 
 
596
/* This function returns a pointer to the io_ptr associated with the user
 
597
 * functions.  The application should free any memory associated with this
 
598
 * pointer before png_write_destroy() or png_read_destroy() are called.
 
599
 */
 
600
png_voidp PNGAPI
 
601
png_get_io_ptr(png_structp png_ptr)
 
602
{
 
603
   return (png_ptr->io_ptr);
 
604
}
 
605
 
 
606
#if !defined(PNG_NO_STDIO)
 
607
/* Initialize the default input/output functions for the PNG file.  If you
 
608
 * use your own read or write routines, you can call either png_set_read_fn()
 
609
 * or png_set_write_fn() instead of png_init_io().  If you have defined
 
610
 * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
 
611
 * necessarily available.
 
612
 */
 
613
void PNGAPI
 
614
png_init_io(png_structp png_ptr, png_FILE_p fp)
 
615
{
 
616
   png_debug(1, "in png_init_io\n");
 
617
   png_ptr->io_ptr = (png_voidp)fp;
 
618
}
 
619
#endif
 
620
 
 
621
#if defined(PNG_TIME_RFC1123_SUPPORTED)
 
622
/* Convert the supplied time into an RFC 1123 string suitable for use in
 
623
 * a "Creation Time" or other text-based time string.
 
624
 */
 
625
png_charp PNGAPI
 
626
png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
 
627
{
 
628
   static PNG_CONST char short_months[12][4] =
 
629
        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
 
630
         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
631
 
 
632
   if (png_ptr->time_buffer == NULL)
 
633
   {
 
634
      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
 
635
         png_sizeof(char)));
 
636
   }
 
637
 
 
638
#if defined(_WIN32_WCE)
 
639
   {
 
640
      wchar_t time_buf[29];
 
641
      wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
 
642
          ptime->day % 32, short_months[(ptime->month - 1) % 12],
 
643
        ptime->year, ptime->hour % 24, ptime->minute % 60,
 
644
          ptime->second % 61);
 
645
      WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
 
646
          NULL, NULL);
 
647
   }
 
648
#else
 
649
#ifdef USE_FAR_KEYWORD
 
650
   {
 
651
      char near_time_buf[29];
 
652
      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
 
653
          ptime->day % 32, short_months[(ptime->month - 1) % 12],
 
654
          ptime->year, ptime->hour % 24, ptime->minute % 60,
 
655
          ptime->second % 61);
 
656
      png_memcpy(png_ptr->time_buffer, near_time_buf,
 
657
          29*png_sizeof(char));
 
658
   }
 
659
#else
 
660
   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
 
661
       ptime->day % 32, short_months[(ptime->month - 1) % 12],
 
662
       ptime->year, ptime->hour % 24, ptime->minute % 60,
 
663
       ptime->second % 61);
 
664
#endif
 
665
#endif /* _WIN32_WCE */
 
666
   return ((png_charp)png_ptr->time_buffer);
 
667
}
 
668
#endif /* PNG_TIME_RFC1123_SUPPORTED */
 
669
 
 
670
#if 0
 
671
/* Signature string for a PNG file. */
 
672
png_bytep PNGAPI
 
673
png_sig_bytes(void)
 
674
{
 
675
   return ((png_bytep)"\211\120\116\107\015\012\032\012");
 
676
}
 
677
#endif
 
678
 
 
679
png_charp PNGAPI
 
680
png_get_copyright(png_structp png_ptr)
 
681
{
 
682
   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
 
683
   return ((png_charp) "\n libpng version 1.2.8 - December 3, 2004\n\
 
684
   Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\
 
685
   Copyright (c) 1996-1997 Andreas Dilger\n\
 
686
   Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
 
687
   return ((png_charp) "");
 
688
}
 
689
 
 
690
/* The following return the library version as a short string in the
 
691
 * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
 
692
 * used with your application, print out PNG_LIBPNG_VER_STRING, which
 
693
 * is defined in png.h.
 
694
 * Note: now there is no difference between png_get_libpng_ver() and
 
695
 * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
 
696
 * it is guaranteed that png.c uses the correct version of png.h.
 
697
 */
 
698
png_charp PNGAPI
 
699
png_get_libpng_ver(png_structp png_ptr)
 
700
{
 
701
   /* Version of *.c files used when building libpng */
 
702
   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
 
703
      return ((png_charp) PNG_LIBPNG_VER_STRING);
 
704
   return ((png_charp) "");
 
705
}
 
706
 
 
707
png_charp PNGAPI
 
708
png_get_header_ver(png_structp png_ptr)
 
709
{
 
710
   /* Version of *.h files used when building libpng */
 
711
   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
 
712
      return ((png_charp) PNG_LIBPNG_VER_STRING);
 
713
   return ((png_charp) "");
 
714
}
 
715
 
 
716
png_charp PNGAPI
 
717
png_get_header_version(png_structp png_ptr)
 
718
{
 
719
   /* Returns longer string containing both version and date */
 
720
   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
 
721
      return ((png_charp) PNG_HEADER_VERSION_STRING);
 
722
   return ((png_charp) "");
 
723
}
 
724
 
 
725
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 
726
int PNGAPI
 
727
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
 
728
{
 
729
   /* check chunk_name and return "keep" value if it's on the list, else 0 */
 
730
   int i;
 
731
   png_bytep p;
 
732
   if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
 
733
      return 0;
 
734
   p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
 
735
   for (i = png_ptr->num_chunk_list; i; i--, p-=5)
 
736
      if (!png_memcmp(chunk_name, p, 4))
 
737
        return ((int)*(p+4));
 
738
   return 0;
 
739
}
 
740
#endif
 
741
 
 
742
/* This function, added to libpng-1.0.6g, is untested. */
 
743
int PNGAPI
 
744
png_reset_zstream(png_structp png_ptr)
 
745
{
 
746
   return (inflateReset(&png_ptr->zstream));
 
747
}
 
748
 
 
749
/* This function was added to libpng-1.0.7 */
 
750
png_uint_32 PNGAPI
 
751
png_access_version_number(void)
 
752
{
 
753
   /* Version of *.c files used when building libpng */
 
754
   return((png_uint_32) PNG_LIBPNG_VER);
 
755
}
 
756
 
 
757
 
 
758
#if !defined(PNG_1_0_X)
 
759
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
 
760
    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
 
761
/* this INTERNAL function was added to libpng 1.2.0 */
 
762
void /* PRIVATE */
 
763
png_init_mmx_flags (png_structp png_ptr)
 
764
{
 
765
    png_ptr->mmx_rowbytes_threshold = 0;
 
766
    png_ptr->mmx_bitdepth_threshold = 0;
 
767
 
 
768
#  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
 
769
 
 
770
    png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
 
771
 
 
772
    if (png_mmx_support() > 0) {
 
773
        png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
 
774
#    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
 
775
                              | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
 
776
#    endif
 
777
#    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
 
778
                              | PNG_ASM_FLAG_MMX_READ_INTERLACE
 
779
#    endif
 
780
#    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
 
781
                              ;
 
782
#    else
 
783
                              | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
 
784
                              | PNG_ASM_FLAG_MMX_READ_FILTER_UP
 
785
                              | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
 
786
                              | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
 
787
 
 
788
        png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
 
789
        png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
 
790
#    endif
 
791
    } else {
 
792
        png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
 
793
                               | PNG_MMX_READ_FLAGS
 
794
                               | PNG_MMX_WRITE_FLAGS );
 
795
    }
 
796
 
 
797
#  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
 
798
 
 
799
    /* clear all MMX flags; no support is compiled in */
 
800
    png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
 
801
 
 
802
#  endif /* ?(PNGVCRD || PNGGCCRD) */
 
803
}
 
804
 
 
805
#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */
 
806
 
 
807
/* this function was added to libpng 1.2.0 */
 
808
#if !defined(PNG_USE_PNGGCCRD) && \
 
809
    !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
 
810
int PNGAPI
 
811
png_mmx_support(void)
 
812
{
 
813
    return -1;
 
814
}
 
815
#endif
 
816
#endif /* PNG_1_0_X */
 
817
 
 
818
#ifdef PNG_SIZE_T
 
819
/* Added at libpng version 1.2.6 */
 
820
   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
 
821
png_size_t PNGAPI
 
822
png_convert_size(size_t size)
 
823
{
 
824
  if (size > (png_size_t)-1)
 
825
     PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
 
826
  return ((png_size_t)size);
 
827
}
 
828
#endif /* PNG_SIZE_T */