← Back to branch summary

~ubuntu-branches/ubuntu/maverick/ntop/maverick

« back to all changes in this revision

Viewing changes to gdchart0.94c/gd-1.8.3/libpng-1.0.8/pngpread.c

  • Committer: Bazaar Package Importer
  • Author(s): Dennis Schoen
  • Date: 2002-04-12 11:38:47 UTC
  • Revision ID: james.westby@ubuntu.com-20020412113847-4k4yydw0pzybc6g8
Tags: upstream-2.0.0
Import upstream version 2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdchart0.94c/gd-1.8.3/libpng-1.0.8/pngpread.c
 
1
 
 
2
/* pngpread.c - read a png file in push mode
 
3
 *
 
4
 * libpng 1.0.8 - July 24, 2000
 
5
 * For conditions of distribution and use, see copyright notice in png.h
 
6
 * Copyright (c) 1998, 1999, 2000 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
#include "png.h"
 
13
 
 
14
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 
15
 
 
16
/* push model modes */
 
17
#define PNG_READ_SIG_MODE   0
 
18
#define PNG_READ_CHUNK_MODE 1
 
19
#define PNG_READ_IDAT_MODE  2
 
20
#define PNG_SKIP_MODE       3
 
21
#define PNG_READ_tEXt_MODE  4
 
22
#define PNG_READ_zTXt_MODE  5
 
23
#define PNG_READ_DONE_MODE  6
 
24
#define PNG_READ_iTXt_MODE  7
 
25
#define PNG_ERROR_MODE      8
 
26
 
 
27
void PNGAPI
 
28
png_process_data(png_structp png_ptr, png_infop info_ptr,
 
29
   png_bytep buffer, png_size_t buffer_size)
 
30
{
 
31
   png_push_restore_buffer(png_ptr, buffer, buffer_size);
 
32
 
 
33
   while (png_ptr->buffer_size)
 
34
   {
 
35
      png_process_some_data(png_ptr, info_ptr);
 
36
   }
 
37
}
 
38
 
 
39
/* What we do with the incoming data depends on what we were previously
 
40
 * doing before we ran out of data...
 
41
 */
 
42
void /* PRIVATE */
 
43
png_process_some_data(png_structp png_ptr, png_infop info_ptr)
 
44
{
 
45
   switch (png_ptr->process_mode)
 
46
   {
 
47
      case PNG_READ_SIG_MODE:
 
48
      {
 
49
         png_push_read_sig(png_ptr, info_ptr);
 
50
         break;
 
51
      }
 
52
      case PNG_READ_CHUNK_MODE:
 
53
      {
 
54
         png_push_read_chunk(png_ptr, info_ptr);
 
55
         break;
 
56
      }
 
57
      case PNG_READ_IDAT_MODE:
 
58
      {
 
59
         png_push_read_IDAT(png_ptr);
 
60
         break;
 
61
      }
 
62
#if defined(PNG_READ_tEXt_SUPPORTED)
 
63
      case PNG_READ_tEXt_MODE:
 
64
      {
 
65
         png_push_read_tEXt(png_ptr, info_ptr);
 
66
         break;
 
67
      }
 
68
#endif
 
69
#if defined(PNG_READ_zTXt_SUPPORTED)
 
70
      case PNG_READ_zTXt_MODE:
 
71
      {
 
72
         png_push_read_zTXt(png_ptr, info_ptr);
 
73
         break;
 
74
      }
 
75
#endif
 
76
#if defined(PNG_READ_iTXt_SUPPORTED)
 
77
      case PNG_READ_iTXt_MODE:
 
78
      {
 
79
         png_push_read_iTXt(png_ptr, info_ptr);
 
80
         break;
 
81
      }
 
82
#endif
 
83
      case PNG_SKIP_MODE:
 
84
      {
 
85
         png_push_crc_finish(png_ptr);
 
86
         break;
 
87
      }
 
88
      default:
 
89
      {
 
90
         png_ptr->buffer_size = 0;
 
91
         break;
 
92
      }
 
93
   }
 
94
}
 
95
 
 
96
/* Read any remaining signature bytes from the stream and compare them with
 
97
 * the correct PNG signature.  It is possible that this routine is called
 
98
 * with bytes already read from the signature, either because they have been
 
99
 * checked by the calling application, or because of multiple calls to this
 
100
 * routine.
 
101
 */
 
102
void /* PRIVATE */
 
103
png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
 
104
{
 
105
   png_size_t num_checked = png_ptr->sig_bytes,
 
106
             num_to_check = 8 - num_checked;
 
107
 
 
108
   if (png_ptr->buffer_size < num_to_check)
 
109
   {
 
110
      num_to_check = png_ptr->buffer_size;
 
111
   }
 
112
 
 
113
   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
 
114
      num_to_check);
 
115
   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check);
 
116
 
 
117
   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
 
118
   {
 
119
      if (num_checked < 4 &&
 
120
          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
 
121
         png_error(png_ptr, "Not a PNG file");
 
122
      else
 
123
         png_error(png_ptr, "PNG file corrupted by ASCII conversion");
 
124
   }
 
125
   else
 
126
   {
 
127
      if (png_ptr->sig_bytes >= 8)
 
128
      {
 
129
         png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
130
      }
 
131
   }
 
132
}
 
133
 
 
134
void /* PRIVATE */
 
135
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
 
136
{
 
137
#ifdef PNG_USE_LOCAL_ARRAYS
 
138
      PNG_IHDR;
 
139
      PNG_IDAT;
 
140
      PNG_IEND;
 
141
      PNG_PLTE;
 
142
#if defined(PNG_READ_bKGD_SUPPORTED)
 
143
      PNG_bKGD;
 
144
#endif
 
145
#if defined(PNG_READ_cHRM_SUPPORTED)
 
146
      PNG_cHRM;
 
147
#endif
 
148
#if defined(PNG_READ_gAMA_SUPPORTED)
 
149
      PNG_gAMA;
 
150
#endif
 
151
#if defined(PNG_READ_hIST_SUPPORTED)
 
152
      PNG_hIST;
 
153
#endif
 
154
#if defined(PNG_READ_iCCP_SUPPORTED)
 
155
      PNG_iCCP;
 
156
#endif
 
157
#if defined(PNG_READ_iTXt_SUPPORTED)
 
158
      PNG_iTXt;
 
159
#endif
 
160
#if defined(PNG_READ_oFFs_SUPPORTED)
 
161
      PNG_oFFs;
 
162
#endif
 
163
#if defined(PNG_READ_pCAL_SUPPORTED)
 
164
      PNG_pCAL;
 
165
#endif
 
166
#if defined(PNG_READ_pHYs_SUPPORTED)
 
167
      PNG_pHYs;
 
168
#endif
 
169
#if defined(PNG_READ_sBIT_SUPPORTED)
 
170
      PNG_sBIT;
 
171
#endif
 
172
#if defined(PNG_READ_sCAL_SUPPORTED)
 
173
      PNG_sCAL;
 
174
#endif
 
175
#if defined(PNG_READ_sRGB_SUPPORTED)
 
176
      PNG_sRGB;
 
177
#endif
 
178
#if defined(PNG_READ_sPLT_SUPPORTED)
 
179
      PNG_sPLT;
 
180
#endif
 
181
#if defined(PNG_READ_tEXt_SUPPORTED)
 
182
      PNG_tEXt;
 
183
#endif
 
184
#if defined(PNG_READ_tIME_SUPPORTED)
 
185
      PNG_tIME;
 
186
#endif
 
187
#if defined(PNG_READ_tRNS_SUPPORTED)
 
188
      PNG_tRNS;
 
189
#endif
 
190
#if defined(PNG_READ_zTXt_SUPPORTED)
 
191
      PNG_zTXt;
 
192
#endif
 
193
#endif /* PNG_USE_LOCAL_ARRAYS */
 
194
   /* First we make sure we have enough data for the 4 byte chunk name
 
195
    * and the 4 byte chunk length before proceeding with decoding the
 
196
    * chunk data.  To fully decode each of these chunks, we also make
 
197
    * sure we have enough data in the buffer for the 4 byte CRC at the
 
198
    * end of every chunk (except IDAT, which is handled separately).
 
199
    */
 
200
   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 
201
   {
 
202
      png_byte chunk_length[4];
 
203
 
 
204
      if (png_ptr->buffer_size < 8)
 
205
      {
 
206
         png_push_save_buffer(png_ptr);
 
207
         return;
 
208
      }
 
209
 
 
210
      png_push_fill_buffer(png_ptr, chunk_length, 4);
 
211
      png_ptr->push_length = png_get_uint_32(chunk_length);
 
212
      png_reset_crc(png_ptr);
 
213
      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
 
214
      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 
215
   }
 
216
 
 
217
   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
 
218
   {
 
219
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
220
      {
 
221
         png_push_save_buffer(png_ptr);
 
222
         return;
 
223
      }
 
224
 
 
225
      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
 
226
   }
 
227
   else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
 
228
   {
 
229
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
230
      {
 
231
         png_push_save_buffer(png_ptr);
 
232
         return;
 
233
      }
 
234
 
 
235
      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
 
236
   }
 
237
   else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))
 
238
   {
 
239
      /* If we reach an IDAT chunk, this means we have read all of the
 
240
       * header chunks, and we can start reading the image (or if this
 
241
       * is called after the image has been read - we have an error).
 
242
       */
 
243
      if (png_ptr->mode & PNG_HAVE_IDAT)
 
244
      {
 
245
         if (png_ptr->push_length == 0)
 
246
            return;
 
247
 
 
248
         if (png_ptr->mode & PNG_AFTER_IDAT)
 
249
            png_error(png_ptr, "Too many IDAT's found");
 
250
      }
 
251
 
 
252
      png_ptr->idat_size = png_ptr->push_length;
 
253
      png_ptr->mode |= PNG_HAVE_IDAT;
 
254
      png_ptr->process_mode = PNG_READ_IDAT_MODE;
 
255
      png_push_have_info(png_ptr, info_ptr);
 
256
      png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
 
257
      png_ptr->zstream.next_out = png_ptr->row_buf;
 
258
      return;
 
259
   }
 
260
   else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
 
261
   {
 
262
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
263
      {
 
264
         png_push_save_buffer(png_ptr);
 
265
         return;
 
266
      }
 
267
 
 
268
      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 
269
      png_ptr->process_mode = PNG_READ_DONE_MODE;
 
270
      png_push_have_end(png_ptr, info_ptr);
 
271
   }
 
272
#if defined(PNG_READ_gAMA_SUPPORTED)
 
273
   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
 
274
   {
 
275
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
276
      {
 
277
         png_push_save_buffer(png_ptr);
 
278
         return;
 
279
      }
 
280
 
 
281
      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
 
282
   }
 
283
#endif
 
284
#if defined(PNG_READ_sBIT_SUPPORTED)
 
285
   else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
 
286
   {
 
287
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
288
      {
 
289
         png_push_save_buffer(png_ptr);
 
290
         return;
 
291
      }
 
292
 
 
293
      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
 
294
   }
 
295
#endif
 
296
#if defined(PNG_READ_cHRM_SUPPORTED)
 
297
   else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
 
298
   {
 
299
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
300
      {
 
301
         png_push_save_buffer(png_ptr);
 
302
         return;
 
303
      }
 
304
 
 
305
      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
 
306
   }
 
307
#endif
 
308
#if defined(PNG_READ_sRGB_SUPPORTED)
 
309
   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
 
310
   {
 
311
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
312
      {
 
313
         png_push_save_buffer(png_ptr);
 
314
         return;
 
315
      }
 
316
 
 
317
      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
 
318
   }
 
319
#endif
 
320
#if defined(PNG_READ_iCCP_SUPPORTED)
 
321
   else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
 
322
   {
 
323
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
324
      {
 
325
         png_push_save_buffer(png_ptr);
 
326
         return;
 
327
      }
 
328
 
 
329
      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
 
330
   }
 
331
#endif
 
332
#if defined(PNG_READ_sPLT_SUPPORTED)
 
333
   else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
 
334
   {
 
335
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
336
      {
 
337
         png_push_save_buffer(png_ptr);
 
338
         return;
 
339
      }
 
340
 
 
341
      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
 
342
   }
 
343
#endif
 
344
#if defined(PNG_READ_tRNS_SUPPORTED)
 
345
   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
 
346
   {
 
347
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
348
      {
 
349
         png_push_save_buffer(png_ptr);
 
350
         return;
 
351
      }
 
352
 
 
353
      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
 
354
   }
 
355
#endif
 
356
#if defined(PNG_READ_bKGD_SUPPORTED)
 
357
   else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
 
358
   {
 
359
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
360
      {
 
361
         png_push_save_buffer(png_ptr);
 
362
         return;
 
363
      }
 
364
 
 
365
      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
 
366
   }
 
367
#endif
 
368
#if defined(PNG_READ_hIST_SUPPORTED)
 
369
   else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
 
370
   {
 
371
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
372
      {
 
373
         png_push_save_buffer(png_ptr);
 
374
         return;
 
375
      }
 
376
 
 
377
      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
 
378
   }
 
379
#endif
 
380
#if defined(PNG_READ_pHYs_SUPPORTED)
 
381
   else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
 
382
   {
 
383
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
384
      {
 
385
         png_push_save_buffer(png_ptr);
 
386
         return;
 
387
      }
 
388
 
 
389
      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
 
390
   }
 
391
#endif
 
392
#if defined(PNG_READ_oFFs_SUPPORTED)
 
393
   else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
 
394
   {
 
395
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
396
      {
 
397
         png_push_save_buffer(png_ptr);
 
398
         return;
 
399
      }
 
400
 
 
401
      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
 
402
   }
 
403
#endif
 
404
#if defined(PNG_READ_pCAL_SUPPORTED)
 
405
   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
 
406
   {
 
407
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
408
      {
 
409
         png_push_save_buffer(png_ptr);
 
410
         return;
 
411
      }
 
412
 
 
413
      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
 
414
   }
 
415
#endif
 
416
#if defined(PNG_READ_sCAL_SUPPORTED)
 
417
   else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
 
418
   {
 
419
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
420
      {
 
421
         png_push_save_buffer(png_ptr);
 
422
         return;
 
423
      }
 
424
 
 
425
      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
 
426
   }
 
427
#endif
 
428
#if defined(PNG_READ_tIME_SUPPORTED)
 
429
   else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
 
430
   {
 
431
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
 
432
      {
 
433
         png_push_save_buffer(png_ptr);
 
434
         return;
 
435
      }
 
436
 
 
437
      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
 
438
   }
 
439
#endif
 
440
#if defined(PNG_READ_tEXt_SUPPORTED)
 
441
   else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
 
442
   {
 
443
      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
 
444
   }
 
445
#endif
 
446
#if defined(PNG_READ_zTXt_SUPPORTED)
 
447
   else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
 
448
   {
 
449
      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
 
450
   }
 
451
#endif
 
452
#if defined(PNG_READ_iTXt_SUPPORTED)
 
453
   else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
 
454
   {
 
455
      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
 
456
   }
 
457
#endif
 
458
   else
 
459
   {
 
460
      png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
 
461
   }
 
462
 
 
463
   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 
464
}
 
465
 
 
466
void /* PRIVATE */
 
467
png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
 
468
{
 
469
   png_ptr->process_mode = PNG_SKIP_MODE;
 
470
   png_ptr->skip_length = skip;
 
471
}
 
472
 
 
473
void /* PRIVATE */
 
474
png_push_crc_finish(png_structp png_ptr)
 
475
{
 
476
   if (png_ptr->skip_length && png_ptr->save_buffer_size)
 
477
   {
 
478
      png_size_t save_size;
 
479
 
 
480
      if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
 
481
         save_size = (png_size_t)png_ptr->skip_length;
 
482
      else
 
483
         save_size = png_ptr->save_buffer_size;
 
484
 
 
485
      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
486
 
 
487
      png_ptr->skip_length -= save_size;
 
488
      png_ptr->buffer_size -= save_size;
 
489
      png_ptr->save_buffer_size -= save_size;
 
490
      png_ptr->save_buffer_ptr += save_size;
 
491
   }
 
492
   if (png_ptr->skip_length && png_ptr->current_buffer_size)
 
493
   {
 
494
      png_size_t save_size;
 
495
 
 
496
      if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
 
497
         save_size = (png_size_t)png_ptr->skip_length;
 
498
      else
 
499
         save_size = png_ptr->current_buffer_size;
 
500
 
 
501
      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
502
 
 
503
      png_ptr->skip_length -= save_size;
 
504
      png_ptr->buffer_size -= save_size;
 
505
      png_ptr->current_buffer_size -= save_size;
 
506
      png_ptr->current_buffer_ptr += save_size;
 
507
   }
 
508
   if (!png_ptr->skip_length)
 
509
   {
 
510
      if (png_ptr->buffer_size < 4)
 
511
      {
 
512
         png_push_save_buffer(png_ptr);
 
513
         return;
 
514
      }
 
515
 
 
516
      png_crc_finish(png_ptr, 0);
 
517
      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
518
   }
 
519
}
 
520
 
 
521
void /* PRIVATE */
 
522
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
 
523
{
 
524
   png_bytep ptr;
 
525
 
 
526
   ptr = buffer;
 
527
   if (png_ptr->save_buffer_size)
 
528
   {
 
529
      png_size_t save_size;
 
530
 
 
531
      if (length < png_ptr->save_buffer_size)
 
532
         save_size = length;
 
533
      else
 
534
         save_size = png_ptr->save_buffer_size;
 
535
 
 
536
      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
 
537
      length -= save_size;
 
538
      ptr += save_size;
 
539
      png_ptr->buffer_size -= save_size;
 
540
      png_ptr->save_buffer_size -= save_size;
 
541
      png_ptr->save_buffer_ptr += save_size;
 
542
   }
 
543
   if (length && png_ptr->current_buffer_size)
 
544
   {
 
545
      png_size_t save_size;
 
546
 
 
547
      if (length < png_ptr->current_buffer_size)
 
548
         save_size = length;
 
549
      else
 
550
         save_size = png_ptr->current_buffer_size;
 
551
 
 
552
      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
 
553
      png_ptr->buffer_size -= save_size;
 
554
      png_ptr->current_buffer_size -= save_size;
 
555
      png_ptr->current_buffer_ptr += save_size;
 
556
   }
 
557
}
 
558
 
 
559
void /* PRIVATE */
 
560
png_push_save_buffer(png_structp png_ptr)
 
561
{
 
562
   if (png_ptr->save_buffer_size)
 
563
   {
 
564
      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
 
565
      {
 
566
         png_size_t i,istop;
 
567
         png_bytep sp;
 
568
         png_bytep dp;
 
569
 
 
570
         istop = png_ptr->save_buffer_size;
 
571
         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
 
572
            i < istop; i++, sp++, dp++)
 
573
         {
 
574
            *dp = *sp;
 
575
         }
 
576
      }
 
577
   }
 
578
   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
 
579
      png_ptr->save_buffer_max)
 
580
   {
 
581
      png_size_t new_max;
 
582
      png_bytep old_buffer;
 
583
 
 
584
      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
 
585
      old_buffer = png_ptr->save_buffer;
 
586
      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
 
587
         (png_uint_32)new_max);
 
588
      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
 
589
      png_free(png_ptr, old_buffer);
 
590
      png_ptr->save_buffer_max = new_max;
 
591
   }
 
592
   if (png_ptr->current_buffer_size)
 
593
   {
 
594
      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
 
595
         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
 
596
      png_ptr->save_buffer_size += png_ptr->current_buffer_size;
 
597
      png_ptr->current_buffer_size = 0;
 
598
   }
 
599
   png_ptr->save_buffer_ptr = png_ptr->save_buffer;
 
600
   png_ptr->buffer_size = 0;
 
601
}
 
602
 
 
603
void /* PRIVATE */
 
604
png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
 
605
   png_size_t buffer_length)
 
606
{
 
607
   png_ptr->current_buffer = buffer;
 
608
   png_ptr->current_buffer_size = buffer_length;
 
609
   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
 
610
   png_ptr->current_buffer_ptr = png_ptr->current_buffer;
 
611
}
 
612
 
 
613
void /* PRIVATE */
 
614
png_push_read_IDAT(png_structp png_ptr)
 
615
{
 
616
#ifdef PNG_USE_LOCAL_ARRAYS
 
617
   PNG_IDAT;
 
618
#endif
 
619
   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
 
620
   {
 
621
      png_byte chunk_length[4];
 
622
 
 
623
      if (png_ptr->buffer_size < 8)
 
624
      {
 
625
         png_push_save_buffer(png_ptr);
 
626
         return;
 
627
      }
 
628
 
 
629
      png_push_fill_buffer(png_ptr, chunk_length, 4);
 
630
      png_ptr->push_length = png_get_uint_32(chunk_length);
 
631
 
 
632
      png_reset_crc(png_ptr);
 
633
      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
 
634
      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 
635
 
 
636
      if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))
 
637
      {
 
638
         png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
639
         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
 
640
            png_error(png_ptr, "Not enough compressed data");
 
641
         return;
 
642
      }
 
643
 
 
644
      png_ptr->idat_size = png_ptr->push_length;
 
645
   }
 
646
   if (png_ptr->idat_size && png_ptr->save_buffer_size)
 
647
   {
 
648
      png_size_t save_size;
 
649
 
 
650
      if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
 
651
      {
 
652
         save_size = (png_size_t)png_ptr->idat_size;
 
653
         /* check for overflow */
 
654
         if((png_uint_32)save_size != png_ptr->idat_size)
 
655
            png_error(png_ptr, "save_size overflowed in pngpread");
 
656
      }
 
657
      else
 
658
         save_size = png_ptr->save_buffer_size;
 
659
 
 
660
      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
661
      png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
662
 
 
663
      png_ptr->idat_size -= save_size;
 
664
      png_ptr->buffer_size -= save_size;
 
665
      png_ptr->save_buffer_size -= save_size;
 
666
      png_ptr->save_buffer_ptr += save_size;
 
667
   }
 
668
   if (png_ptr->idat_size && png_ptr->current_buffer_size)
 
669
   {
 
670
      png_size_t save_size;
 
671
 
 
672
      if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
 
673
      {
 
674
         save_size = (png_size_t)png_ptr->idat_size;
 
675
         /* check for overflow */
 
676
         if((png_uint_32)save_size != png_ptr->idat_size)
 
677
            png_error(png_ptr, "save_size overflowed in pngpread");
 
678
      }
 
679
      else
 
680
         save_size = png_ptr->current_buffer_size;
 
681
 
 
682
      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
683
      png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
684
 
 
685
      png_ptr->idat_size -= save_size;
 
686
      png_ptr->buffer_size -= save_size;
 
687
      png_ptr->current_buffer_size -= save_size;
 
688
      png_ptr->current_buffer_ptr += save_size;
 
689
   }
 
690
   if (!png_ptr->idat_size)
 
691
   {
 
692
      if (png_ptr->buffer_size < 4)
 
693
      {
 
694
         png_push_save_buffer(png_ptr);
 
695
         return;
 
696
      }
 
697
 
 
698
      png_crc_finish(png_ptr, 0);
 
699
      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 
700
   }
 
701
}
 
702
 
 
703
void /* PRIVATE */
 
704
png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
 
705
   png_size_t buffer_length)
 
706
{
 
707
   int ret;
 
708
 
 
709
   if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)
 
710
      png_error(png_ptr, "Extra compression data");
 
711
 
 
712
   png_ptr->zstream.next_in = buffer;
 
713
   png_ptr->zstream.avail_in = (uInt)buffer_length;
 
714
   for(;;)
 
715
   {
 
716
      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
 
717
      if (ret != Z_OK)
 
718
      {
 
719
         if (ret == Z_STREAM_END)
 
720
         {
 
721
            if (png_ptr->zstream.avail_in)
 
722
               png_error(png_ptr, "Extra compressed data");
 
723
            if (!(png_ptr->zstream.avail_out))
 
724
            {
 
725
               png_push_process_row(png_ptr);
 
726
            }
 
727
 
 
728
            png_ptr->mode |= PNG_AFTER_IDAT;
 
729
            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 
730
            break;
 
731
         }
 
732
         else if (ret == Z_BUF_ERROR)
 
733
            break;
 
734
         else
 
735
            png_error(png_ptr, "Decompression Error");
 
736
      }
 
737
      if (!(png_ptr->zstream.avail_out))
 
738
      {
 
739
         png_push_process_row(png_ptr);
 
740
         png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
 
741
         png_ptr->zstream.next_out = png_ptr->row_buf;
 
742
      }
 
743
      else
 
744
         break;
 
745
   }
 
746
}
 
747
 
 
748
void /* PRIVATE */
 
749
png_push_process_row(png_structp png_ptr)
 
750
{
 
751
   png_ptr->row_info.color_type = png_ptr->color_type;
 
752
   png_ptr->row_info.width = png_ptr->iwidth;
 
753
   png_ptr->row_info.channels = png_ptr->channels;
 
754
   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
 
755
   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
 
756
 
 
757
   png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
 
758
      (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
 
759
 
 
760
   png_read_filter_row(png_ptr, &(png_ptr->row_info),
 
761
      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
 
762
      (int)(png_ptr->row_buf[0]));
 
763
 
 
764
   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
 
765
      png_ptr->rowbytes + 1);
 
766
 
 
767
   if (png_ptr->transformations)
 
768
      png_do_read_transformations(png_ptr);
 
769
 
 
770
#if defined(PNG_READ_INTERLACING_SUPPORTED)
 
771
   /* blow up interlaced rows to full size */
 
772
   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
 
773
   {
 
774
      if (png_ptr->pass < 6)
 
775
         png_do_read_interlace(&(png_ptr->row_info),
 
776
            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
 
777
 
 
778
      switch (png_ptr->pass)
 
779
      {
 
780
         case 0:
 
781
         {
 
782
            int i;
 
783
            for (i = 0; i < 8 && png_ptr->pass == 0; i++)
 
784
            {
 
785
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
786
               png_read_push_finish_row(png_ptr);
 
787
            }
 
788
            break;
 
789
         }
 
790
         case 1:
 
791
         {
 
792
            int i;
 
793
            for (i = 0; i < 8 && png_ptr->pass == 1; i++)
 
794
            {
 
795
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
796
               png_read_push_finish_row(png_ptr);
 
797
            }
 
798
            if (png_ptr->pass == 2)
 
799
            {
 
800
               for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 
801
               {
 
802
                  png_push_have_row(png_ptr, NULL);
 
803
                  png_read_push_finish_row(png_ptr);
 
804
               }
 
805
            }
 
806
            break;
 
807
         }
 
808
         case 2:
 
809
         {
 
810
            int i;
 
811
            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 
812
            {
 
813
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
814
               png_read_push_finish_row(png_ptr);
 
815
            }
 
816
            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
 
817
            {
 
818
               png_push_have_row(png_ptr, NULL);
 
819
               png_read_push_finish_row(png_ptr);
 
820
            }
 
821
            break;
 
822
         }
 
823
         case 3:
 
824
         {
 
825
            int i;
 
826
            for (i = 0; i < 4 && png_ptr->pass == 3; i++)
 
827
            {
 
828
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
829
               png_read_push_finish_row(png_ptr);
 
830
            }
 
831
            if (png_ptr->pass == 4)
 
832
            {
 
833
               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 
834
               {
 
835
                  png_push_have_row(png_ptr, NULL);
 
836
                  png_read_push_finish_row(png_ptr);
 
837
               }
 
838
            }
 
839
            break;
 
840
         }
 
841
         case 4:
 
842
         {
 
843
            int i;
 
844
            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 
845
            {
 
846
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
847
               png_read_push_finish_row(png_ptr);
 
848
            }
 
849
            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
 
850
            {
 
851
               png_push_have_row(png_ptr, NULL);
 
852
               png_read_push_finish_row(png_ptr);
 
853
            }
 
854
            break;
 
855
         }
 
856
         case 5:
 
857
         {
 
858
            int i;
 
859
            for (i = 0; i < 2 && png_ptr->pass == 5; i++)
 
860
            {
 
861
               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
862
               png_read_push_finish_row(png_ptr);
 
863
            }
 
864
            if (png_ptr->pass == 6)
 
865
            {
 
866
               png_push_have_row(png_ptr, NULL);
 
867
               png_read_push_finish_row(png_ptr);
 
868
            }
 
869
            break;
 
870
         }
 
871
         case 6:
 
872
         {
 
873
            png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
874
            png_read_push_finish_row(png_ptr);
 
875
            if (png_ptr->pass != 6)
 
876
               break;
 
877
            png_push_have_row(png_ptr, NULL);
 
878
            png_read_push_finish_row(png_ptr);
 
879
         }
 
880
      }
 
881
   }
 
882
   else
 
883
#endif
 
884
   {
 
885
      png_push_have_row(png_ptr, png_ptr->row_buf + 1);
 
886
      png_read_push_finish_row(png_ptr);
 
887
   }
 
888
}
 
889
 
 
890
void /* PRIVATE */
 
891
png_read_push_finish_row(png_structp png_ptr)
 
892
{
 
893
#ifdef PNG_USE_LOCAL_ARRAYS
 
894
   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
895
 
 
896
   /* start of interlace block */
 
897
   const int png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 
898
 
 
899
   /* offset to next interlace block */
 
900
   const int png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 
901
 
 
902
   /* start of interlace block in the y direction */
 
903
   const int png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 
904
 
 
905
   /* offset to next interlace block in the y direction */
 
906
   const int png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
 
907
 
 
908
   /* Width of interlace block.  This is not currently used - if you need
 
909
    * it, uncomment it here and in png.h
 
910
   const int png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
 
911
   */
 
912
 
 
913
   /* Height of interlace block.  This is not currently used - if you need
 
914
    * it, uncomment it here and in png.h
 
915
   const int png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
 
916
   */
 
917
#endif
 
918
 
 
919
   png_ptr->row_number++;
 
920
   if (png_ptr->row_number < png_ptr->num_rows)
 
921
      return;
 
922
 
 
923
   if (png_ptr->interlaced)
 
924
   {
 
925
      png_ptr->row_number = 0;
 
926
      png_memset_check(png_ptr, png_ptr->prev_row, 0,
 
927
         png_ptr->rowbytes + 1);
 
928
      do
 
929
      {
 
930
         png_ptr->pass++;
 
931
         if (png_ptr->pass >= 7)
 
932
            break;
 
933
 
 
934
         png_ptr->iwidth = (png_ptr->width +
 
935
            png_pass_inc[png_ptr->pass] - 1 -
 
936
            png_pass_start[png_ptr->pass]) /
 
937
            png_pass_inc[png_ptr->pass];
 
938
 
 
939
         png_ptr->irowbytes = ((png_ptr->iwidth *
 
940
            png_ptr->pixel_depth + 7) >> 3) + 1;
 
941
 
 
942
         if (png_ptr->transformations & PNG_INTERLACE)
 
943
            break;
 
944
 
 
945
         png_ptr->num_rows = (png_ptr->height +
 
946
            png_pass_yinc[png_ptr->pass] - 1 -
 
947
            png_pass_ystart[png_ptr->pass]) /
 
948
            png_pass_yinc[png_ptr->pass];
 
949
 
 
950
      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
 
951
   }
 
952
}
 
953
 
 
954
#if defined(PNG_READ_tEXt_SUPPORTED)
 
955
void /* PRIVATE */
 
956
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
957
{
 
958
   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
 
959
      {
 
960
         png_error(png_ptr, "Out of place tEXt");
 
961
         /* to quiet some compiler warnings */
 
962
         if(info_ptr == NULL) return;
 
963
      }
 
964
 
 
965
#ifdef PNG_MAX_MALLOC_64K
 
966
   png_ptr->skip_length = 0;  /* This may not be necessary */
 
967
 
 
968
   if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
 
969
   {
 
970
      png_warning(png_ptr, "tEXt chunk too large to fit in memory");
 
971
      png_ptr->skip_length = length - (png_uint_32)65535L;
 
972
      length = (png_uint_32)65535L;
 
973
   }
 
974
#endif
 
975
 
 
976
   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
 
977
         (png_uint_32)(length+1));
 
978
   png_ptr->current_text[length] = '\0';
 
979
   png_ptr->current_text_ptr = png_ptr->current_text;
 
980
   png_ptr->current_text_size = (png_size_t)length;
 
981
   png_ptr->current_text_left = (png_size_t)length;
 
982
   png_ptr->process_mode = PNG_READ_tEXt_MODE;
 
983
}
 
984
 
 
985
void /* PRIVATE */
 
986
png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
 
987
{
 
988
   if (png_ptr->buffer_size && png_ptr->current_text_left)
 
989
   {
 
990
      png_size_t text_size;
 
991
 
 
992
      if (png_ptr->buffer_size < png_ptr->current_text_left)
 
993
         text_size = png_ptr->buffer_size;
 
994
      else
 
995
         text_size = png_ptr->current_text_left;
 
996
      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
 
997
      png_ptr->current_text_left -= text_size;
 
998
      png_ptr->current_text_ptr += text_size;
 
999
   }
 
1000
   if (!(png_ptr->current_text_left))
 
1001
   {
 
1002
      png_textp text_ptr;
 
1003
      png_charp text;
 
1004
      png_charp key;
 
1005
 
 
1006
      if (png_ptr->buffer_size < 4)
 
1007
      {
 
1008
         png_push_save_buffer(png_ptr);
 
1009
         return;
 
1010
      }
 
1011
 
 
1012
      png_push_crc_finish(png_ptr);
 
1013
 
 
1014
#if defined(PNG_MAX_MALLOC_64K)
 
1015
      if (png_ptr->skip_length)
 
1016
         return;
 
1017
#endif
 
1018
 
 
1019
      key = png_ptr->current_text;
 
1020
      png_ptr->current_text = 0;
 
1021
 
 
1022
      for (text = key; *text; text++)
 
1023
         /* empty loop */ ;
 
1024
 
 
1025
      if (text != key + png_ptr->current_text_size)
 
1026
         text++;
 
1027
 
 
1028
      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
 
1029
      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
 
1030
      text_ptr->key = key;
 
1031
#ifdef PNG_iTXt_SUPPORTED
 
1032
      text_ptr->lang = (char *)NULL;
 
1033
      text_ptr->lang_key = (char *)NULL;
 
1034
#endif
 
1035
      text_ptr->text = text;
 
1036
 
 
1037
      png_set_text(png_ptr, info_ptr, text_ptr, 1);
 
1038
 
 
1039
      png_free(png_ptr, key);
 
1040
      png_free(png_ptr, text_ptr);
 
1041
   }
 
1042
}
 
1043
#endif
 
1044
 
 
1045
#if defined(PNG_READ_zTXt_SUPPORTED)
 
1046
void /* PRIVATE */
 
1047
png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
1048
{
 
1049
   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
 
1050
      {
 
1051
         png_error(png_ptr, "Out of place zTXt");
 
1052
         /* to quiet some compiler warnings */
 
1053
         if(info_ptr == NULL) return;
 
1054
      }
 
1055
 
 
1056
#ifdef PNG_MAX_MALLOC_64K
 
1057
   /* We can't handle zTXt chunks > 64K, since we don't have enough space
 
1058
    * to be able to store the uncompressed data.  Actually, the threshold
 
1059
    * is probably around 32K, but it isn't as definite as 64K is.
 
1060
    */
 
1061
   if (length > (png_uint_32)65535L)
 
1062
   {
 
1063
      png_warning(png_ptr, "zTXt chunk too large to fit in memory");
 
1064
      png_push_crc_skip(png_ptr, length);
 
1065
      return;
 
1066
   }
 
1067
#endif
 
1068
 
 
1069
   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
 
1070
       (png_uint_32)(length+1));
 
1071
   png_ptr->current_text[length] = '\0';
 
1072
   png_ptr->current_text_ptr = png_ptr->current_text;
 
1073
   png_ptr->current_text_size = (png_size_t)length;
 
1074
   png_ptr->current_text_left = (png_size_t)length;
 
1075
   png_ptr->process_mode = PNG_READ_zTXt_MODE;
 
1076
}
 
1077
 
 
1078
void /* PRIVATE */
 
1079
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
 
1080
{
 
1081
   if (png_ptr->buffer_size && png_ptr->current_text_left)
 
1082
   {
 
1083
      png_size_t text_size;
 
1084
 
 
1085
      if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
 
1086
         text_size = png_ptr->buffer_size;
 
1087
      else
 
1088
         text_size = png_ptr->current_text_left;
 
1089
      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
 
1090
      png_ptr->current_text_left -= text_size;
 
1091
      png_ptr->current_text_ptr += text_size;
 
1092
   }
 
1093
   if (!(png_ptr->current_text_left))
 
1094
   {
 
1095
      png_textp text_ptr;
 
1096
      png_charp text;
 
1097
      png_charp key;
 
1098
      int ret;
 
1099
      png_size_t text_size, key_size;
 
1100
 
 
1101
      if (png_ptr->buffer_size < 4)
 
1102
      {
 
1103
         png_push_save_buffer(png_ptr);
 
1104
         return;
 
1105
      }
 
1106
 
 
1107
      png_push_crc_finish(png_ptr);
 
1108
 
 
1109
      key = png_ptr->current_text;
 
1110
      png_ptr->current_text = 0;
 
1111
 
 
1112
      for (text = key; *text; text++)
 
1113
         /* empty loop */ ;
 
1114
 
 
1115
      /* zTXt can't have zero text */
 
1116
      if (text == key + png_ptr->current_text_size)
 
1117
      {
 
1118
         png_free(png_ptr, key);
 
1119
         return;
 
1120
      }
 
1121
 
 
1122
      text++;
 
1123
 
 
1124
      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */
 
1125
      {
 
1126
         png_free(png_ptr, key);
 
1127
         return;
 
1128
      }
 
1129
 
 
1130
      text++;
 
1131
 
 
1132
      png_ptr->zstream.next_in = (png_bytep )text;
 
1133
      png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
 
1134
         (text - key));
 
1135
      png_ptr->zstream.next_out = png_ptr->zbuf;
 
1136
      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 
1137
 
 
1138
      key_size = text - key;
 
1139
      text_size = 0;
 
1140
      text = NULL;
 
1141
      ret = Z_STREAM_END;
 
1142
 
 
1143
      while (png_ptr->zstream.avail_in)
 
1144
      {
 
1145
         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
 
1146
         if (ret != Z_OK && ret != Z_STREAM_END)
 
1147
         {
 
1148
            inflateReset(&png_ptr->zstream);
 
1149
            png_ptr->zstream.avail_in = 0;
 
1150
            png_free(png_ptr, key);
 
1151
            png_free(png_ptr, text);
 
1152
            return;
 
1153
         }
 
1154
         if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
 
1155
         {
 
1156
            if (text == NULL)
 
1157
            {
 
1158
               text = (png_charp)png_malloc(png_ptr,
 
1159
                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out +
 
1160
                     key_size + 1));
 
1161
               png_memcpy(text + key_size, png_ptr->zbuf,
 
1162
                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
 
1163
               png_memcpy(text, key, key_size);
 
1164
               text_size = key_size + png_ptr->zbuf_size -
 
1165
                  png_ptr->zstream.avail_out;
 
1166
               *(text + text_size) = '\0';
 
1167
            }
 
1168
            else
 
1169
            {
 
1170
               png_charp tmp;
 
1171
 
 
1172
               tmp = text;
 
1173
               text = (png_charp)png_malloc(png_ptr, text_size +
 
1174
                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
 
1175
                   + 1));
 
1176
               png_memcpy(text, tmp, text_size);
 
1177
               png_free(png_ptr, tmp);
 
1178
               png_memcpy(text + text_size, png_ptr->zbuf,
 
1179
                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
 
1180
               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
 
1181
               *(text + text_size) = '\0';
 
1182
            }
 
1183
            if (ret != Z_STREAM_END)
 
1184
            {
 
1185
               png_ptr->zstream.next_out = png_ptr->zbuf;
 
1186
               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 
1187
            }
 
1188
         }
 
1189
         else
 
1190
         {
 
1191
            break;
 
1192
         }
 
1193
 
 
1194
         if (ret == Z_STREAM_END)
 
1195
            break;
 
1196
      }
 
1197
 
 
1198
      inflateReset(&png_ptr->zstream);
 
1199
      png_ptr->zstream.avail_in = 0;
 
1200
 
 
1201
      if (ret != Z_STREAM_END)
 
1202
      {
 
1203
         png_free(png_ptr, key);
 
1204
         png_free(png_ptr, text);
 
1205
         return;
 
1206
      }
 
1207
 
 
1208
      png_free(png_ptr, key);
 
1209
      key = text;
 
1210
      text += key_size;
 
1211
 
 
1212
      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
 
1213
      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
 
1214
      text_ptr->key = key;
 
1215
#ifdef PNG_iTXt_SUPPORTED
 
1216
      text_ptr->lang = (char *)NULL;
 
1217
      text_ptr->lang_key = (char *)NULL;
 
1218
#endif
 
1219
      text_ptr->text = text;
 
1220
 
 
1221
      png_set_text(png_ptr, info_ptr, text_ptr, 1);
 
1222
 
 
1223
      png_free(png_ptr, key);
 
1224
      png_free(png_ptr, text_ptr);
 
1225
   }
 
1226
}
 
1227
#endif
 
1228
 
 
1229
#if defined(PNG_READ_iTXt_SUPPORTED)
 
1230
void /* PRIVATE */
 
1231
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
1232
{
 
1233
   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
 
1234
      {
 
1235
         png_error(png_ptr, "Out of place iTXt");
 
1236
         /* to quiet some compiler warnings */
 
1237
         if(info_ptr == NULL) return;
 
1238
      }
 
1239
 
 
1240
#ifdef PNG_MAX_MALLOC_64K
 
1241
   png_ptr->skip_length = 0;  /* This may not be necessary */
 
1242
 
 
1243
   if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
 
1244
   {
 
1245
      png_warning(png_ptr, "iTXt chunk too large to fit in memory");
 
1246
      png_ptr->skip_length = length - (png_uint_32)65535L;
 
1247
      length = (png_uint_32)65535L;
 
1248
   }
 
1249
#endif
 
1250
 
 
1251
   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
 
1252
         (png_uint_32)(length+1));
 
1253
   png_ptr->current_text[length] = '\0';
 
1254
   png_ptr->current_text_ptr = png_ptr->current_text;
 
1255
   png_ptr->current_text_size = (png_size_t)length;
 
1256
   png_ptr->current_text_left = (png_size_t)length;
 
1257
   png_ptr->process_mode = PNG_READ_iTXt_MODE;
 
1258
}
 
1259
 
 
1260
void /* PRIVATE */
 
1261
png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
 
1262
{
 
1263
 
 
1264
   if (png_ptr->buffer_size && png_ptr->current_text_left)
 
1265
   {
 
1266
      png_size_t text_size;
 
1267
 
 
1268
      if (png_ptr->buffer_size < png_ptr->current_text_left)
 
1269
         text_size = png_ptr->buffer_size;
 
1270
      else
 
1271
         text_size = png_ptr->current_text_left;
 
1272
      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
 
1273
      png_ptr->current_text_left -= text_size;
 
1274
      png_ptr->current_text_ptr += text_size;
 
1275
   }
 
1276
   if (!(png_ptr->current_text_left))
 
1277
   {
 
1278
      png_textp text_ptr;
 
1279
      png_charp key;
 
1280
      int comp_flag;
 
1281
      png_charp lang;
 
1282
      png_charp lang_key;
 
1283
      png_charp text;
 
1284
 
 
1285
      if (png_ptr->buffer_size < 4)
 
1286
      {
 
1287
         png_push_save_buffer(png_ptr);
 
1288
         return;
 
1289
      }
 
1290
 
 
1291
      png_push_crc_finish(png_ptr);
 
1292
 
 
1293
#if defined(PNG_MAX_MALLOC_64K)
 
1294
      if (png_ptr->skip_length)
 
1295
         return;
 
1296
#endif
 
1297
 
 
1298
      key = png_ptr->current_text;
 
1299
      png_ptr->current_text = 0;
 
1300
 
 
1301
      for (lang = key; *lang; lang++)
 
1302
         /* empty loop */ ;
 
1303
 
 
1304
      if (lang != key + png_ptr->current_text_size)
 
1305
         lang++;
 
1306
 
 
1307
      comp_flag = *lang++;
 
1308
      lang++;     /* skip comp_type, always zero */
 
1309
 
 
1310
      for (lang_key = lang; *lang_key; lang_key++)
 
1311
         /* empty loop */ ;
 
1312
      lang_key++;        /* skip NUL separator */
 
1313
 
 
1314
      for (text = lang_key; *text; text++)
 
1315
         /* empty loop */ ;
 
1316
 
 
1317
      if (text != key + png_ptr->current_text_size)
 
1318
         text++;
 
1319
 
 
1320
      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
 
1321
      text_ptr->compression = comp_flag + 2;
 
1322
      text_ptr->key = key;
 
1323
      text_ptr->lang = lang;
 
1324
      text_ptr->lang_key = lang_key;
 
1325
      text_ptr->text = text;
 
1326
      text_ptr->text_length = 0;
 
1327
      text_ptr->itxt_length = png_strlen(text);
 
1328
 
 
1329
      png_set_text(png_ptr, info_ptr, text_ptr, 1);
 
1330
 
 
1331
      png_free(png_ptr, text_ptr);
 
1332
   }
 
1333
}
 
1334
#endif
 
1335
 
 
1336
/* This function is called when we haven't found a handler for this
 
1337
 * chunk.  If there isn't a problem with the chunk itself (ie a bad chunk
 
1338
 * name or a critical chunk), the chunk is (currently) silently ignored.
 
1339
 */
 
1340
void /* PRIVATE */
 
1341
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
1342
{
 
1343
   png_uint_32 skip=0;
 
1344
   png_check_chunk_name(png_ptr, png_ptr->chunk_name);
 
1345
 
 
1346
   if (!(png_ptr->chunk_name[0] & 0x20))
 
1347
   {
 
1348
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
 
1349
      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
 
1350
           HANDLE_CHUNK_ALWAYS
 
1351
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
 
1352
           && png_ptr->read_user_chunk_fn == (png_user_chunk_ptr)NULL
 
1353
#endif
 
1354
         )
 
1355
#endif
 
1356
         png_chunk_error(png_ptr, "unknown critical chunk");
 
1357
 
 
1358
      /* to quiet compiler warnings about unused info_ptr */
 
1359
      if (info_ptr == NULL)
 
1360
         return;
 
1361
   }
 
1362
 
 
1363
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
 
1364
   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
 
1365
   {
 
1366
       png_unknown_chunk chunk;
 
1367
 
 
1368
#ifdef PNG_MAX_MALLOC_64K
 
1369
       if (length > (png_uint_32)65535L)
 
1370
       {
 
1371
           png_warning(png_ptr, "unknown chunk too large to fit in memory");
 
1372
           skip = length - (png_uint_32)65535L;
 
1373
           length = (png_uint_32)65535L;
 
1374
       }
 
1375
#endif
 
1376
 
 
1377
       strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);
 
1378
       chunk.data = (png_bytep)png_malloc(png_ptr, length);
 
1379
       png_crc_read(png_ptr, chunk.data, length);
 
1380
       chunk.size = length;
 
1381
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
 
1382
       if(png_ptr->read_user_chunk_fn != (png_user_chunk_ptr)NULL)
 
1383
       {
 
1384
          /* callback to user unknown chunk handler */
 
1385
          if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0)
 
1386
          {
 
1387
             if (!(png_ptr->chunk_name[0] & 0x20))
 
1388
                if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
 
1389
                     HANDLE_CHUNK_ALWAYS)
 
1390
                   png_chunk_error(png_ptr, "unknown critical chunk");
 
1391
          }
 
1392
             png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
 
1393
       }
 
1394
       else
 
1395
#endif
 
1396
          png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
 
1397
       png_free(png_ptr, chunk.data);
 
1398
   }
 
1399
   else
 
1400
#endif
 
1401
      skip=length;
 
1402
   png_push_crc_skip(png_ptr, skip);
 
1403
}
 
1404
 
 
1405
void /* PRIVATE */
 
1406
png_push_have_info(png_structp png_ptr, png_infop info_ptr)
 
1407
{
 
1408
   if (png_ptr->info_fn != NULL)
 
1409
      (*(png_ptr->info_fn))(png_ptr, info_ptr);
 
1410
}
 
1411
 
 
1412
void /* PRIVATE */
 
1413
png_push_have_end(png_structp png_ptr, png_infop info_ptr)
 
1414
{
 
1415
   if (png_ptr->end_fn != NULL)
 
1416
      (*(png_ptr->end_fn))(png_ptr, info_ptr);
 
1417
}
 
1418
 
 
1419
void /* PRIVATE */
 
1420
png_push_have_row(png_structp png_ptr, png_bytep row)
 
1421
{
 
1422
   if (png_ptr->row_fn != NULL)
 
1423
      (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
 
1424
         (int)png_ptr->pass);
 
1425
}
 
1426
 
 
1427
void PNGAPI
 
1428
png_progressive_combine_row (png_structp png_ptr,
 
1429
   png_bytep old_row, png_bytep new_row)
 
1430
{
 
1431
#ifdef PNG_USE_LOCAL_ARRAYS
 
1432
   const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
 
1433
#endif
 
1434
   if (new_row != NULL)    /* new_row must == png_ptr->row_buf here. */
 
1435
      png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
 
1436
}
 
1437
 
 
1438
void PNGAPI
 
1439
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
 
1440
   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
 
1441
   png_progressive_end_ptr end_fn)
 
1442
{
 
1443
   png_ptr->info_fn = info_fn;
 
1444
   png_ptr->row_fn = row_fn;
 
1445
   png_ptr->end_fn = end_fn;
 
1446
 
 
1447
   png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
 
1448
}
 
1449
 
 
1450
png_voidp PNGAPI
 
1451
png_get_progressive_ptr(png_structp png_ptr)
 
1452
{
 
1453
   return png_ptr->io_ptr;
 
1454
}
 
1455
 
 
1456
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
 
1457