pngpread.c@ 13371

Last change on this file since 13371 was 6393, checked in by vboxsync, 17 years ago
export libpng and zlib so Windows and OS/2 builds cleanly.
Property svn:eol-style set to `native`
File size: 44.9 KB

Line
1
2	/* pngpread.c - read a png file in push mode
3	*
4	* libpng version 1.2.8 - December 3, 2004
5	* For conditions of distribution and use, see copyright notice in png.h
6	* Copyright (c) 1998-2004 Glenn Randers-Pehrson
7	* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8	* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9	*/
10
11	#define PNG_INTERNAL
12	#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_31(png_ptr,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	png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
225	}
226	else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
227	{
228	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
229	{
230	png_push_save_buffer(png_ptr);
231	return;
232	}
233	png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
234
235	png_ptr->process_mode = PNG_READ_DONE_MODE;
236	png_push_have_end(png_ptr, info_ptr);
237	}
238	#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
239	else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
240	{
241	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
242	{
243	png_push_save_buffer(png_ptr);
244	return;
245	}
246	if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
247	png_ptr->mode \|= PNG_HAVE_IDAT;
248	png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
249	if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
250	png_ptr->mode \|= PNG_HAVE_PLTE;
251	else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
252	{
253	if (!(png_ptr->mode & PNG_HAVE_IHDR))
254	png_error(png_ptr, "Missing IHDR before IDAT");
255	else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
256	!(png_ptr->mode & PNG_HAVE_PLTE))
257	png_error(png_ptr, "Missing PLTE before IDAT");
258	}
259	}
260	#endif
261	else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
262	{
263	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
264	{
265	png_push_save_buffer(png_ptr);
266	return;
267	}
268	png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
269	}
270	else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))
271	{
272	/* If we reach an IDAT chunk, this means we have read all of the
273	* header chunks, and we can start reading the image (or if this
274	* is called after the image has been read - we have an error).
275	*/
276	if (!(png_ptr->mode & PNG_HAVE_IHDR))
277	png_error(png_ptr, "Missing IHDR before IDAT");
278	else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
279	!(png_ptr->mode & PNG_HAVE_PLTE))
280	png_error(png_ptr, "Missing PLTE before IDAT");
281
282	if (png_ptr->mode & PNG_HAVE_IDAT)
283	{
284	if (png_ptr->push_length == 0)
285	return;
286
287	if (png_ptr->mode & PNG_AFTER_IDAT)
288	png_error(png_ptr, "Too many IDAT's found");
289	}
290
291	png_ptr->idat_size = png_ptr->push_length;
292	png_ptr->mode \|= PNG_HAVE_IDAT;
293	png_ptr->process_mode = PNG_READ_IDAT_MODE;
294	png_push_have_info(png_ptr, info_ptr);
295	png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
296	png_ptr->zstream.next_out = png_ptr->row_buf;
297	return;
298	}
299	#if defined(PNG_READ_gAMA_SUPPORTED)
300	else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
301	{
302	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
303	{
304	png_push_save_buffer(png_ptr);
305	return;
306	}
307	png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
308	}
309	#endif
310	#if defined(PNG_READ_sBIT_SUPPORTED)
311	else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
312	{
313	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
314	{
315	png_push_save_buffer(png_ptr);
316	return;
317	}
318	png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
319	}
320	#endif
321	#if defined(PNG_READ_cHRM_SUPPORTED)
322	else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
323	{
324	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
325	{
326	png_push_save_buffer(png_ptr);
327	return;
328	}
329	png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
330	}
331	#endif
332	#if defined(PNG_READ_sRGB_SUPPORTED)
333	else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 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	png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
341	}
342	#endif
343	#if defined(PNG_READ_iCCP_SUPPORTED)
344	else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
345	{
346	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
347	{
348	png_push_save_buffer(png_ptr);
349	return;
350	}
351	png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
352	}
353	#endif
354	#if defined(PNG_READ_sPLT_SUPPORTED)
355	else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
356	{
357	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
358	{
359	png_push_save_buffer(png_ptr);
360	return;
361	}
362	png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
363	}
364	#endif
365	#if defined(PNG_READ_tRNS_SUPPORTED)
366	else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
367	{
368	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
369	{
370	png_push_save_buffer(png_ptr);
371	return;
372	}
373	png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
374	}
375	#endif
376	#if defined(PNG_READ_bKGD_SUPPORTED)
377	else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
378	{
379	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
380	{
381	png_push_save_buffer(png_ptr);
382	return;
383	}
384	png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
385	}
386	#endif
387	#if defined(PNG_READ_hIST_SUPPORTED)
388	else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
389	{
390	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
391	{
392	png_push_save_buffer(png_ptr);
393	return;
394	}
395	png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
396	}
397	#endif
398	#if defined(PNG_READ_pHYs_SUPPORTED)
399	else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
400	{
401	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
402	{
403	png_push_save_buffer(png_ptr);
404	return;
405	}
406	png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
407	}
408	#endif
409	#if defined(PNG_READ_oFFs_SUPPORTED)
410	else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
411	{
412	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
413	{
414	png_push_save_buffer(png_ptr);
415	return;
416	}
417	png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
418	}
419	#endif
420	#if defined(PNG_READ_pCAL_SUPPORTED)
421	else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
422	{
423	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
424	{
425	png_push_save_buffer(png_ptr);
426	return;
427	}
428	png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
429	}
430	#endif
431	#if defined(PNG_READ_sCAL_SUPPORTED)
432	else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
433	{
434	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
435	{
436	png_push_save_buffer(png_ptr);
437	return;
438	}
439	png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
440	}
441	#endif
442	#if defined(PNG_READ_tIME_SUPPORTED)
443	else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
444	{
445	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
446	{
447	png_push_save_buffer(png_ptr);
448	return;
449	}
450	png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
451	}
452	#endif
453	#if defined(PNG_READ_tEXt_SUPPORTED)
454	else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
455	{
456	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
457	{
458	png_push_save_buffer(png_ptr);
459	return;
460	}
461	png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
462	}
463	#endif
464	#if defined(PNG_READ_zTXt_SUPPORTED)
465	else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
466	{
467	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
468	{
469	png_push_save_buffer(png_ptr);
470	return;
471	}
472	png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
473	}
474	#endif
475	#if defined(PNG_READ_iTXt_SUPPORTED)
476	else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
477	{
478	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
479	{
480	png_push_save_buffer(png_ptr);
481	return;
482	}
483	png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
484	}
485	#endif
486	else
487	{
488	if (png_ptr->push_length + 4 > png_ptr->buffer_size)
489	{
490	png_push_save_buffer(png_ptr);
491	return;
492	}
493	png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
494	}
495
496	png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
497	}
498
499	void /* PRIVATE */
500	png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
501	{
502	png_ptr->process_mode = PNG_SKIP_MODE;
503	png_ptr->skip_length = skip;
504	}
505
506	void /* PRIVATE */
507	png_push_crc_finish(png_structp png_ptr)
508	{
509	if (png_ptr->skip_length && png_ptr->save_buffer_size)
510	{
511	png_size_t save_size;
512
513	if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
514	save_size = (png_size_t)png_ptr->skip_length;
515	else
516	save_size = png_ptr->save_buffer_size;
517
518	png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
519
520	png_ptr->skip_length -= save_size;
521	png_ptr->buffer_size -= save_size;
522	png_ptr->save_buffer_size -= save_size;
523	png_ptr->save_buffer_ptr += save_size;
524	}
525	if (png_ptr->skip_length && png_ptr->current_buffer_size)
526	{
527	png_size_t save_size;
528
529	if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
530	save_size = (png_size_t)png_ptr->skip_length;
531	else
532	save_size = png_ptr->current_buffer_size;
533
534	png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
535
536	png_ptr->skip_length -= save_size;
537	png_ptr->buffer_size -= save_size;
538	png_ptr->current_buffer_size -= save_size;
539	png_ptr->current_buffer_ptr += save_size;
540	}
541	if (!png_ptr->skip_length)
542	{
543	if (png_ptr->buffer_size < 4)
544	{
545	png_push_save_buffer(png_ptr);
546	return;
547	}
548
549	png_crc_finish(png_ptr, 0);
550	png_ptr->process_mode = PNG_READ_CHUNK_MODE;
551	}
552	}
553
554	void PNGAPI
555	png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
556	{
557	png_bytep ptr;
558
559	ptr = buffer;
560	if (png_ptr->save_buffer_size)
561	{
562	png_size_t save_size;
563
564	if (length < png_ptr->save_buffer_size)
565	save_size = length;
566	else
567	save_size = png_ptr->save_buffer_size;
568
569	png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
570	length -= save_size;
571	ptr += save_size;
572	png_ptr->buffer_size -= save_size;
573	png_ptr->save_buffer_size -= save_size;
574	png_ptr->save_buffer_ptr += save_size;
575	}
576	if (length && png_ptr->current_buffer_size)
577	{
578	png_size_t save_size;
579
580	if (length < png_ptr->current_buffer_size)
581	save_size = length;
582	else
583	save_size = png_ptr->current_buffer_size;
584
585	png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
586	png_ptr->buffer_size -= save_size;
587	png_ptr->current_buffer_size -= save_size;
588	png_ptr->current_buffer_ptr += save_size;
589	}
590	}
591
592	void /* PRIVATE */
593	png_push_save_buffer(png_structp png_ptr)
594	{
595	if (png_ptr->save_buffer_size)
596	{
597	if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
598	{
599	png_size_t i,istop;
600	png_bytep sp;
601	png_bytep dp;
602
603	istop = png_ptr->save_buffer_size;
604	for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
605	i < istop; i++, sp++, dp++)
606	{
607	dp = sp;
608	}
609	}
610	}
611	if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
612	png_ptr->save_buffer_max)
613	{
614	png_size_t new_max;
615	png_bytep old_buffer;
616
617	if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
618	(png_ptr->current_buffer_size + 256))
619	{
620	png_error(png_ptr, "Potential overflow of save_buffer");
621	}
622	new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
623	old_buffer = png_ptr->save_buffer;
624	png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
625	(png_uint_32)new_max);
626	png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
627	png_free(png_ptr, old_buffer);
628	png_ptr->save_buffer_max = new_max;
629	}
630	if (png_ptr->current_buffer_size)
631	{
632	png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
633	png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
634	png_ptr->save_buffer_size += png_ptr->current_buffer_size;
635	png_ptr->current_buffer_size = 0;
636	}
637	png_ptr->save_buffer_ptr = png_ptr->save_buffer;
638	png_ptr->buffer_size = 0;
639	}
640
641	void /* PRIVATE */
642	png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
643	png_size_t buffer_length)
644	{
645	png_ptr->current_buffer = buffer;
646	png_ptr->current_buffer_size = buffer_length;
647	png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
648	png_ptr->current_buffer_ptr = png_ptr->current_buffer;
649	}
650
651	void /* PRIVATE */
652	png_push_read_IDAT(png_structp png_ptr)
653	{
654	#ifdef PNG_USE_LOCAL_ARRAYS
655	PNG_IDAT;
656	#endif
657	if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
658	{
659	png_byte chunk_length[4];
660
661	if (png_ptr->buffer_size < 8)
662	{
663	png_push_save_buffer(png_ptr);
664	return;
665	}
666
667	png_push_fill_buffer(png_ptr, chunk_length, 4);
668	png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length);
669	png_reset_crc(png_ptr);
670	png_crc_read(png_ptr, png_ptr->chunk_name, 4);
671	png_ptr->mode \|= PNG_HAVE_CHUNK_HEADER;
672
673	if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))
674	{
675	png_ptr->process_mode = PNG_READ_CHUNK_MODE;
676	if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
677	png_error(png_ptr, "Not enough compressed data");
678	return;
679	}
680
681	png_ptr->idat_size = png_ptr->push_length;
682	}
683	if (png_ptr->idat_size && png_ptr->save_buffer_size)
684	{
685	png_size_t save_size;
686
687	if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
688	{
689	save_size = (png_size_t)png_ptr->idat_size;
690	/* check for overflow */
691	if((png_uint_32)save_size != png_ptr->idat_size)
692	png_error(png_ptr, "save_size overflowed in pngpread");
693	}
694	else
695	save_size = png_ptr->save_buffer_size;
696
697	png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
698	if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
699	png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
700	png_ptr->idat_size -= save_size;
701	png_ptr->buffer_size -= save_size;
702	png_ptr->save_buffer_size -= save_size;
703	png_ptr->save_buffer_ptr += save_size;
704	}
705	if (png_ptr->idat_size && png_ptr->current_buffer_size)
706	{
707	png_size_t save_size;
708
709	if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
710	{
711	save_size = (png_size_t)png_ptr->idat_size;
712	/* check for overflow */
713	if((png_uint_32)save_size != png_ptr->idat_size)
714	png_error(png_ptr, "save_size overflowed in pngpread");
715	}
716	else
717	save_size = png_ptr->current_buffer_size;
718
719	png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
720	if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
721	png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
722
723	png_ptr->idat_size -= save_size;
724	png_ptr->buffer_size -= save_size;
725	png_ptr->current_buffer_size -= save_size;
726	png_ptr->current_buffer_ptr += save_size;
727	}
728	if (!png_ptr->idat_size)
729	{
730	if (png_ptr->buffer_size < 4)
731	{
732	png_push_save_buffer(png_ptr);
733	return;
734	}
735
736	png_crc_finish(png_ptr, 0);
737	png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
738	png_ptr->mode \|= PNG_AFTER_IDAT;
739	}
740	}
741
742	void /* PRIVATE */
743	png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
744	png_size_t buffer_length)
745	{
746	int ret;
747
748	if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)
749	png_error(png_ptr, "Extra compression data");
750
751	png_ptr->zstream.next_in = buffer;
752	png_ptr->zstream.avail_in = (uInt)buffer_length;
753	for(;;)
754	{
755	ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
756	if (ret != Z_OK)
757	{
758	if (ret == Z_STREAM_END)
759	{
760	if (png_ptr->zstream.avail_in)
761	png_error(png_ptr, "Extra compressed data");
762	if (!(png_ptr->zstream.avail_out))
763	{
764	png_push_process_row(png_ptr);
765	}
766
767	png_ptr->mode \|= PNG_AFTER_IDAT;
768	png_ptr->flags \|= PNG_FLAG_ZLIB_FINISHED;
769	break;
770	}
771	else if (ret == Z_BUF_ERROR)
772	break;
773	else
774	png_error(png_ptr, "Decompression Error");
775	}
776	if (!(png_ptr->zstream.avail_out))
777	{
778	if ((
779	#if defined(PNG_READ_INTERLACING_SUPPORTED)
780	png_ptr->interlaced && png_ptr->pass > 6) \|\|
781	(!png_ptr->interlaced &&
782	#endif
783	png_ptr->row_number == png_ptr->num_rows))
784	{
785	if (png_ptr->zstream.avail_in)
786	png_warning(png_ptr, "Too much data in IDAT chunks");
787	png_ptr->flags \|= PNG_FLAG_ZLIB_FINISHED;
788	break;
789	}
790	png_push_process_row(png_ptr);
791	png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
792	png_ptr->zstream.next_out = png_ptr->row_buf;
793	}
794	else
795	break;
796	}
797	}
798
799	void /* PRIVATE */
800	png_push_process_row(png_structp png_ptr)
801	{
802	png_ptr->row_info.color_type = png_ptr->color_type;
803	png_ptr->row_info.width = png_ptr->iwidth;
804	png_ptr->row_info.channels = png_ptr->channels;
805	png_ptr->row_info.bit_depth = png_ptr->bit_depth;
806	png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
807
808	png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
809	png_ptr->row_info.width);
810
811	png_read_filter_row(png_ptr, &(png_ptr->row_info),
812	png_ptr->row_buf + 1, png_ptr->prev_row + 1,
813	(int)(png_ptr->row_buf[0]));
814
815	png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
816	png_ptr->rowbytes + 1);
817
818	if (png_ptr->transformations \|\| (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
819	png_do_read_transformations(png_ptr);
820
821	#if defined(PNG_READ_INTERLACING_SUPPORTED)
822	/* blow up interlaced rows to full size */
823	if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
824	{
825	if (png_ptr->pass < 6)
826	/* old interface (pre-1.0.9):
827	png_do_read_interlace(&(png_ptr->row_info),
828	png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
829	*/
830	png_do_read_interlace(png_ptr);
831
832	switch (png_ptr->pass)
833	{
834	case 0:
835	{
836	int i;
837	for (i = 0; i < 8 && png_ptr->pass == 0; i++)
838	{
839	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
840	png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */
841	}
842	if (png_ptr->pass == 2) /* pass 1 might be empty */
843	{
844	for (i = 0; i < 4 && png_ptr->pass == 2; i++)
845	{
846	png_push_have_row(png_ptr, png_bytep_NULL);
847	png_read_push_finish_row(png_ptr);
848	}
849	}
850	if (png_ptr->pass == 4 && png_ptr->height <= 4)
851	{
852	for (i = 0; i < 2 && png_ptr->pass == 4; 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 == 6 && png_ptr->height <= 4)
859	{
860	png_push_have_row(png_ptr, png_bytep_NULL);
861	png_read_push_finish_row(png_ptr);
862	}
863	break;
864	}
865	case 1:
866	{
867	int i;
868	for (i = 0; i < 8 && png_ptr->pass == 1; i++)
869	{
870	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
871	png_read_push_finish_row(png_ptr);
872	}
873	if (png_ptr->pass == 2) /* skip top 4 generated rows */
874	{
875	for (i = 0; i < 4 && png_ptr->pass == 2; i++)
876	{
877	png_push_have_row(png_ptr, png_bytep_NULL);
878	png_read_push_finish_row(png_ptr);
879	}
880	}
881	break;
882	}
883	case 2:
884	{
885	int i;
886	for (i = 0; i < 4 && png_ptr->pass == 2; i++)
887	{
888	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
889	png_read_push_finish_row(png_ptr);
890	}
891	for (i = 0; i < 4 && png_ptr->pass == 2; i++)
892	{
893	png_push_have_row(png_ptr, png_bytep_NULL);
894	png_read_push_finish_row(png_ptr);
895	}
896	if (png_ptr->pass == 4) /* pass 3 might be empty */
897	{
898	for (i = 0; i < 2 && png_ptr->pass == 4; i++)
899	{
900	png_push_have_row(png_ptr, png_bytep_NULL);
901	png_read_push_finish_row(png_ptr);
902	}
903	}
904	break;
905	}
906	case 3:
907	{
908	int i;
909	for (i = 0; i < 4 && png_ptr->pass == 3; i++)
910	{
911	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
912	png_read_push_finish_row(png_ptr);
913	}
914	if (png_ptr->pass == 4) /* skip top two generated rows */
915	{
916	for (i = 0; i < 2 && png_ptr->pass == 4; i++)
917	{
918	png_push_have_row(png_ptr, png_bytep_NULL);
919	png_read_push_finish_row(png_ptr);
920	}
921	}
922	break;
923	}
924	case 4:
925	{
926	int i;
927	for (i = 0; i < 2 && png_ptr->pass == 4; i++)
928	{
929	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
930	png_read_push_finish_row(png_ptr);
931	}
932	for (i = 0; i < 2 && png_ptr->pass == 4; i++)
933	{
934	png_push_have_row(png_ptr, png_bytep_NULL);
935	png_read_push_finish_row(png_ptr);
936	}
937	if (png_ptr->pass == 6) /* pass 5 might be empty */
938	{
939	png_push_have_row(png_ptr, png_bytep_NULL);
940	png_read_push_finish_row(png_ptr);
941	}
942	break;
943	}
944	case 5:
945	{
946	int i;
947	for (i = 0; i < 2 && png_ptr->pass == 5; i++)
948	{
949	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
950	png_read_push_finish_row(png_ptr);
951	}
952	if (png_ptr->pass == 6) /* skip top generated row */
953	{
954	png_push_have_row(png_ptr, png_bytep_NULL);
955	png_read_push_finish_row(png_ptr);
956	}
957	break;
958	}
959	case 6:
960	{
961	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
962	png_read_push_finish_row(png_ptr);
963	if (png_ptr->pass != 6)
964	break;
965	png_push_have_row(png_ptr, png_bytep_NULL);
966	png_read_push_finish_row(png_ptr);
967	}
968	}
969	}
970	else
971	#endif
972	{
973	png_push_have_row(png_ptr, png_ptr->row_buf + 1);
974	png_read_push_finish_row(png_ptr);
975	}
976	}
977
978	void /* PRIVATE */
979	png_read_push_finish_row(png_structp png_ptr)
980	{
981	#ifdef PNG_USE_LOCAL_ARRAYS
982	/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
983
984	/* start of interlace block */
985	const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
986
987	/* offset to next interlace block */
988	const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
989
990	/* start of interlace block in the y direction */
991	const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
992
993	/* offset to next interlace block in the y direction */
994	const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
995
996	/* Width of interlace block. This is not currently used - if you need
997	* it, uncomment it here and in png.h
998	const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
999	*/
1000
1001	/* Height of interlace block. This is not currently used - if you need
1002	* it, uncomment it here and in png.h
1003	const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
1004	*/
1005	#endif
1006
1007	png_ptr->row_number++;
1008	if (png_ptr->row_number < png_ptr->num_rows)
1009	return;
1010
1011	if (png_ptr->interlaced)
1012	{
1013	png_ptr->row_number = 0;
1014	png_memset_check(png_ptr, png_ptr->prev_row, 0,
1015	png_ptr->rowbytes + 1);
1016	do
1017	{
1018	png_ptr->pass++;
1019	if ((png_ptr->pass == 1 && png_ptr->width < 5) \|\|
1020	(png_ptr->pass == 3 && png_ptr->width < 3) \|\|
1021	(png_ptr->pass == 5 && png_ptr->width < 2))
1022	png_ptr->pass++;
1023
1024	if (png_ptr->pass > 7)
1025	png_ptr->pass--;
1026	if (png_ptr->pass >= 7)
1027	break;
1028
1029	png_ptr->iwidth = (png_ptr->width +
1030	png_pass_inc[png_ptr->pass] - 1 -
1031	png_pass_start[png_ptr->pass]) /
1032	png_pass_inc[png_ptr->pass];
1033
1034	png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
1035	png_ptr->iwidth) + 1;
1036
1037	if (png_ptr->transformations & PNG_INTERLACE)
1038	break;
1039
1040	png_ptr->num_rows = (png_ptr->height +
1041	png_pass_yinc[png_ptr->pass] - 1 -
1042	png_pass_ystart[png_ptr->pass]) /
1043	png_pass_yinc[png_ptr->pass];
1044
1045	} while (png_ptr->iwidth == 0 \|\| png_ptr->num_rows == 0);
1046	}
1047	}
1048
1049	#if defined(PNG_READ_tEXt_SUPPORTED)
1050	void /* PRIVATE */
1051	png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1052	length)
1053	{
1054	if (!(png_ptr->mode & PNG_HAVE_IHDR) \|\| (png_ptr->mode & PNG_HAVE_IEND))
1055	{
1056	png_error(png_ptr, "Out of place tEXt");
1057	/* to quiet some compiler warnings */
1058	if(info_ptr == NULL) return;
1059	}
1060
1061	#ifdef PNG_MAX_MALLOC_64K
1062	png_ptr->skip_length = 0; /* This may not be necessary */
1063
1064	if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
1065	{
1066	png_warning(png_ptr, "tEXt chunk too large to fit in memory");
1067	png_ptr->skip_length = length - (png_uint_32)65535L;
1068	length = (png_uint_32)65535L;
1069	}
1070	#endif
1071
1072	png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1073	(png_uint_32)(length+1));
1074	png_ptr->current_text[length] = '\0';
1075	png_ptr->current_text_ptr = png_ptr->current_text;
1076	png_ptr->current_text_size = (png_size_t)length;
1077	png_ptr->current_text_left = (png_size_t)length;
1078	png_ptr->process_mode = PNG_READ_tEXt_MODE;
1079	}
1080
1081	void /* PRIVATE */
1082	png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
1083	{
1084	if (png_ptr->buffer_size && png_ptr->current_text_left)
1085	{
1086	png_size_t text_size;
1087
1088	if (png_ptr->buffer_size < png_ptr->current_text_left)
1089	text_size = png_ptr->buffer_size;
1090	else
1091	text_size = png_ptr->current_text_left;
1092	png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1093	png_ptr->current_text_left -= text_size;
1094	png_ptr->current_text_ptr += text_size;
1095	}
1096	if (!(png_ptr->current_text_left))
1097	{
1098	png_textp text_ptr;
1099	png_charp text;
1100	png_charp key;
1101	int ret;
1102
1103	if (png_ptr->buffer_size < 4)
1104	{
1105	png_push_save_buffer(png_ptr);
1106	return;
1107	}
1108
1109	png_push_crc_finish(png_ptr);
1110
1111	#if defined(PNG_MAX_MALLOC_64K)
1112	if (png_ptr->skip_length)
1113	return;
1114	#endif
1115
1116	key = png_ptr->current_text;
1117
1118	for (text = key; *text; text++)
1119	/* empty loop */ ;
1120
1121	if (text != key + png_ptr->current_text_size)
1122	text++;
1123
1124	text_ptr = (png_textp)png_malloc(png_ptr,
1125	(png_uint_32)png_sizeof(png_text));
1126	text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
1127	text_ptr->key = key;
1128	#ifdef PNG_iTXt_SUPPORTED
1129	text_ptr->lang = NULL;
1130	text_ptr->lang_key = NULL;
1131	#endif
1132	text_ptr->text = text;
1133
1134	ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1135
1136	png_free(png_ptr, key);
1137	png_free(png_ptr, text_ptr);
1138	png_ptr->current_text = NULL;
1139
1140	if (ret)
1141	png_warning(png_ptr, "Insufficient memory to store text chunk.");
1142	}
1143	}
1144	#endif
1145
1146	#if defined(PNG_READ_zTXt_SUPPORTED)
1147	void /* PRIVATE */
1148	png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1149	length)
1150	{
1151	if (!(png_ptr->mode & PNG_HAVE_IHDR) \|\| (png_ptr->mode & PNG_HAVE_IEND))
1152	{
1153	png_error(png_ptr, "Out of place zTXt");
1154	/* to quiet some compiler warnings */
1155	if(info_ptr == NULL) return;
1156	}
1157
1158	#ifdef PNG_MAX_MALLOC_64K
1159	/* We can't handle zTXt chunks > 64K, since we don't have enough space
1160	* to be able to store the uncompressed data. Actually, the threshold
1161	* is probably around 32K, but it isn't as definite as 64K is.
1162	*/
1163	if (length > (png_uint_32)65535L)
1164	{
1165	png_warning(png_ptr, "zTXt chunk too large to fit in memory");
1166	png_push_crc_skip(png_ptr, length);
1167	return;
1168	}
1169	#endif
1170
1171	png_ptr->current_text = (png_charp)png_malloc(png_ptr,
1172	(png_uint_32)(length+1));
1173	png_ptr->current_text[length] = '\0';
1174	png_ptr->current_text_ptr = png_ptr->current_text;
1175	png_ptr->current_text_size = (png_size_t)length;
1176	png_ptr->current_text_left = (png_size_t)length;
1177	png_ptr->process_mode = PNG_READ_zTXt_MODE;
1178	}
1179
1180	void /* PRIVATE */
1181	png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
1182	{
1183	if (png_ptr->buffer_size && png_ptr->current_text_left)
1184	{
1185	png_size_t text_size;
1186
1187	if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
1188	text_size = png_ptr->buffer_size;
1189	else
1190	text_size = png_ptr->current_text_left;
1191	png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
1192	png_ptr->current_text_left -= text_size;
1193	png_ptr->current_text_ptr += text_size;
1194	}
1195	if (!(png_ptr->current_text_left))
1196	{
1197	png_textp text_ptr;
1198	png_charp text;
1199	png_charp key;
1200	int ret;
1201	png_size_t text_size, key_size;
1202
1203	if (png_ptr->buffer_size < 4)
1204	{
1205	png_push_save_buffer(png_ptr);
1206	return;
1207	}
1208
1209	png_push_crc_finish(png_ptr);
1210
1211	key = png_ptr->current_text;
1212
1213	for (text = key; *text; text++)
1214	/* empty loop */ ;
1215
1216	/* zTXt can't have zero text */
1217	if (text == key + png_ptr->current_text_size)
1218	{
1219	png_ptr->current_text = NULL;
1220	png_free(png_ptr, key);
1221	return;
1222	}
1223
1224	text++;
1225
1226	if (text != PNG_TEXT_COMPRESSION_zTXt) / check compression byte */
1227	{
1228	png_ptr->current_text = NULL;
1229	png_free(png_ptr, key);
1230	return;
1231	}
1232
1233	text++;
1234
1235	png_ptr->zstream.next_in = (png_bytep )text;
1236	png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
1237	(text - key));
1238	png_ptr->zstream.next_out = png_ptr->zbuf;
1239	png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1240
1241	key_size = text - key;
1242	text_size = 0;
1243	text = NULL;
1244	ret = Z_STREAM_END;
1245
1246	while (png_ptr->zstream.avail_in)
1247	{
1248	ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
1249	if (ret != Z_OK && ret != Z_STREAM_END)
1250	{
1251	inflateReset(&png_ptr->zstream);
1252	png_ptr->zstream.avail_in = 0;
1253	png_ptr->current_text = NULL;
1254	png_free(png_ptr, key);
1255	png_free(png_ptr, text);
1256	return;
1257	}
1258	if (!(png_ptr->zstream.avail_out) \|\| ret == Z_STREAM_END)
1259	{
1260	if (text == NULL)
1261	{
1262	text = (png_charp)png_malloc(png_ptr,
1263	(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
1264	+ key_size + 1));
1265	png_memcpy(text + key_size, png_ptr->zbuf,
1266	png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1267	png_memcpy(text, key, key_size);
1268	text_size = key_size + png_ptr->zbuf_size -
1269	png_ptr->zstream.avail_out;
1270	*(text + text_size) = '\0';
1271	}
1272	else
1273	{
1274	png_charp tmp;
1275
1276	tmp = text;
1277	text = (png_charp)png_malloc(png_ptr, text_size +
1278	(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
1279	+ 1));
1280	png_memcpy(text, tmp, text_size);
1281	png_free(png_ptr, tmp);
1282	png_memcpy(text + text_size, png_ptr->zbuf,
1283	png_ptr->zbuf_size - png_ptr->zstream.avail_out);
1284	text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
1285	*(text + text_size) = '\0';
1286	}
1287	if (ret != Z_STREAM_END)
1288	{
1289	png_ptr->zstream.next_out = png_ptr->zbuf;
1290	png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1291	}
1292	}
1293	else
1294	{
1295	break;
1296	}
1297
1298	if (ret == Z_STREAM_END)
1299	break;
1300	}
1301
1302	inflateReset(&png_ptr->zstream);
1303	png_ptr->zstream.avail_in = 0;
1304
1305	if (ret != Z_STREAM_END)
1306	{
1307	png_ptr->current_text = NULL;
1308	png_free(png_ptr, key);
1309	png_free(png_ptr, text);
1310	return;
1311	}
1312
1313	png_ptr->current_text = NULL;
1314	png_free(png_ptr, key);
1315	key = text;
1316	text += key_size;
1317
1318	text_ptr = (png_textp)png_malloc(png_ptr,
1319	(png_uint_32)png_sizeof(png_text));
1320	text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
1321	text_ptr->key = key;
1322	#ifdef PNG_iTXt_SUPPORTED
1323	text_ptr->lang = NULL;
1324	text_ptr->lang_key = NULL;
1325	#endif
1326	text_ptr->text = text;
1327
1328	ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1329
1330	png_free(png_ptr, key);
1331	png_free(png_ptr, text_ptr);
1332
1333	if (ret)
1334	png_warning(png_ptr, "Insufficient memory to store text chunk.");
1335	}
1336	}
1337	#endif
1338
1339	#if defined(PNG_READ_iTXt_SUPPORTED)
1340	void /* PRIVATE */
1341	png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
1342	length)
1343	{
1344	if (!(png_ptr->mode & PNG_HAVE_IHDR) \|\| (png_ptr->mode & PNG_HAVE_IEND))
1345	{
1346	png_error(png_ptr, "Out of place iTXt");
1347	/* to quiet some compiler warnings */
1348	if(info_ptr == NULL) return;
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)
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	for (text = lang_key; *text; text++)
1426	/* empty loop */ ;
1427
1428	if (text != key + png_ptr->current_text_size)
1429	text++;
1430
1431	text_ptr = (png_textp)png_malloc(png_ptr,
1432	(png_uint_32)png_sizeof(png_text));
1433	text_ptr->compression = comp_flag + 2;
1434	text_ptr->key = key;
1435	text_ptr->lang = lang;
1436	text_ptr->lang_key = lang_key;
1437	text_ptr->text = text;
1438	text_ptr->text_length = 0;
1439	text_ptr->itxt_length = png_strlen(text);
1440
1441	ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
1442
1443	png_ptr->current_text = NULL;
1444
1445	png_free(png_ptr, text_ptr);
1446	if (ret)
1447	png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");
1448	}
1449	}
1450	#endif
1451
1452	/* This function is called when we haven't found a handler for this
1453	* chunk. If there isn't a problem with the chunk itself (ie a bad chunk
1454	* name or a critical chunk), the chunk is (currently) silently ignored.
1455	*/
1456	void /* PRIVATE */
1457	png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
1458	length)
1459	{
1460	png_uint_32 skip=0;
1461	png_check_chunk_name(png_ptr, png_ptr->chunk_name);
1462
1463	if (!(png_ptr->chunk_name[0] & 0x20))
1464	{
1465	#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1466	if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1467	PNG_HANDLE_CHUNK_ALWAYS
1468	#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1469	&& png_ptr->read_user_chunk_fn == NULL
1470	#endif
1471	)
1472	#endif
1473	png_chunk_error(png_ptr, "unknown critical chunk");
1474
1475	/* to quiet compiler warnings about unused info_ptr */
1476	if (info_ptr == NULL)
1477	return;
1478	}
1479
1480	#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
1481	if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
1482	{
1483	png_unknown_chunk chunk;
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
1494	png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);
1495	chunk.data = (png_bytep)png_malloc(png_ptr, length);
1496	png_crc_read(png_ptr, chunk.data, length);
1497	chunk.size = length;
1498	#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1499	if(png_ptr->read_user_chunk_fn != NULL)
1500	{
1501	/* callback to user unknown chunk handler */
1502	if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0)
1503	{
1504	if (!(png_ptr->chunk_name[0] & 0x20))
1505	if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
1506	PNG_HANDLE_CHUNK_ALWAYS)
1507	png_chunk_error(png_ptr, "unknown critical chunk");
1508	}
1509	png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
1510	}
1511	else
1512	#endif
1513	png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);
1514	png_free(png_ptr, chunk.data);
1515	}
1516	else
1517	#endif
1518	skip=length;
1519	png_push_crc_skip(png_ptr, skip);
1520	}
1521
1522	void /* PRIVATE */
1523	png_push_have_info(png_structp png_ptr, png_infop info_ptr)
1524	{
1525	if (png_ptr->info_fn != NULL)
1526	(*(png_ptr->info_fn))(png_ptr, info_ptr);
1527	}
1528
1529	void /* PRIVATE */
1530	png_push_have_end(png_structp png_ptr, png_infop info_ptr)
1531	{
1532	if (png_ptr->end_fn != NULL)
1533	(*(png_ptr->end_fn))(png_ptr, info_ptr);
1534	}
1535
1536	void /* PRIVATE */
1537	png_push_have_row(png_structp png_ptr, png_bytep row)
1538	{
1539	if (png_ptr->row_fn != NULL)
1540	(*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
1541	(int)png_ptr->pass);
1542	}
1543
1544	void PNGAPI
1545	png_progressive_combine_row (png_structp png_ptr,
1546	png_bytep old_row, png_bytep new_row)
1547	{
1548	#ifdef PNG_USE_LOCAL_ARRAYS
1549	const int FARDATA png_pass_dsp_mask[7] =
1550	{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
1551	#endif
1552	if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
1553	png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
1554	}
1555
1556	void PNGAPI
1557	png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
1558	png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
1559	png_progressive_end_ptr end_fn)
1560	{
1561	png_ptr->info_fn = info_fn;
1562	png_ptr->row_fn = row_fn;
1563	png_ptr->end_fn = end_fn;
1564
1565	png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
1566	}
1567
1568	png_voidp PNGAPI
1569	png_get_progressive_ptr(png_structp png_ptr)
1570	{
1571	return png_ptr->io_ptr;
1572	}
1573	#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libpng-1.2.8/pngpread.c@ 13371

Download in other formats: