Context Navigation

source: rtems-graphics-toolkit/fltk-1.1.10/png/png.c @ 513eea1

Last change on this file since 513eea1 was 513eea1, checked in by Joel Sherrill <joel.sherrill@…>, on 01/09/10 at 22:43:24

2010-01-08 Joel Sherrill <joel.sherrill@…>

fltk 1.1.10. imported

ORIGIN: Updated.

Property mode set to 100644

File size: 26.1 KB

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

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

Download in other formats: