pngset.c@ 35199

Last change on this file since 35199 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: 37.7 KB

Line
1
2	/* pngset.c - storage of image information into info struct
3	*
4	* libpng 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	* The functions here are used during reads to store data from the file
11	* into the info struct, and during writes to store application data
12	* into the info struct for writing into the file. This abstracts the
13	* info struct and allows us to change the structure in the future.
14	*/
15
16	#define PNG_INTERNAL
17	#include "png.h"
18
19	#if defined(PNG_bKGD_SUPPORTED)
20	void PNGAPI
21	png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
22	{
23	png_debug1(1, "in %s storage function\n", "bKGD");
24	if (png_ptr == NULL \|\| info_ptr == NULL)
25	return;
26
27	png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
28	info_ptr->valid \|= PNG_INFO_bKGD;
29	}
30	#endif
31
32	#if defined(PNG_cHRM_SUPPORTED)
33	#ifdef PNG_FLOATING_POINT_SUPPORTED
34	void PNGAPI
35	png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
36	double white_x, double white_y, double red_x, double red_y,
37	double green_x, double green_y, double blue_x, double blue_y)
38	{
39	png_debug1(1, "in %s storage function\n", "cHRM");
40	if (png_ptr == NULL \|\| info_ptr == NULL)
41	return;
42
43	if (white_x < 0.0 \|\| white_y < 0.0 \|\|
44	red_x < 0.0 \|\| red_y < 0.0 \|\|
45	green_x < 0.0 \|\| green_y < 0.0 \|\|
46	blue_x < 0.0 \|\| blue_y < 0.0)
47	{
48	png_warning(png_ptr,
49	"Ignoring attempt to set negative chromaticity value");
50	return;
51	}
52	if (white_x > 21474.83 \|\| white_y > 21474.83 \|\|
53	red_x > 21474.83 \|\| red_y > 21474.83 \|\|
54	green_x > 21474.83 \|\| green_y > 21474.83 \|\|
55	blue_x > 21474.83 \|\| blue_y > 21474.83)
56	{
57	png_warning(png_ptr,
58	"Ignoring attempt to set chromaticity value exceeding 21474.83");
59	return;
60	}
61
62	info_ptr->x_white = (float)white_x;
63	info_ptr->y_white = (float)white_y;
64	info_ptr->x_red = (float)red_x;
65	info_ptr->y_red = (float)red_y;
66	info_ptr->x_green = (float)green_x;
67	info_ptr->y_green = (float)green_y;
68	info_ptr->x_blue = (float)blue_x;
69	info_ptr->y_blue = (float)blue_y;
70	#ifdef PNG_FIXED_POINT_SUPPORTED
71	info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
72	info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
73	info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5);
74	info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5);
75	info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
76	info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
77	info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5);
78	info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5);
79	#endif
80	info_ptr->valid \|= PNG_INFO_cHRM;
81	}
82	#endif
83	#ifdef PNG_FIXED_POINT_SUPPORTED
84	void PNGAPI
85	png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
86	png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
87	png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
88	png_fixed_point blue_x, png_fixed_point blue_y)
89	{
90	png_debug1(1, "in %s storage function\n", "cHRM");
91	if (png_ptr == NULL \|\| info_ptr == NULL)
92	return;
93
94	if (white_x < 0 \|\| white_y < 0 \|\|
95	red_x < 0 \|\| red_y < 0 \|\|
96	green_x < 0 \|\| green_y < 0 \|\|
97	blue_x < 0 \|\| blue_y < 0)
98	{
99	png_warning(png_ptr,
100	"Ignoring attempt to set negative chromaticity value");
101	return;
102	}
103	if (white_x > (double) PNG_UINT_31_MAX \|\|
104	white_y > (double) PNG_UINT_31_MAX \|\|
105	red_x > (double) PNG_UINT_31_MAX \|\|
106	red_y > (double) PNG_UINT_31_MAX \|\|
107	green_x > (double) PNG_UINT_31_MAX \|\|
108	green_y > (double) PNG_UINT_31_MAX \|\|
109	blue_x > (double) PNG_UINT_31_MAX \|\|
110	blue_y > (double) PNG_UINT_31_MAX)
111	{
112	png_warning(png_ptr,
113	"Ignoring attempt to set chromaticity value exceeding 21474.83");
114	return;
115	}
116	info_ptr->int_x_white = white_x;
117	info_ptr->int_y_white = white_y;
118	info_ptr->int_x_red = red_x;
119	info_ptr->int_y_red = red_y;
120	info_ptr->int_x_green = green_x;
121	info_ptr->int_y_green = green_y;
122	info_ptr->int_x_blue = blue_x;
123	info_ptr->int_y_blue = blue_y;
124	#ifdef PNG_FLOATING_POINT_SUPPORTED
125	info_ptr->x_white = (float)(white_x/100000.);
126	info_ptr->y_white = (float)(white_y/100000.);
127	info_ptr->x_red = (float)( red_x/100000.);
128	info_ptr->y_red = (float)( red_y/100000.);
129	info_ptr->x_green = (float)(green_x/100000.);
130	info_ptr->y_green = (float)(green_y/100000.);
131	info_ptr->x_blue = (float)( blue_x/100000.);
132	info_ptr->y_blue = (float)( blue_y/100000.);
133	#endif
134	info_ptr->valid \|= PNG_INFO_cHRM;
135	}
136	#endif
137	#endif
138
139	#if defined(PNG_gAMA_SUPPORTED)
140	#ifdef PNG_FLOATING_POINT_SUPPORTED
141	void PNGAPI
142	png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
143	{
144	double gamma;
145	png_debug1(1, "in %s storage function\n", "gAMA");
146	if (png_ptr == NULL \|\| info_ptr == NULL)
147	return;
148
149	/* Check for overflow */
150	if (file_gamma > 21474.83)
151	{
152	png_warning(png_ptr, "Limiting gamma to 21474.83");
153	gamma=21474.83;
154	}
155	else
156	gamma=file_gamma;
157	info_ptr->gamma = (float)gamma;
158	#ifdef PNG_FIXED_POINT_SUPPORTED
159	info_ptr->int_gamma = (int)(gamma*100000.+.5);
160	#endif
161	info_ptr->valid \|= PNG_INFO_gAMA;
162	if(gamma == 0.0)
163	png_warning(png_ptr, "Setting gamma=0");
164	}
165	#endif
166	void PNGAPI
167	png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
168	int_gamma)
169	{
170	png_fixed_point gamma;
171
172	png_debug1(1, "in %s storage function\n", "gAMA");
173	if (png_ptr == NULL \|\| info_ptr == NULL)
174	return;
175
176	if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)
177	{
178	png_warning(png_ptr, "Limiting gamma to 21474.83");
179	gamma=PNG_UINT_31_MAX;
180	}
181	else
182	{
183	if (int_gamma < 0)
184	{
185	png_warning(png_ptr, "Setting negative gamma to zero");
186	gamma=0;
187	}
188	else
189	gamma=int_gamma;
190	}
191	#ifdef PNG_FLOATING_POINT_SUPPORTED
192	info_ptr->gamma = (float)(gamma/100000.);
193	#endif
194	#ifdef PNG_FIXED_POINT_SUPPORTED
195	info_ptr->int_gamma = gamma;
196	#endif
197	info_ptr->valid \|= PNG_INFO_gAMA;
198	if(gamma == 0)
199	png_warning(png_ptr, "Setting gamma=0");
200	}
201	#endif
202
203	#if defined(PNG_hIST_SUPPORTED)
204	void PNGAPI
205	png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
206	{
207	int i;
208
209	png_debug1(1, "in %s storage function\n", "hIST");
210	if (png_ptr == NULL \|\| info_ptr == NULL)
211	return;
212	if (info_ptr->num_palette == 0)
213	{
214	png_warning(png_ptr,
215	"Palette size 0, hIST allocation skipped.");
216	return;
217	}
218
219	#ifdef PNG_FREE_ME_SUPPORTED
220	png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
221	#endif
222	/* Changed from info->num_palette to 256 in version 1.2.1 */
223	png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
224	(png_uint_32)(256 * png_sizeof (png_uint_16)));
225	if (png_ptr->hist == NULL)
226	{
227	png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
228	return;
229	}
230
231	for (i = 0; i < info_ptr->num_palette; i++)
232	png_ptr->hist[i] = hist[i];
233	info_ptr->hist = png_ptr->hist;
234	info_ptr->valid \|= PNG_INFO_hIST;
235
236	#ifdef PNG_FREE_ME_SUPPORTED
237	info_ptr->free_me \|= PNG_FREE_HIST;
238	#else
239	png_ptr->flags \|= PNG_FLAG_FREE_HIST;
240	#endif
241	}
242	#endif
243
244	void PNGAPI
245	png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
246	png_uint_32 width, png_uint_32 height, int bit_depth,
247	int color_type, int interlace_type, int compression_type,
248	int filter_type)
249	{
250	png_debug1(1, "in %s storage function\n", "IHDR");
251	if (png_ptr == NULL \|\| info_ptr == NULL)
252	return;
253
254	/* check for width and height valid values */
255	if (width == 0 \|\| height == 0)
256	png_error(png_ptr, "Image width or height is zero in IHDR");
257	#ifdef PNG_SET_USER_LIMITS_SUPPORTED
258	if (width > png_ptr->user_width_max \|\| height > png_ptr->user_height_max)
259	png_error(png_ptr, "image size exceeds user limits in IHDR");
260	#else
261	if (width > PNG_USER_WIDTH_MAX \|\| height > PNG_USER_HEIGHT_MAX)
262	png_error(png_ptr, "image size exceeds user limits in IHDR");
263	#endif
264	if (width > PNG_UINT_31_MAX \|\| height > PNG_UINT_31_MAX)
265	png_error(png_ptr, "Invalid image size in IHDR");
266	if ( width > (PNG_UINT_32_MAX
267	>> 3) /* 8-byte RGBA pixels */
268	- 64 /* bigrowbuf hack */
269	- 1 /* filter byte */
270	- 78 / rounding of width to multiple of 8 pixels */
271	- 8) /* extra max_pixel_depth pad */
272	png_warning(png_ptr, "Width is too large for libpng to process pixels");
273
274	/* check other values */
275	if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
276	bit_depth != 8 && bit_depth != 16)
277	png_error(png_ptr, "Invalid bit depth in IHDR");
278
279	if (color_type < 0 \|\| color_type == 1 \|\|
280	color_type == 5 \|\| color_type > 6)
281	png_error(png_ptr, "Invalid color type in IHDR");
282
283	if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) \|\|
284	((color_type == PNG_COLOR_TYPE_RGB \|\|
285	color_type == PNG_COLOR_TYPE_GRAY_ALPHA \|\|
286	color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
287	png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");
288
289	if (interlace_type >= PNG_INTERLACE_LAST)
290	png_error(png_ptr, "Unknown interlace method in IHDR");
291
292	if (compression_type != PNG_COMPRESSION_TYPE_BASE)
293	png_error(png_ptr, "Unknown compression method in IHDR");
294
295	#if defined(PNG_MNG_FEATURES_SUPPORTED)
296	/* Accept filter_method 64 (intrapixel differencing) only if
297	* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
298	* 2. Libpng did not read a PNG signature (this filter_method is only
299	* used in PNG datastreams that are embedded in MNG datastreams) and
300	* 3. The application called png_permit_mng_features with a mask that
301	* included PNG_FLAG_MNG_FILTER_64 and
302	* 4. The filter_method is 64 and
303	* 5. The color_type is RGB or RGBA
304	*/
305	if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)
306	png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");
307	if(filter_type != PNG_FILTER_TYPE_BASE)
308	{
309	if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
310	(filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
311	((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
312	(color_type == PNG_COLOR_TYPE_RGB \|\|
313	color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
314	png_error(png_ptr, "Unknown filter method in IHDR");
315	if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
316	png_warning(png_ptr, "Invalid filter method in IHDR");
317	}
318	#else
319	if(filter_type != PNG_FILTER_TYPE_BASE)
320	png_error(png_ptr, "Unknown filter method in IHDR");
321	#endif
322
323	info_ptr->width = width;
324	info_ptr->height = height;
325	info_ptr->bit_depth = (png_byte)bit_depth;
326	info_ptr->color_type =(png_byte) color_type;
327	info_ptr->compression_type = (png_byte)compression_type;
328	info_ptr->filter_type = (png_byte)filter_type;
329	info_ptr->interlace_type = (png_byte)interlace_type;
330	if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
331	info_ptr->channels = 1;
332	else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
333	info_ptr->channels = 3;
334	else
335	info_ptr->channels = 1;
336	if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
337	info_ptr->channels++;
338	info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
339
340	/* check for potential overflow */
341	if ( width > (PNG_UINT_32_MAX
342	>> 3) /* 8-byte RGBA pixels */
343	- 64 /* bigrowbuf hack */
344	- 1 /* filter byte */
345	- 78 / rounding of width to multiple of 8 pixels */
346	- 8) /* extra max_pixel_depth pad */
347	info_ptr->rowbytes = (png_size_t)0;
348	else
349	info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width);
350	}
351
352	#if defined(PNG_oFFs_SUPPORTED)
353	void PNGAPI
354	png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
355	png_int_32 offset_x, png_int_32 offset_y, int unit_type)
356	{
357	png_debug1(1, "in %s storage function\n", "oFFs");
358	if (png_ptr == NULL \|\| info_ptr == NULL)
359	return;
360
361	info_ptr->x_offset = offset_x;
362	info_ptr->y_offset = offset_y;
363	info_ptr->offset_unit_type = (png_byte)unit_type;
364	info_ptr->valid \|= PNG_INFO_oFFs;
365	}
366	#endif
367
368	#if defined(PNG_pCAL_SUPPORTED)
369	void PNGAPI
370	png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
371	png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
372	png_charp units, png_charpp params)
373	{
374	png_uint_32 length;
375	int i;
376
377	png_debug1(1, "in %s storage function\n", "pCAL");
378	if (png_ptr == NULL \|\| info_ptr == NULL)
379	return;
380
381	length = png_strlen(purpose) + 1;
382	png_debug1(3, "allocating purpose for info (%lu bytes)\n", length);
383	info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
384	if (info_ptr->pcal_purpose == NULL)
385	{
386	png_warning(png_ptr, "Insufficient memory for pCAL purpose.");
387	return;
388	}
389	png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
390
391	png_debug(3, "storing X0, X1, type, and nparams in info\n");
392	info_ptr->pcal_X0 = X0;
393	info_ptr->pcal_X1 = X1;
394	info_ptr->pcal_type = (png_byte)type;
395	info_ptr->pcal_nparams = (png_byte)nparams;
396
397	length = png_strlen(units) + 1;
398	png_debug1(3, "allocating units for info (%lu bytes)\n", length);
399	info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
400	if (info_ptr->pcal_units == NULL)
401	{
402	png_warning(png_ptr, "Insufficient memory for pCAL units.");
403	return;
404	}
405	png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
406
407	info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
408	(png_uint_32)((nparams + 1) * png_sizeof(png_charp)));
409	if (info_ptr->pcal_params == NULL)
410	{
411	png_warning(png_ptr, "Insufficient memory for pCAL params.");
412	return;
413	}
414
415	info_ptr->pcal_params[nparams] = NULL;
416
417	for (i = 0; i < nparams; i++)
418	{
419	length = png_strlen(params[i]) + 1;
420	png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length);
421	info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
422	if (info_ptr->pcal_params[i] == NULL)
423	{
424	png_warning(png_ptr, "Insufficient memory for pCAL parameter.");
425	return;
426	}
427	png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
428	}
429
430	info_ptr->valid \|= PNG_INFO_pCAL;
431	#ifdef PNG_FREE_ME_SUPPORTED
432	info_ptr->free_me \|= PNG_FREE_PCAL;
433	#endif
434	}
435	#endif
436
437	#if defined(PNG_READ_sCAL_SUPPORTED) \|\| defined(PNG_WRITE_sCAL_SUPPORTED)
438	#ifdef PNG_FLOATING_POINT_SUPPORTED
439	void PNGAPI
440	png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
441	int unit, double width, double height)
442	{
443	png_debug1(1, "in %s storage function\n", "sCAL");
444	if (png_ptr == NULL \|\| info_ptr == NULL)
445	return;
446
447	info_ptr->scal_unit = (png_byte)unit;
448	info_ptr->scal_pixel_width = width;
449	info_ptr->scal_pixel_height = height;
450
451	info_ptr->valid \|= PNG_INFO_sCAL;
452	}
453	#else
454	#ifdef PNG_FIXED_POINT_SUPPORTED
455	void PNGAPI
456	png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
457	int unit, png_charp swidth, png_charp sheight)
458	{
459	png_uint_32 length;
460
461	png_debug1(1, "in %s storage function\n", "sCAL");
462	if (png_ptr == NULL \|\| info_ptr == NULL)
463	return;
464
465	info_ptr->scal_unit = (png_byte)unit;
466
467	length = png_strlen(swidth) + 1;
468	png_debug1(3, "allocating unit for info (%d bytes)\n", length);
469	info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
470	if (info_ptr->scal_s_width == NULL)
471	{
472	png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
473	}
474	png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
475
476	length = png_strlen(sheight) + 1;
477	png_debug1(3, "allocating unit for info (%d bytes)\n", length);
478	info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
479	if (info_ptr->scal_s_height == NULL)
480	{
481	png_free (png_ptr, info_ptr->scal_s_width);
482	png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
483	}
484	png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
485
486	info_ptr->valid \|= PNG_INFO_sCAL;
487	#ifdef PNG_FREE_ME_SUPPORTED
488	info_ptr->free_me \|= PNG_FREE_SCAL;
489	#endif
490	}
491	#endif
492	#endif
493	#endif
494
495	#if defined(PNG_pHYs_SUPPORTED)
496	void PNGAPI
497	png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
498	png_uint_32 res_x, png_uint_32 res_y, int unit_type)
499	{
500	png_debug1(1, "in %s storage function\n", "pHYs");
501	if (png_ptr == NULL \|\| info_ptr == NULL)
502	return;
503
504	info_ptr->x_pixels_per_unit = res_x;
505	info_ptr->y_pixels_per_unit = res_y;
506	info_ptr->phys_unit_type = (png_byte)unit_type;
507	info_ptr->valid \|= PNG_INFO_pHYs;
508	}
509	#endif
510
511	void PNGAPI
512	png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
513	png_colorp palette, int num_palette)
514	{
515
516	png_debug1(1, "in %s storage function\n", "PLTE");
517	if (png_ptr == NULL \|\| info_ptr == NULL)
518	return;
519
520	/*
521	* It may not actually be necessary to set png_ptr->palette here;
522	* we do it for backward compatibility with the way the png_handle_tRNS
523	* function used to do the allocation.
524	*/
525	#ifdef PNG_FREE_ME_SUPPORTED
526	png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
527	#endif
528
529	/* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries,
530	in case of an invalid PNG file that has too-large sample values. */
531	png_ptr->palette = (png_colorp)png_malloc(png_ptr,
532	256 * png_sizeof(png_color));
533	png_memset(png_ptr->palette, 0, 256 * png_sizeof(png_color));
534	png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color));
535	info_ptr->palette = png_ptr->palette;
536	info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
537
538	#ifdef PNG_FREE_ME_SUPPORTED
539	info_ptr->free_me \|= PNG_FREE_PLTE;
540	#else
541	png_ptr->flags \|= PNG_FLAG_FREE_PLTE;
542	#endif
543
544	info_ptr->valid \|= PNG_INFO_PLTE;
545	}
546
547	#if defined(PNG_sBIT_SUPPORTED)
548	void PNGAPI
549	png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
550	png_color_8p sig_bit)
551	{
552	png_debug1(1, "in %s storage function\n", "sBIT");
553	if (png_ptr == NULL \|\| info_ptr == NULL)
554	return;
555
556	png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8));
557	info_ptr->valid \|= PNG_INFO_sBIT;
558	}
559	#endif
560
561	#if defined(PNG_sRGB_SUPPORTED)
562	void PNGAPI
563	png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
564	{
565	png_debug1(1, "in %s storage function\n", "sRGB");
566	if (png_ptr == NULL \|\| info_ptr == NULL)
567	return;
568
569	info_ptr->srgb_intent = (png_byte)intent;
570	info_ptr->valid \|= PNG_INFO_sRGB;
571	}
572
573	void PNGAPI
574	png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
575	int intent)
576	{
577	#if defined(PNG_gAMA_SUPPORTED)
578	#ifdef PNG_FLOATING_POINT_SUPPORTED
579	float file_gamma;
580	#endif
581	#ifdef PNG_FIXED_POINT_SUPPORTED
582	png_fixed_point int_file_gamma;
583	#endif
584	#endif
585	#if defined(PNG_cHRM_SUPPORTED)
586	#ifdef PNG_FLOATING_POINT_SUPPORTED
587	float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
588	#endif
589	#ifdef PNG_FIXED_POINT_SUPPORTED
590	png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
591	int_green_y, int_blue_x, int_blue_y;
592	#endif
593	#endif
594	png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
595	if (png_ptr == NULL \|\| info_ptr == NULL)
596	return;
597
598	png_set_sRGB(png_ptr, info_ptr, intent);
599
600	#if defined(PNG_gAMA_SUPPORTED)
601	#ifdef PNG_FLOATING_POINT_SUPPORTED
602	file_gamma = (float).45455;
603	png_set_gAMA(png_ptr, info_ptr, file_gamma);
604	#endif
605	#ifdef PNG_FIXED_POINT_SUPPORTED
606	int_file_gamma = 45455L;
607	png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
608	#endif
609	#endif
610
611	#if defined(PNG_cHRM_SUPPORTED)
612	#ifdef PNG_FIXED_POINT_SUPPORTED
613	int_white_x = 31270L;
614	int_white_y = 32900L;
615	int_red_x = 64000L;
616	int_red_y = 33000L;
617	int_green_x = 30000L;
618	int_green_y = 60000L;
619	int_blue_x = 15000L;
620	int_blue_y = 6000L;
621
622	png_set_cHRM_fixed(png_ptr, info_ptr,
623	int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
624	int_blue_x, int_blue_y);
625	#endif
626	#ifdef PNG_FLOATING_POINT_SUPPORTED
627	white_x = (float).3127;
628	white_y = (float).3290;
629	red_x = (float).64;
630	red_y = (float).33;
631	green_x = (float).30;
632	green_y = (float).60;
633	blue_x = (float).15;
634	blue_y = (float).06;
635
636	png_set_cHRM(png_ptr, info_ptr,
637	white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
638	#endif
639	#endif
640	}
641	#endif
642
643
644	#if defined(PNG_iCCP_SUPPORTED)
645	void PNGAPI
646	png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
647	png_charp name, int compression_type,
648	png_charp profile, png_uint_32 proflen)
649	{
650	png_charp new_iccp_name;
651	png_charp new_iccp_profile;
652
653	png_debug1(1, "in %s storage function\n", "iCCP");
654	if (png_ptr == NULL \|\| info_ptr == NULL \|\| name == NULL \|\| profile == NULL)
655	return;
656
657	new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1);
658	if (new_iccp_name == NULL)
659	{
660	png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
661	return;
662	}
663	png_strcpy(new_iccp_name, name);
664	new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
665	if (new_iccp_profile == NULL)
666	{
667	png_free (png_ptr, new_iccp_name);
668	png_warning(png_ptr, "Insufficient memory to process iCCP profile.");
669	return;
670	}
671	png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
672
673	png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
674
675	info_ptr->iccp_proflen = proflen;
676	info_ptr->iccp_name = new_iccp_name;
677	info_ptr->iccp_profile = new_iccp_profile;
678	/* Compression is always zero but is here so the API and info structure
679	* does not have to change if we introduce multiple compression types */
680	info_ptr->iccp_compression = (png_byte)compression_type;
681	#ifdef PNG_FREE_ME_SUPPORTED
682	info_ptr->free_me \|= PNG_FREE_ICCP;
683	#endif
684	info_ptr->valid \|= PNG_INFO_iCCP;
685	}
686	#endif
687
688	#if defined(PNG_TEXT_SUPPORTED)
689	void PNGAPI
690	png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
691	int num_text)
692	{
693	int ret;
694	ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
695	if (ret)
696	png_error(png_ptr, "Insufficient memory to store text");
697	}
698
699	int /* PRIVATE */
700	png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
701	int num_text)
702	{
703	int i;
704
705	png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
706	"text" : (png_const_charp)png_ptr->chunk_name));
707
708	if (png_ptr == NULL \|\| info_ptr == NULL \|\| num_text == 0)
709	return(0);
710
711	/* Make sure we have enough space in the "text" array in info_struct
712	* to hold all of the incoming text_ptr objects.
713	*/
714	if (info_ptr->num_text + num_text > info_ptr->max_text)
715	{
716	if (info_ptr->text != NULL)
717	{
718	png_textp old_text;
719	int old_max;
720
721	old_max = info_ptr->max_text;
722	info_ptr->max_text = info_ptr->num_text + num_text + 8;
723	old_text = info_ptr->text;
724	info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
725	(png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));
726	if (info_ptr->text == NULL)
727	{
728	png_free(png_ptr, old_text);
729	return(1);
730	}
731	png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
732	png_sizeof(png_text)));
733	png_free(png_ptr, old_text);
734	}
735	else
736	{
737	info_ptr->max_text = num_text + 8;
738	info_ptr->num_text = 0;
739	info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
740	(png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));
741	if (info_ptr->text == NULL)
742	return(1);
743	#ifdef PNG_FREE_ME_SUPPORTED
744	info_ptr->free_me \|= PNG_FREE_TEXT;
745	#endif
746	}
747	png_debug1(3, "allocated %d entries for info_ptr->text\n",
748	info_ptr->max_text);
749	}
750	for (i = 0; i < num_text; i++)
751	{
752	png_size_t text_length,key_len;
753	png_size_t lang_len,lang_key_len;
754	png_textp textp = &(info_ptr->text[info_ptr->num_text]);
755
756	if (text_ptr[i].key == NULL)
757	continue;
758
759	key_len = png_strlen(text_ptr[i].key);
760
761	if(text_ptr[i].compression <= 0)
762	{
763	lang_len = 0;
764	lang_key_len = 0;
765	}
766	else
767	#ifdef PNG_iTXt_SUPPORTED
768	{
769	/* set iTXt data */
770	if (text_ptr[i].lang != NULL)
771	lang_len = png_strlen(text_ptr[i].lang);
772	else
773	lang_len = 0;
774	if (text_ptr[i].lang_key != NULL)
775	lang_key_len = png_strlen(text_ptr[i].lang_key);
776	else
777	lang_key_len = 0;
778	}
779	#else
780	{
781	png_warning(png_ptr, "iTXt chunk not supported.");
782	continue;
783	}
784	#endif
785
786	if (text_ptr[i].text == NULL \|\| text_ptr[i].text[0] == '\0')
787	{
788	text_length = 0;
789	#ifdef PNG_iTXt_SUPPORTED
790	if(text_ptr[i].compression > 0)
791	textp->compression = PNG_ITXT_COMPRESSION_NONE;
792	else
793	#endif
794	textp->compression = PNG_TEXT_COMPRESSION_NONE;
795	}
796	else
797	{
798	text_length = png_strlen(text_ptr[i].text);
799	textp->compression = text_ptr[i].compression;
800	}
801
802	textp->key = (png_charp)png_malloc_warn(png_ptr,
803	(png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));
804	if (textp->key == NULL)
805	return(1);
806	png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",
807	(png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4),
808	(int)textp->key);
809
810	png_memcpy(textp->key, text_ptr[i].key,
811	(png_size_t)(key_len));
812	*(textp->key+key_len) = '\0';
813	#ifdef PNG_iTXt_SUPPORTED
814	if (text_ptr[i].compression > 0)
815	{
816	textp->lang=textp->key + key_len + 1;
817	png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
818	*(textp->lang+lang_len) = '\0';
819	textp->lang_key=textp->lang + lang_len + 1;
820	png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
821	*(textp->lang_key+lang_key_len) = '\0';
822	textp->text=textp->lang_key + lang_key_len + 1;
823	}
824	else
825	#endif
826	{
827	#ifdef PNG_iTXt_SUPPORTED
828	textp->lang=NULL;
829	textp->lang_key=NULL;
830	#endif
831	textp->text=textp->key + key_len + 1;
832	}
833	if(text_length)
834	png_memcpy(textp->text, text_ptr[i].text,
835	(png_size_t)(text_length));
836	*(textp->text+text_length) = '\0';
837
838	#ifdef PNG_iTXt_SUPPORTED
839	if(textp->compression > 0)
840	{
841	textp->text_length = 0;
842	textp->itxt_length = text_length;
843	}
844	else
845	#endif
846	{
847	textp->text_length = text_length;
848	#ifdef PNG_iTXt_SUPPORTED
849	textp->itxt_length = 0;
850	#endif
851	}
852	info_ptr->text[info_ptr->num_text]= *textp;
853	info_ptr->num_text++;
854	png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
855	}
856	return(0);
857	}
858	#endif
859
860	#if defined(PNG_tIME_SUPPORTED)
861	void PNGAPI
862	png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
863	{
864	png_debug1(1, "in %s storage function\n", "tIME");
865	if (png_ptr == NULL \|\| info_ptr == NULL \|\|
866	(png_ptr->mode & PNG_WROTE_tIME))
867	return;
868
869	png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time));
870	info_ptr->valid \|= PNG_INFO_tIME;
871	}
872	#endif
873
874	#if defined(PNG_tRNS_SUPPORTED)
875	void PNGAPI
876	png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
877	png_bytep trans, int num_trans, png_color_16p trans_values)
878	{
879	png_debug1(1, "in %s storage function\n", "tRNS");
880	if (png_ptr == NULL \|\| info_ptr == NULL)
881	return;
882
883	if (trans != NULL)
884	{
885	/*
886	* It may not actually be necessary to set png_ptr->trans here;
887	* we do it for backward compatibility with the way the png_handle_tRNS
888	* function used to do the allocation.
889	*/
890	#ifdef PNG_FREE_ME_SUPPORTED
891	png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
892	#endif
893	/* Changed from num_trans to 256 in version 1.2.1 */
894	png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
895	(png_uint_32)256);
896	png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
897	#ifdef PNG_FREE_ME_SUPPORTED
898	info_ptr->free_me \|= PNG_FREE_TRNS;
899	#else
900	png_ptr->flags \|= PNG_FLAG_FREE_TRNS;
901	#endif
902	}
903
904	if (trans_values != NULL)
905	{
906	png_memcpy(&(info_ptr->trans_values), trans_values,
907	png_sizeof(png_color_16));
908	if (num_trans == 0)
909	num_trans = 1;
910	}
911	info_ptr->num_trans = (png_uint_16)num_trans;
912	info_ptr->valid \|= PNG_INFO_tRNS;
913	}
914	#endif
915
916	#if defined(PNG_sPLT_SUPPORTED)
917	void PNGAPI
918	png_set_sPLT(png_structp png_ptr,
919	png_infop info_ptr, png_sPLT_tp entries, int nentries)
920	{
921	png_sPLT_tp np;
922	int i;
923
924	np = (png_sPLT_tp)png_malloc_warn(png_ptr,
925	(info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t));
926	if (np == NULL)
927	{
928	png_warning(png_ptr, "No memory for sPLT palettes.");
929	return;
930	}
931
932	png_memcpy(np, info_ptr->splt_palettes,
933	info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
934	png_free(png_ptr, info_ptr->splt_palettes);
935	info_ptr->splt_palettes=NULL;
936
937	for (i = 0; i < nentries; i++)
938	{
939	png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
940	png_sPLT_tp from = entries + i;
941
942	to->name = (png_charp)png_malloc(png_ptr,
943	png_strlen(from->name) + 1);
944	/* TODO: use png_malloc_warn */
945	png_strcpy(to->name, from->name);
946	to->entries = (png_sPLT_entryp)png_malloc(png_ptr,
947	from->nentries * png_sizeof(png_sPLT_t));
948	/* TODO: use png_malloc_warn */
949	png_memcpy(to->entries, from->entries,
950	from->nentries * png_sizeof(png_sPLT_t));
951	to->nentries = from->nentries;
952	to->depth = from->depth;
953	}
954
955	info_ptr->splt_palettes = np;
956	info_ptr->splt_palettes_num += nentries;
957	info_ptr->valid \|= PNG_INFO_sPLT;
958	#ifdef PNG_FREE_ME_SUPPORTED
959	info_ptr->free_me \|= PNG_FREE_SPLT;
960	#endif
961	}
962	#endif /* PNG_sPLT_SUPPORTED */
963
964	#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
965	void PNGAPI
966	png_set_unknown_chunks(png_structp png_ptr,
967	png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
968	{
969	png_unknown_chunkp np;
970	int i;
971
972	if (png_ptr == NULL \|\| info_ptr == NULL \|\| num_unknowns == 0)
973	return;
974
975	np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
976	(info_ptr->unknown_chunks_num + num_unknowns) *
977	png_sizeof(png_unknown_chunk));
978	if (np == NULL)
979	{
980	png_warning(png_ptr, "Out of memory while processing unknown chunk.");
981	return;
982	}
983
984	png_memcpy(np, info_ptr->unknown_chunks,
985	info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
986	png_free(png_ptr, info_ptr->unknown_chunks);
987	info_ptr->unknown_chunks=NULL;
988
989	for (i = 0; i < num_unknowns; i++)
990	{
991	png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
992	png_unknown_chunkp from = unknowns + i;
993
994	png_strncpy((png_charp)to->name, (png_charp)from->name, 5);
995	to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);
996	if (to->data == NULL)
997	{
998	png_warning(png_ptr, "Out of memory processing unknown chunk.");
999	}
1000	else
1001	{
1002	png_memcpy(to->data, from->data, from->size);
1003	to->size = from->size;
1004
1005	/* note our location in the read or write sequence */
1006	to->location = (png_byte)(png_ptr->mode & 0xff);
1007	}
1008	}
1009
1010	info_ptr->unknown_chunks = np;
1011	info_ptr->unknown_chunks_num += num_unknowns;
1012	#ifdef PNG_FREE_ME_SUPPORTED
1013	info_ptr->free_me \|= PNG_FREE_UNKN;
1014	#endif
1015	}
1016	void PNGAPI
1017	png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
1018	int chunk, int location)
1019	{
1020	if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
1021	(int)info_ptr->unknown_chunks_num)
1022	info_ptr->unknown_chunks[chunk].location = (png_byte)location;
1023	}
1024	#endif
1025
1026	#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) \|\| \
1027	defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
1028	void PNGAPI
1029	png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
1030	{
1031	/* This function is deprecated in favor of png_permit_mng_features()
1032	and will be removed from libpng-2.0.0 */
1033	png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");
1034	if (png_ptr == NULL)
1035	return;
1036	png_ptr->mng_features_permitted = (png_byte)
1037	((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) \|
1038	((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
1039	}
1040	#endif
1041
1042	#if defined(PNG_MNG_FEATURES_SUPPORTED)
1043	png_uint_32 PNGAPI
1044	png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
1045	{
1046	png_debug(1, "in png_permit_mng_features\n");
1047	if (png_ptr == NULL)
1048	return (png_uint_32)0;
1049	png_ptr->mng_features_permitted =
1050	(png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
1051	return (png_uint_32)png_ptr->mng_features_permitted;
1052	}
1053	#endif
1054
1055	#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
1056	void PNGAPI
1057	png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
1058	chunk_list, int num_chunks)
1059	{
1060	png_bytep new_list, p;
1061	int i, old_num_chunks;
1062	if (num_chunks == 0)
1063	{
1064	if(keep == PNG_HANDLE_CHUNK_ALWAYS \|\| keep == PNG_HANDLE_CHUNK_IF_SAFE)
1065	png_ptr->flags \|= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1066	else
1067	png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1068
1069	if(keep == PNG_HANDLE_CHUNK_ALWAYS)
1070	png_ptr->flags \|= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1071	else
1072	png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1073	return;
1074	}
1075	if (chunk_list == NULL)
1076	return;
1077	old_num_chunks=png_ptr->num_chunk_list;
1078	new_list=(png_bytep)png_malloc(png_ptr,
1079	(png_uint_32)(5*(num_chunks+old_num_chunks)));
1080	if(png_ptr->chunk_list != NULL)
1081	{
1082	png_memcpy(new_list, png_ptr->chunk_list,
1083	(png_size_t)(5*old_num_chunks));
1084	png_free(png_ptr, png_ptr->chunk_list);
1085	png_ptr->chunk_list=NULL;
1086	}
1087	png_memcpy(new_list+5*old_num_chunks, chunk_list,
1088	(png_size_t)(5*num_chunks));
1089	for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5)
1090	*p=(png_byte)keep;
1091	png_ptr->num_chunk_list=old_num_chunks+num_chunks;
1092	png_ptr->chunk_list=new_list;
1093	#ifdef PNG_FREE_ME_SUPPORTED
1094	png_ptr->free_me \|= PNG_FREE_LIST;
1095	#endif
1096	}
1097	#endif
1098
1099	#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
1100	void PNGAPI
1101	png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
1102	png_user_chunk_ptr read_user_chunk_fn)
1103	{
1104	png_debug(1, "in png_set_read_user_chunk_fn\n");
1105	png_ptr->read_user_chunk_fn = read_user_chunk_fn;
1106	png_ptr->user_chunk_ptr = user_chunk_ptr;
1107	}
1108	#endif
1109
1110	#if defined(PNG_INFO_IMAGE_SUPPORTED)
1111	void PNGAPI
1112	png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
1113	{
1114	png_debug1(1, "in %s storage function\n", "rows");
1115
1116	if (png_ptr == NULL \|\| info_ptr == NULL)
1117	return;
1118
1119	if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
1120	png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1121	info_ptr->row_pointers = row_pointers;
1122	if(row_pointers)
1123	info_ptr->valid \|= PNG_INFO_IDAT;
1124	}
1125	#endif
1126
1127	#ifdef PNG_WRITE_SUPPORTED
1128	void PNGAPI
1129	png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
1130	{
1131	if(png_ptr->zbuf)
1132	png_free(png_ptr, png_ptr->zbuf);
1133	png_ptr->zbuf_size = (png_size_t)size;
1134	png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
1135	png_ptr->zstream.next_out = png_ptr->zbuf;
1136	png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1137	}
1138	#endif
1139
1140	void PNGAPI
1141	png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
1142	{
1143	if (png_ptr && info_ptr)
1144	info_ptr->valid &= ~(mask);
1145	}
1146
1147
1148	#ifndef PNG_1_0_X
1149	#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
1150	/* this function was added to libpng 1.2.0 and should always exist by default */
1151	void PNGAPI
1152	png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
1153	{
1154	png_uint_32 settable_asm_flags;
1155	png_uint_32 settable_mmx_flags;
1156
1157	settable_mmx_flags =
1158	#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
1159	PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \|
1160	#endif
1161	#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
1162	PNG_ASM_FLAG_MMX_READ_INTERLACE \|
1163	#endif
1164	#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
1165	PNG_ASM_FLAG_MMX_READ_FILTER_SUB \|
1166	PNG_ASM_FLAG_MMX_READ_FILTER_UP \|
1167	PNG_ASM_FLAG_MMX_READ_FILTER_AVG \|
1168	PNG_ASM_FLAG_MMX_READ_FILTER_PAETH \|
1169	#endif
1170	0;
1171
1172	/* could be some non-MMX ones in the future, but not currently: */
1173	settable_asm_flags = settable_mmx_flags;
1174
1175	if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) \|\|
1176	!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU))
1177	{
1178	/* clear all MMX flags if MMX isn't supported */
1179	settable_asm_flags &= ~settable_mmx_flags;
1180	png_ptr->asm_flags &= ~settable_mmx_flags;
1181	}
1182
1183	/* we're replacing the settable bits with those passed in by the user,
1184	* so first zero them out of the master copy, then logical-OR in the
1185	* allowed subset that was requested */
1186
1187	png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */
1188	png_ptr->asm_flags \|= (asm_flags & settable_asm_flags); /* set them */
1189	}
1190	#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
1191
1192	#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
1193	/* this function was added to libpng 1.2.0 */
1194	void PNGAPI
1195	png_set_mmx_thresholds (png_structp png_ptr,
1196	png_byte mmx_bitdepth_threshold,
1197	png_uint_32 mmx_rowbytes_threshold)
1198	{
1199	png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold;
1200	png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold;
1201	}
1202	#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
1203
1204	#ifdef PNG_SET_USER_LIMITS_SUPPORTED
1205	/* this function was added to libpng 1.2.6 */
1206	void PNGAPI
1207	png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
1208	png_uint_32 user_height_max)
1209	{
1210	/* Images with dimensions larger than these limits will be
1211	* rejected by png_set_IHDR(). To accept any PNG datastream
1212	* regardless of dimensions, set both limits to 0x7ffffffL.
1213	*/
1214	png_ptr->user_width_max = user_width_max;
1215	png_ptr->user_height_max = user_height_max;
1216	}
1217	#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1218
1219	#endif /* ?PNG_1_0_X */

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

source: vbox/trunk/src/libs/libpng-1.2.8/pngset.c@ 35199

Download in other formats: