projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge from amd64 branch:
[reactos.git] / rosapps / lib / libpng / pngpread.c
1
2 /* pngpread.c - read a png file in push mode
3 *
4 * Last changed in libpng 1.2.23 [November 6, 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
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 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 */
43 void /* PRIVATE */
44 png_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 */
104 void /* PRIVATE */
105 png_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
136 void /* PRIVATE */
137 png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
138 {
139 #ifdef PNG_USE_LOCAL_ARRAYS
140 PNG_CONST PNG_IHDR;
141 PNG_CONST PNG_IDAT;
142 PNG_CONST PNG_IEND;
143 PNG_CONST PNG_PLTE;
144 #if defined(PNG_READ_bKGD_SUPPORTED)
145 PNG_CONST PNG_bKGD;
146 #endif
147 #if defined(PNG_READ_cHRM_SUPPORTED)
148 PNG_CONST PNG_cHRM;
149 #endif
150 #if defined(PNG_READ_gAMA_SUPPORTED)
151 PNG_CONST PNG_gAMA;
152 #endif
153 #if defined(PNG_READ_hIST_SUPPORTED)
154 PNG_CONST PNG_hIST;
155 #endif
156 #if defined(PNG_READ_iCCP_SUPPORTED)
157 PNG_CONST PNG_iCCP;
158 #endif
159 #if defined(PNG_READ_iTXt_SUPPORTED)
160 PNG_CONST PNG_iTXt;
161 #endif
162 #if defined(PNG_READ_oFFs_SUPPORTED)
163 PNG_CONST PNG_oFFs;
164 #endif
165 #if defined(PNG_READ_pCAL_SUPPORTED)
166 PNG_CONST PNG_pCAL;
167 #endif
168 #if defined(PNG_READ_pHYs_SUPPORTED)
169 PNG_CONST PNG_pHYs;
170 #endif
171 #if defined(PNG_READ_sBIT_SUPPORTED)
172 PNG_CONST PNG_sBIT;
173 #endif
174 #if defined(PNG_READ_sCAL_SUPPORTED)
175 PNG_CONST PNG_sCAL;
176 #endif
177 #if defined(PNG_READ_sRGB_SUPPORTED)
178 PNG_CONST PNG_sRGB;
179 #endif
180 #if defined(PNG_READ_sPLT_SUPPORTED)
181 PNG_CONST PNG_sPLT;
182 #endif
183 #if defined(PNG_READ_tEXt_SUPPORTED)
184 PNG_CONST PNG_tEXt;
185 #endif
186 #if defined(PNG_READ_tIME_SUPPORTED)
187 PNG_CONST PNG_tIME;
188 #endif
189 #if defined(PNG_READ_tRNS_SUPPORTED)
190 PNG_CONST PNG_tRNS;
191 #endif
192 #if defined(PNG_READ_zTXt_SUPPORTED)
193 PNG_CONST 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_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_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
506 void /* PRIVATE */
507 png_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
513 void /* PRIVATE */
514 png_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
561 void PNGAPI
562 png_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
600 void /* PRIVATE */
601 png_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
649 void /* PRIVATE */
650 png_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
659 void /* PRIVATE */
660 png_push_read_IDAT(png_structp png_ptr)
661 {
662 #ifdef PNG_USE_LOCAL_ARRAYS
663 PNG_CONST 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_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
750 void /* PRIVATE */
751 png_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
807 void /* PRIVATE */
808 png_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
986 void /* PRIVATE */
987 png_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 PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
994
995 /* offset to next interlace block */
996 PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
997
998 /* start of interlace block in the y direction */
999 PNG_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 PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
1003
1004 /* Height of interlace block. This is not currently used - if you need
1005 * it, uncomment it here and in png.h
1006 PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
1007 */
1008 #endif
1009
1010 png_ptr->row_number++;
1011 if (png_ptr->row_number < png_ptr->num_rows)
1012 return;
1013
1014 if (png_ptr->interlaced)
1015 {
1016 png_ptr->row_number = 0;
1017 png_memset_check(png_ptr, png_ptr->prev_row, 0,
1018 png_ptr->rowbytes + 1);
1019 do
1020 {
1021 png_ptr->pass++;
1022 if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
1023 (png_ptr->pass == 3 && png_ptr->width < 3) ||
1024 (png_ptr->pass == 5 && png_ptr->width < 2))
1025 png_ptr->pass++;
1026
1027 if (png_ptr->pass > 7)
1028 png_ptr->pass--;
1029 if (png_ptr->pass >= 7)
1030 break;
1031
1032 png_ptr->iwidth = (png_ptr->width +
1033 png_pass_inc[png_ptr->pass] - 1 -
1034 png_pass_start[png_ptr->pass]) /
1035 png_pass_inc[png_ptr->pass];
1036
1037 png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
1038 png_ptr->iwidth) + 1;
1039
1040 if (png_ptr->transformations & PNG_INTERLACE)
1041 break;
1042
1043 png_ptr->num_rows = (png_ptr->height +
1044 png_pass_yinc[png_ptr->pass] - 1 -
1045 png_pass_ystart[png_ptr->pass]) /
1046 png_pass_yinc[png_ptr->pass];
1047
1048 } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
1049 }
1050 }
1051
1052 #if defined(PNG_READ_tEXt_SUPPORTED)
1053 void /* PRIVATE */
1054 png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1055 length)
1056 {
1057 if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1058 {
1059 png_error(png_ptr, "Out of place tEXt");
1060 info_ptr = info_ptr; /* to quiet some compiler warnings */
1061 }
1062
1063 #ifdef PNG_MAX_MALLOC_64K
1064 png_ptr->skip_length = 0; /* This may not be necessary */
1065
1066 if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
1067 {
1068 png_warning(png_ptr, "tEXt chunk too large to fit in memory");
1069 png_ptr->skip_length = length - (png_uint_32)65535L;
1070 length = (png_uint_32)65535L;
1071 }
1072 #endif
1073
1074 png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1075 (png_uint_32)(length+1));
1076 png_ptr->current_text[length] = '\0';
1077 png_ptr->current_text_ptr = png_ptr->current_text;
1078 png_ptr->current_text_size = (png_size_t)length;
1079 png_ptr->current_text_left = (png_size_t)length;
1080 png_ptr->process_mode = PNG_READ_tEXt_MODE;
1081 }
1082
1083 void /* PRIVATE */
1084 png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
1085 {
1086 if (png_ptr->buffer_size && png_ptr->current_text_left)
1087 {
1088 png_size_t text_size;
1089
1090 if (png_ptr->buffer_size < png_ptr->current_text_left)
1091 text_size = png_ptr->buffer_size;
1092 else
1093 text_size = png_ptr->current_text_left;
1094 png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1095 png_ptr->current_text_left -= text_size;
1096 png_ptr->current_text_ptr += text_size;
1097 }
1098 if (!(png_ptr->current_text_left))
1099 {
1100 png_textp text_ptr;
1101 png_charp text;
1102 png_charp key;
1103 int ret;
1104
1105 if (png_ptr->buffer_size < 4)
1106 {
1107 png_push_save_buffer(png_ptr);
1108 return;
1109 }
1110
1111 png_push_crc_finish(png_ptr);
1112
1113 #if defined(PNG_MAX_MALLOC_64K)
1114 if (png_ptr->skip_length)
1115 return;
1116 #endif
1117
1118 key = png_ptr->current_text;
1119
1120 for (text = key; *text; text++)
1121 /* empty loop */ ;
1122
1123 if (text < key + png_ptr->current_text_size)
1124 text++;
1125
1126 text_ptr = (png_textp)png_malloc(png_ptr,
1127 (png_uint_32)png_sizeof(png_text));
1128 text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
1129 text_ptr->key = key;
1130 #ifdef PNG_iTXt_SUPPORTED
1131 text_ptr->lang = NULL;
1132 text_ptr->lang_key = NULL;
1133 #endif
1134 text_ptr->text = text;
1135
1136 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1137
1138 png_free(png_ptr, key);
1139 png_free(png_ptr, text_ptr);
1140 png_ptr->current_text = NULL;
1141
1142 if (ret)
1143 png_warning(png_ptr, "Insufficient memory to store text chunk.");
1144 }
1145 }
1146 #endif
1147
1148 #if defined(PNG_READ_zTXt_SUPPORTED)
1149 void /* PRIVATE */
1150 png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1151 length)
1152 {
1153 if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1154 {
1155 png_error(png_ptr, "Out of place zTXt");
1156 info_ptr = info_ptr; /* to quiet some compiler warnings */
1157 }
1158
1159 #ifdef PNG_MAX_MALLOC_64K
1160 /* We can't handle zTXt chunks > 64K, since we don't have enough space
1161 * to be able to store the uncompressed data. Actually, the threshold
1162 * is probably around 32K, but it isn't as definite as 64K is.
1163 */
1164 if (length > (png_uint_32)65535L)
1165 {
1166 png_warning(png_ptr, "zTXt chunk too large to fit in memory");
1167 png_push_crc_skip(png_ptr, length);
1168 return;
1169 }
1170 #endif
1171
1172 png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1173 (png_uint_32)(length+1));
1174 png_ptr->current_text[length] = '\0';
1175 png_ptr->current_text_ptr = png_ptr->current_text;
1176 png_ptr->current_text_size = (png_size_t)length;
1177 png_ptr->current_text_left = (png_size_t)length;
1178 png_ptr->process_mode = PNG_READ_zTXt_MODE;
1179 }
1180
1181 void /* PRIVATE */
1182 png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
1183 {
1184 if (png_ptr->buffer_size && png_ptr->current_text_left)
1185 {
1186 png_size_t text_size;
1187
1188 if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
1189 text_size = png_ptr->buffer_size;
1190 else
1191 text_size = png_ptr->current_text_left;
1192 png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1193 png_ptr->current_text_left -= text_size;
1194 png_ptr->current_text_ptr += text_size;
1195 }
1196 if (!(png_ptr->current_text_left))
1197 {
1198 png_textp text_ptr;
1199 png_charp text;
1200 png_charp key;
1201 int ret;
1202 png_size_t text_size, key_size;
1203
1204 if (png_ptr->buffer_size < 4)
1205 {
1206 png_push_save_buffer(png_ptr);
1207 return;
1208 }
1209
1210 png_push_crc_finish(png_ptr);
1211
1212 key = png_ptr->current_text;
1213
1214 for (text = key; *text; text++)
1215 /* empty loop */ ;
1216
1217 /* zTXt can't have zero text */
1218 if (text >= key + png_ptr->current_text_size)
1219 {
1220 png_ptr->current_text = NULL;
1221 png_free(png_ptr, key);
1222 return;
1223 }
1224
1225 text++;
1226
1227 if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */
1228 {
1229 png_ptr->current_text = NULL;
1230 png_free(png_ptr, key);
1231 return;
1232 }
1233
1234 text++;
1235
1236 png_ptr->zstream.next_in = (png_bytep )text;
1237 png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
1238 (text - key));
1239 png_ptr->zstream.next_out = png_ptr->zbuf;
1240 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1241
1242 key_size = text - key;
1243 text_size = 0;
1244 text = NULL;
1245 ret = Z_STREAM_END;
1246
1247 while (png_ptr->zstream.avail_in)
1248 {
1249 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
1250 if (ret != Z_OK && ret != Z_STREAM_END)
1251 {
1252 inflateReset(&png_ptr->zstream);
1253 png_ptr->zstream.avail_in = 0;
1254 png_ptr->current_text = NULL;
1255 png_free(png_ptr, key);
1256 png_free(png_ptr, text);
1257 return;
1258 }
1259 if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
1260 {
1261 if (text == NULL)
1262 {
1263 text = (png_charp)png_malloc(png_ptr,
1264 (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
1265 + key_size + 1));
1266 png_memcpy(text + key_size, png_ptr->zbuf,
1267 png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1268 png_memcpy(text, key, key_size);
1269 text_size = key_size + png_ptr->zbuf_size -
1270 png_ptr->zstream.avail_out;
1271 *(text + text_size) = '\0';
1272 }
1273 else
1274 {
1275 png_charp tmp;
1276
1277 tmp = text;
1278 text = (png_charp)png_malloc(png_ptr, text_size +
1279 (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
1280 + 1));
1281 png_memcpy(text, tmp, text_size);
1282 png_free(png_ptr, tmp);
1283 png_memcpy(text + text_size, png_ptr->zbuf,
1284 png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1285 text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
1286 *(text + text_size) = '\0';
1287 }
1288 if (ret != Z_STREAM_END)
1289 {
1290 png_ptr->zstream.next_out = png_ptr->zbuf;
1291 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1292 }
1293 }
1294 else
1295 {
1296 break;
1297 }
1298
1299 if (ret == Z_STREAM_END)
1300 break;
1301 }
1302
1303 inflateReset(&png_ptr->zstream);
1304 png_ptr->zstream.avail_in = 0;
1305
1306 if (ret != Z_STREAM_END)
1307 {
1308 png_ptr->current_text = NULL;
1309 png_free(png_ptr, key);
1310 png_free(png_ptr, text);
1311 return;
1312 }
1313
1314 png_ptr->current_text = NULL;
1315 png_free(png_ptr, key);
1316 key = text;
1317 text += key_size;
1318
1319 text_ptr = (png_textp)png_malloc(png_ptr,
1320 (png_uint_32)png_sizeof(png_text));
1321 text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
1322 text_ptr->key = key;
1323 #ifdef PNG_iTXt_SUPPORTED
1324 text_ptr->lang = NULL;
1325 text_ptr->lang_key = NULL;
1326 #endif
1327 text_ptr->text = text;
1328
1329 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1330
1331 png_free(png_ptr, key);
1332 png_free(png_ptr, text_ptr);
1333
1334 if (ret)
1335 png_warning(png_ptr, "Insufficient memory to store text chunk.");
1336 }
1337 }
1338 #endif
1339
1340 #if defined(PNG_READ_iTXt_SUPPORTED)
1341 void /* PRIVATE */
1342 png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1343 length)
1344 {
1345 if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
1346 {
1347 png_error(png_ptr, "Out of place iTXt");
1348 info_ptr = info_ptr; /* to quiet some compiler warnings */
1349 }
1350
1351 #ifdef PNG_MAX_MALLOC_64K
1352 png_ptr->skip_length = 0; /* This may not be necessary */
1353
1354 if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
1355 {
1356 png_warning(png_ptr, "iTXt chunk too large to fit in memory");
1357 png_ptr->skip_length = length - (png_uint_32)65535L;
1358 length = (png_uint_32)65535L;
1359 }
1360 #endif
1361
1362 png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1363 (png_uint_32)(length+1));
1364 png_ptr->current_text[length] = '\0';
1365 png_ptr->current_text_ptr = png_ptr->current_text;
1366 png_ptr->current_text_size = (png_size_t)length;
1367 png_ptr->current_text_left = (png_size_t)length;
1368 png_ptr->process_mode = PNG_READ_iTXt_MODE;
1369 }
1370
1371 void /* PRIVATE */
1372 png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
1373 {
1374
1375 if (png_ptr->buffer_size && png_ptr->current_text_left)
1376 {
1377 png_size_t text_size;
1378
1379 if (png_ptr->buffer_size < png_ptr->current_text_left)
1380 text_size = png_ptr->buffer_size;
1381 else
1382 text_size = png_ptr->current_text_left;
1383 png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1384 png_ptr->current_text_left -= text_size;
1385 png_ptr->current_text_ptr += text_size;
1386 }
1387 if (!(png_ptr->current_text_left))
1388 {
1389 png_textp text_ptr;
1390 png_charp key;
1391 int comp_flag;
1392 png_charp lang;
1393 png_charp lang_key;
1394 png_charp text;
1395 int ret;
1396
1397 if (png_ptr->buffer_size < 4)
1398 {
1399 png_push_save_buffer(png_ptr);
1400 return;
1401 }
1402
1403 png_push_crc_finish(png_ptr);
1404
1405 #if defined(PNG_MAX_MALLOC_64K)
1406 if (png_ptr->skip_length)
1407 return;
1408 #endif
1409
1410 key = png_ptr->current_text;
1411
1412 for (lang = key; *lang; lang++)
1413 /* empty loop */ ;
1414
1415 if (lang < key + png_ptr->current_text_size - 3)
1416 lang++;
1417
1418 comp_flag = *lang++;
1419 lang++; /* skip comp_type, always zero */
1420
1421 for (lang_key = lang; *lang_key; lang_key++)
1422 /* empty loop */ ;
1423 lang_key++; /* skip NUL separator */
1424
1425 text=lang_key;
1426 if (lang_key < key + png_ptr->current_text_size - 1)
1427 {
1428 for (; *text; text++)
1429 /* empty loop */ ;
1430 }
1431
1432 if (text < key + png_ptr->current_text_size)
1433 text++;
1434
1435 text_ptr = (png_textp)png_malloc(png_ptr,
1436 (png_uint_32)png_sizeof(png_text));
1437 text_ptr->compression = comp_flag + 2;
1438 text_ptr->key = key;
1439 text_ptr->lang = lang;
1440 text_ptr->lang_key = lang_key;
1441 text_ptr->text = text;
1442 text_ptr->text_length = 0;
1443 text_ptr->itxt_length = png_strlen(text);
1444
1445 ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1446
1447 png_ptr->current_text = NULL;
1448
1449 png_free(png_ptr, text_ptr);
1450 if (ret)
1451 png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");
1452 }
1453 }
1454 #endif
1455
1456 /* This function is called when we haven't found a handler for this
1457 * chunk. If there isn't a problem with the chunk itself (ie a bad chunk
1458 * name or a critical chunk), the chunk is (currently) silently ignored.
1459 */
1460 void /* PRIVATE */
1461 png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
1462 length)
1463 {
1464 png_uint_32 skip=0;
1465 png_check_chunk_name(png_ptr, png_ptr->chunk_name);
1466
1467 if (!(png_ptr->chunk_name[0] & 0x20))
1468 {
1469 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1470 if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1471 PNG_HANDLE_CHUNK_ALWAYS
1472 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1473 && png_ptr->read_user_chunk_fn == NULL
1474 #endif
1475 )
1476 #endif
1477 png_chunk_error(png_ptr, "unknown critical chunk");
1478
1479 info_ptr = info_ptr; /* to quiet some compiler warnings */
1480 }
1481
1482 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1483 if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
1484 {
1485 #ifdef PNG_MAX_MALLOC_64K
1486 if (length > (png_uint_32)65535L)
1487 {
1488 png_warning(png_ptr, "unknown chunk too large to fit in memory");
1489 skip = length - (png_uint_32)65535L;
1490 length = (png_uint_32)65535L;
1491 }
1492 #endif
1493 png_memcpy((png_charp)png_ptr->unknown_chunk.name,
1494 (png_charp)png_ptr->chunk_name,
1495 png_sizeof(png_ptr->unknown_chunk.name));
1496 png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]='\0';
1497
1498 png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
1499 png_ptr->unknown_chunk.size = (png_size_t)length;
1500 png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
1501 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1502 if(png_ptr->read_user_chunk_fn != NULL)
1503 {
1504 /* callback to user unknown chunk handler */
1505 int ret;
1506 ret = (*(png_ptr->read_user_chunk_fn))
1507 (png_ptr, &png_ptr->unknown_chunk);
1508 if (ret < 0)
1509 png_chunk_error(png_ptr, "error in user chunk");
1510 if (ret == 0)
1511 {
1512 if (!(png_ptr->chunk_name[0] & 0x20))
1513 if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1514 PNG_HANDLE_CHUNK_ALWAYS)
1515 png_chunk_error(png_ptr, "unknown critical chunk");
1516 png_set_unknown_chunks(png_ptr, info_ptr,
1517 &png_ptr->unknown_chunk, 1);
1518 }
1519 }
1520 #else
1521 png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
1522 #endif
1523 png_free(png_ptr, png_ptr->unknown_chunk.data);
1524 png_ptr->unknown_chunk.data = NULL;
1525 }
1526 else
1527 #endif
1528 skip=length;
1529 png_push_crc_skip(png_ptr, skip);
1530 }
1531
1532 void /* PRIVATE */
1533 png_push_have_info(png_structp png_ptr, png_infop info_ptr)
1534 {
1535 if (png_ptr->info_fn != NULL)
1536 (*(png_ptr->info_fn))(png_ptr, info_ptr);
1537 }
1538
1539 void /* PRIVATE */
1540 png_push_have_end(png_structp png_ptr, png_infop info_ptr)
1541 {
1542 if (png_ptr->end_fn != NULL)
1543 (*(png_ptr->end_fn))(png_ptr, info_ptr);
1544 }
1545
1546 void /* PRIVATE */
1547 png_push_have_row(png_structp png_ptr, png_bytep row)
1548 {
1549 if (png_ptr->row_fn != NULL)
1550 (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
1551 (int)png_ptr->pass);
1552 }
1553
1554 void PNGAPI
1555 png_progressive_combine_row (png_structp png_ptr,
1556 png_bytep old_row, png_bytep new_row)
1557 {
1558 #ifdef PNG_USE_LOCAL_ARRAYS
1559 PNG_CONST int FARDATA png_pass_dsp_mask[7] =
1560 {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
1561 #endif
1562 if(png_ptr == NULL) return;
1563 if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
1564 png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
1565 }
1566
1567 void PNGAPI
1568 png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
1569 png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
1570 png_progressive_end_ptr end_fn)
1571 {
1572 if(png_ptr == NULL) return;
1573 png_ptr->info_fn = info_fn;
1574 png_ptr->row_fn = row_fn;
1575 png_ptr->end_fn = end_fn;
1576
1577 png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
1578 }
1579
1580 png_voidp PNGAPI
1581 png_get_progressive_ptr(png_structp png_ptr)
1582 {
1583 if(png_ptr == NULL) return (NULL);
1584 return png_ptr->io_ptr;
1585 }
1586 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
A free Windows-compatible Operating System