close Warning: Can't use blame annotator: 
No changeset 422 in the repository

source: liacs/MIR2010/SourceCode/cximage/png/pngpread.c@ 422

Last change on this file since 422 was 95, checked in by Rick van der Zwet, 15 years ago

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