WebSVN - shark - Blame - Rev 96 - /shark/trunk/ports/png/pngget.c

Rev	Author	Line No.	Line
96	giacomo	1
		2	/* pngget.c - retrieval of values from info struct
		3	*
		4	* libpng 1.2.5 - October 3, 2002
		5	* For conditions of distribution and use, see copyright notice in png.h
		6	* Copyright (c) 1998-2002 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	png_uint_32 PNGAPI
		15	png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
		16	{
		17	if (png_ptr != NULL && info_ptr != NULL)
		18	return(info_ptr->valid & flag);
		19	else
		20	return(0);
		21	}
		22
		23	png_uint_32 PNGAPI
		24	png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
		25	{
		26	if (png_ptr != NULL && info_ptr != NULL)
		27	return(info_ptr->rowbytes);
		28	else
		29	return(0);
		30	}
		31
		32	#if defined(PNG_INFO_IMAGE_SUPPORTED)
		33	png_bytepp PNGAPI
		34	png_get_rows(png_structp png_ptr, png_infop info_ptr)
		35	{
		36	if (png_ptr != NULL && info_ptr != NULL)
		37	return(info_ptr->row_pointers);
		38	else
		39	return(0);
		40	}
		41	#endif
		42
		43	#ifdef PNG_EASY_ACCESS_SUPPORTED
		44	/* easy access to info, added in libpng-0.99 */
		45	png_uint_32 PNGAPI
		46	png_get_image_width(png_structp png_ptr, png_infop info_ptr)
		47	{
		48	if (png_ptr != NULL && info_ptr != NULL)
		49	{
		50	return info_ptr->width;
		51	}
		52	return (0);
		53	}
		54
		55	png_uint_32 PNGAPI
		56	png_get_image_height(png_structp png_ptr, png_infop info_ptr)
		57	{
		58	if (png_ptr != NULL && info_ptr != NULL)
		59	{
		60	return info_ptr->height;
		61	}
		62	return (0);
		63	}
		64
		65	png_byte PNGAPI
		66	png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
		67	{
		68	if (png_ptr != NULL && info_ptr != NULL)
		69	{
		70	return info_ptr->bit_depth;
		71	}
		72	return (0);
		73	}
		74
		75	png_byte PNGAPI
		76	png_get_color_type(png_structp png_ptr, png_infop info_ptr)
		77	{
		78	if (png_ptr != NULL && info_ptr != NULL)
		79	{
		80	return info_ptr->color_type;
		81	}
		82	return (0);
		83	}
		84
		85	png_byte PNGAPI
		86	png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
		87	{
		88	if (png_ptr != NULL && info_ptr != NULL)
		89	{
		90	return info_ptr->filter_type;
		91	}
		92	return (0);
		93	}
		94
		95	png_byte PNGAPI
		96	png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
		97	{
		98	if (png_ptr != NULL && info_ptr != NULL)
		99	{
		100	return info_ptr->interlace_type;
		101	}
		102	return (0);
		103	}
		104
		105	png_byte PNGAPI
		106	png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
		107	{
		108	if (png_ptr != NULL && info_ptr != NULL)
		109	{
		110	return info_ptr->compression_type;
		111	}
		112	return (0);
		113	}
		114
		115	png_uint_32 PNGAPI
		116	png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
		117	{
		118	if (png_ptr != NULL && info_ptr != NULL)
		119	#if defined(PNG_pHYs_SUPPORTED)
		120	if (info_ptr->valid & PNG_INFO_pHYs)
		121	{
		122	png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
		123	if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
		124	return (0);
		125	else return (info_ptr->x_pixels_per_unit);
		126	}
		127	#else
		128	return (0);
		129	#endif
		130	return (0);
		131	}
		132
		133	png_uint_32 PNGAPI
		134	png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
		135	{
		136	if (png_ptr != NULL && info_ptr != NULL)
		137	#if defined(PNG_pHYs_SUPPORTED)
		138	if (info_ptr->valid & PNG_INFO_pHYs)
		139	{
		140	png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
		141	if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
		142	return (0);
		143	else return (info_ptr->y_pixels_per_unit);
		144	}
		145	#else
		146	return (0);
		147	#endif
		148	return (0);
		149	}
		150
		151	png_uint_32 PNGAPI
		152	png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
		153	{
		154	if (png_ptr != NULL && info_ptr != NULL)
		155	#if defined(PNG_pHYs_SUPPORTED)
		156	if (info_ptr->valid & PNG_INFO_pHYs)
		157	{
		158	png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
		159	if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER \|\|
		160	info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
		161	return (0);
		162	else return (info_ptr->x_pixels_per_unit);
		163	}
		164	#else
		165	return (0);
		166	#endif
		167	return (0);
		168	}
		169
		170	#ifdef PNG_FLOATING_POINT_SUPPORTED
		171	float PNGAPI
		172	png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
		173	{
		174	if (png_ptr != NULL && info_ptr != NULL)
		175	#if defined(PNG_pHYs_SUPPORTED)
		176	if (info_ptr->valid & PNG_INFO_pHYs)
		177	{
		178	png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
		179	if (info_ptr->x_pixels_per_unit == 0)
		180	return ((float)0.0);
		181	else
		182	return ((float)((float)info_ptr->y_pixels_per_unit
		183	/(float)info_ptr->x_pixels_per_unit));
		184	}
		185	#else
		186	return (0.0);
		187	#endif
		188	return ((float)0.0);
		189	}
		190	#endif
		191
		192	png_int_32 PNGAPI
		193	png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
		194	{
		195	if (png_ptr != NULL && info_ptr != NULL)
		196	#if defined(PNG_oFFs_SUPPORTED)
		197	if (info_ptr->valid & PNG_INFO_oFFs)
		198	{
		199	png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
		200	if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
		201	return (0);
		202	else return (info_ptr->x_offset);
		203	}
		204	#else
		205	return (0);
		206	#endif
		207	return (0);
		208	}
		209
		210	png_int_32 PNGAPI
		211	png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
		212	{
		213	if (png_ptr != NULL && info_ptr != NULL)
		214	#if defined(PNG_oFFs_SUPPORTED)
		215	if (info_ptr->valid & PNG_INFO_oFFs)
		216	{
		217	png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
		218	if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
		219	return (0);
		220	else return (info_ptr->y_offset);
		221	}
		222	#else
		223	return (0);
		224	#endif
		225	return (0);
		226	}
		227
		228	png_int_32 PNGAPI
		229	png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
		230	{
		231	if (png_ptr != NULL && info_ptr != NULL)
		232	#if defined(PNG_oFFs_SUPPORTED)
		233	if (info_ptr->valid & PNG_INFO_oFFs)
		234	{
		235	png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
		236	if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
		237	return (0);
		238	else return (info_ptr->x_offset);
		239	}
		240	#else
		241	return (0);
		242	#endif
		243	return (0);
		244	}
		245
		246	png_int_32 PNGAPI
		247	png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
		248	{
		249	if (png_ptr != NULL && info_ptr != NULL)
		250	#if defined(PNG_oFFs_SUPPORTED)
		251	if (info_ptr->valid & PNG_INFO_oFFs)
		252	{
		253	png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
		254	if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
		255	return (0);
		256	else return (info_ptr->y_offset);
		257	}
		258	#else
		259	return (0);
		260	#endif
		261	return (0);
		262	}
		263
		264	#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
		265	png_uint_32 PNGAPI
		266	png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
		267	{
		268	return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
		269	*.0254 +.5));
		270	}
		271
		272	png_uint_32 PNGAPI
		273	png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
		274	{
		275	return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
		276	*.0254 +.5));
		277	}
		278
		279	png_uint_32 PNGAPI
		280	png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
		281	{
		282	return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
		283	*.0254 +.5));
		284	}
		285
		286	float PNGAPI
		287	png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
		288	{
		289	return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
		290	*.00003937);
		291	}
		292
		293	float PNGAPI
		294	png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
		295	{
		296	return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
		297	*.00003937);
		298	}
		299
		300	#if defined(PNG_pHYs_SUPPORTED)
		301	png_uint_32 PNGAPI
		302	png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
		303	png_uint_32 res_x, png_uint_32 res_y, int *unit_type)
		304	{
		305	png_uint_32 retval = 0;
		306
		307	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
		308	{
		309	png_debug1(1, "in %s retrieval function\n", "pHYs");
		310	if (res_x != NULL)
		311	{
		312	*res_x = info_ptr->x_pixels_per_unit;
		313	retval \|= PNG_INFO_pHYs;
		314	}
		315	if (res_y != NULL)
		316	{
		317	*res_y = info_ptr->y_pixels_per_unit;
		318	retval \|= PNG_INFO_pHYs;
		319	}
		320	if (unit_type != NULL)
		321	{
		322	*unit_type = (int)info_ptr->phys_unit_type;
		323	retval \|= PNG_INFO_pHYs;
		324	if(*unit_type == 1)
		325	{
		326	if (res_x != NULL) res_x = (png_uint_32)(res_x * .0254 + .50);
		327	if (res_y != NULL) res_y = (png_uint_32)(res_y * .0254 + .50);
		328	}
		329	}
		330	}
		331	return (retval);
		332	}
		333	#endif /* PNG_pHYs_SUPPORTED */
		334	#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
		335
		336	/* png_get_channels really belongs in here, too, but it's been around longer */
		337
		338	#endif /* PNG_EASY_ACCESS_SUPPORTED */
		339
		340	png_byte PNGAPI
		341	png_get_channels(png_structp png_ptr, png_infop info_ptr)
		342	{
		343	if (png_ptr != NULL && info_ptr != NULL)
		344	return(info_ptr->channels);
		345	else
		346	return (0);
		347	}
		348
		349	png_bytep PNGAPI
		350	png_get_signature(png_structp png_ptr, png_infop info_ptr)
		351	{
		352	if (png_ptr != NULL && info_ptr != NULL)
		353	return(info_ptr->signature);
		354	else
		355	return (NULL);
		356	}
		357
		358	#if defined(PNG_bKGD_SUPPORTED)
		359	png_uint_32 PNGAPI
		360	png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
		361	png_color_16p *background)
		362	{
		363	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
		364	&& background != NULL)
		365	{
		366	png_debug1(1, "in %s retrieval function\n", "bKGD");
		367	*background = &(info_ptr->background);
		368	return (PNG_INFO_bKGD);
		369	}
		370	return (0);
		371	}
		372	#endif
		373
		374	#if defined(PNG_cHRM_SUPPORTED)
		375	#ifdef PNG_FLOATING_POINT_SUPPORTED
		376	png_uint_32 PNGAPI
		377	png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
		378	double white_x, double white_y, double red_x, double red_y,
		379	double green_x, double green_y, double blue_x, double blue_y)
		380	{
		381	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
		382	{
		383	png_debug1(1, "in %s retrieval function\n", "cHRM");
		384	if (white_x != NULL)
		385	*white_x = (double)info_ptr->x_white;
		386	if (white_y != NULL)
		387	*white_y = (double)info_ptr->y_white;
		388	if (red_x != NULL)
		389	*red_x = (double)info_ptr->x_red;
		390	if (red_y != NULL)
		391	*red_y = (double)info_ptr->y_red;
		392	if (green_x != NULL)
		393	*green_x = (double)info_ptr->x_green;
		394	if (green_y != NULL)
		395	*green_y = (double)info_ptr->y_green;
		396	if (blue_x != NULL)
		397	*blue_x = (double)info_ptr->x_blue;
		398	if (blue_y != NULL)
		399	*blue_y = (double)info_ptr->y_blue;
		400	return (PNG_INFO_cHRM);
		401	}
		402	return (0);
		403	}
		404	#endif
		405	#ifdef PNG_FIXED_POINT_SUPPORTED
		406	png_uint_32 PNGAPI
		407	png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
		408	png_fixed_point white_x, png_fixed_point white_y, png_fixed_point *red_x,
		409	png_fixed_point red_y, png_fixed_point green_x, png_fixed_point *green_y,
		410	png_fixed_point blue_x, png_fixed_point blue_y)
		411	{
		412	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
		413	{
		414	png_debug1(1, "in %s retrieval function\n", "cHRM");
		415	if (white_x != NULL)
		416	*white_x = info_ptr->int_x_white;
		417	if (white_y != NULL)
		418	*white_y = info_ptr->int_y_white;
		419	if (red_x != NULL)
		420	*red_x = info_ptr->int_x_red;
		421	if (red_y != NULL)
		422	*red_y = info_ptr->int_y_red;
		423	if (green_x != NULL)
		424	*green_x = info_ptr->int_x_green;
		425	if (green_y != NULL)
		426	*green_y = info_ptr->int_y_green;
		427	if (blue_x != NULL)
		428	*blue_x = info_ptr->int_x_blue;
		429	if (blue_y != NULL)
		430	*blue_y = info_ptr->int_y_blue;
		431	return (PNG_INFO_cHRM);
		432	}
		433	return (0);
		434	}
		435	#endif
		436	#endif
		437
		438	#if defined(PNG_gAMA_SUPPORTED)
		439	#ifdef PNG_FLOATING_POINT_SUPPORTED
		440	png_uint_32 PNGAPI
		441	png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
		442	{
		443	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
		444	&& file_gamma != NULL)
		445	{
		446	png_debug1(1, "in %s retrieval function\n", "gAMA");
		447	*file_gamma = (double)info_ptr->gamma;
		448	return (PNG_INFO_gAMA);
		449	}
		450	return (0);
		451	}
		452	#endif
		453	#ifdef PNG_FIXED_POINT_SUPPORTED
		454	png_uint_32 PNGAPI
		455	png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
		456	png_fixed_point *int_file_gamma)
		457	{
		458	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
		459	&& int_file_gamma != NULL)
		460	{
		461	png_debug1(1, "in %s retrieval function\n", "gAMA");
		462	*int_file_gamma = info_ptr->int_gamma;
		463	return (PNG_INFO_gAMA);
		464	}
		465	return (0);
		466	}
		467	#endif
		468	#endif
		469
		470	#if defined(PNG_sRGB_SUPPORTED)
		471	png_uint_32 PNGAPI
		472	png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
		473	{
		474	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
		475	&& file_srgb_intent != NULL)
		476	{
		477	png_debug1(1, "in %s retrieval function\n", "sRGB");
		478	*file_srgb_intent = (int)info_ptr->srgb_intent;
		479	return (PNG_INFO_sRGB);
		480	}
		481	return (0);
		482	}
		483	#endif
		484
		485	#if defined(PNG_iCCP_SUPPORTED)
		486	png_uint_32 PNGAPI
		487	png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
		488	png_charpp name, int *compression_type,
		489	png_charpp profile, png_uint_32 *proflen)
		490	{
		491	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
		492	&& name != NULL && profile != NULL && proflen != NULL)
		493	{
		494	png_debug1(1, "in %s retrieval function\n", "iCCP");
		495	*name = info_ptr->iccp_name;
		496	*profile = info_ptr->iccp_profile;
		497	/* compression_type is a dummy so the API won't have to change
		498	if we introduce multiple compression types later. */
		499	*proflen = (int)info_ptr->iccp_proflen;
		500	*compression_type = (int)info_ptr->iccp_compression;
		501	return (PNG_INFO_iCCP);
		502	}
		503	return (0);
		504	}
		505	#endif
		506
		507	#if defined(PNG_sPLT_SUPPORTED)
		508	png_uint_32 PNGAPI
		509	png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
		510	png_sPLT_tpp spalettes)
		511	{
		512	if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
		513	*spalettes = info_ptr->splt_palettes;
		514	return ((png_uint_32)info_ptr->splt_palettes_num);
		515	}
		516	#endif
		517
		518	#if defined(PNG_hIST_SUPPORTED)
		519	png_uint_32 PNGAPI
		520	png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
		521	{
		522	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
		523	&& hist != NULL)
		524	{
		525	png_debug1(1, "in %s retrieval function\n", "hIST");
		526	*hist = info_ptr->hist;
		527	return (PNG_INFO_hIST);
		528	}
		529	return (0);
		530	}
		531	#endif
		532
		533	png_uint_32 PNGAPI
		534	png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
		535	png_uint_32 width, png_uint_32 height, int *bit_depth,
		536	int color_type, int interlace_type, int *compression_type,
		537	int *filter_type)
		538
		539	{
		540	if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
		541	bit_depth != NULL && color_type != NULL)
		542	{
		543	int pixel_depth, channels;
		544	png_uint_32 rowbytes_per_pixel;
		545
		546	png_debug1(1, "in %s retrieval function\n", "IHDR");
		547	*width = info_ptr->width;
		548	*height = info_ptr->height;
		549	*bit_depth = info_ptr->bit_depth;
		550	if (info_ptr->bit_depth < 1 \|\| info_ptr->bit_depth > 16)
		551	png_error(png_ptr, "Invalid bit depth");
		552	*color_type = info_ptr->color_type;
		553	if (info_ptr->color_type > 6)
		554	png_error(png_ptr, "Invalid color type");
		555	if (compression_type != NULL)
		556	*compression_type = info_ptr->compression_type;
		557	if (filter_type != NULL)
		558	*filter_type = info_ptr->filter_type;
		559	if (interlace_type != NULL)
		560	*interlace_type = info_ptr->interlace_type;
		561
		562	/* check for potential overflow of rowbytes */
		563	if (*color_type == PNG_COLOR_TYPE_PALETTE)
		564	channels = 1;
		565	else if (*color_type & PNG_COLOR_MASK_COLOR)
		566	channels = 3;
		567	else
		568	channels = 1;
		569	if (*color_type & PNG_COLOR_MASK_ALPHA)
		570	channels++;
		571	pixel_depth = bit_depth channels;
		572	rowbytes_per_pixel = (pixel_depth + 7) >> 3;
		573	if (width == 0 \|\| *width > PNG_MAX_UINT)
		574	png_error(png_ptr, "Invalid image width");
		575	if (height == 0 \|\| *height > PNG_MAX_UINT)
		576	png_error(png_ptr, "Invalid image height");
		577	if (*width > PNG_MAX_UINT/rowbytes_per_pixel - 64)
		578	{
		579	png_error(png_ptr,
		580	"Width too large for libpng to process image data.");
		581	}
		582	return (1);
		583	}
		584	return (0);
		585	}
		586
		587	#if defined(PNG_oFFs_SUPPORTED)
		588	png_uint_32 PNGAPI
		589	png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
		590	png_int_32 offset_x, png_int_32 offset_y, int *unit_type)
		591	{
		592	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
		593	&& offset_x != NULL && offset_y != NULL && unit_type != NULL)
		594	{
		595	png_debug1(1, "in %s retrieval function\n", "oFFs");
		596	*offset_x = info_ptr->x_offset;
		597	*offset_y = info_ptr->y_offset;
		598	*unit_type = (int)info_ptr->offset_unit_type;
		599	return (PNG_INFO_oFFs);
		600	}
		601	return (0);
		602	}
		603	#endif
		604
		605	#if defined(PNG_pCAL_SUPPORTED)
		606	png_uint_32 PNGAPI
		607	png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
		608	png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int *nparams,
		609	png_charp units, png_charpp params)
		610	{
		611	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
		612	&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
		613	nparams != NULL && units != NULL && params != NULL)
		614	{
		615	png_debug1(1, "in %s retrieval function\n", "pCAL");
		616	*purpose = info_ptr->pcal_purpose;
		617	*X0 = info_ptr->pcal_X0;
		618	*X1 = info_ptr->pcal_X1;
		619	*type = (int)info_ptr->pcal_type;
		620	*nparams = (int)info_ptr->pcal_nparams;
		621	*units = info_ptr->pcal_units;
		622	*params = info_ptr->pcal_params;
		623	return (PNG_INFO_pCAL);
		624	}
		625	return (0);
		626	}
		627	#endif
		628
		629	#if defined(PNG_sCAL_SUPPORTED)
		630	#ifdef PNG_FLOATING_POINT_SUPPORTED
		631	png_uint_32 PNGAPI
		632	png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
		633	int unit, double width, double *height)
		634	{
		635	if (png_ptr != NULL && info_ptr != NULL &&
		636	(info_ptr->valid & PNG_INFO_sCAL))
		637	{
		638	*unit = info_ptr->scal_unit;
		639	*width = info_ptr->scal_pixel_width;
		640	*height = info_ptr->scal_pixel_height;
		641	return (PNG_INFO_sCAL);
		642	}
		643	return(0);
		644	}
		645	#else
		646	#ifdef PNG_FIXED_POINT_SUPPORTED
		647	png_uint_32 PNGAPI
		648	png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
		649	int *unit, png_charpp width, png_charpp height)
		650	{
		651	if (png_ptr != NULL && info_ptr != NULL &&
		652	(info_ptr->valid & PNG_INFO_sCAL))
		653	{
		654	*unit = info_ptr->scal_unit;
		655	*width = info_ptr->scal_s_width;
		656	*height = info_ptr->scal_s_height;
		657	return (PNG_INFO_sCAL);
		658	}
		659	return(0);
		660	}
		661	#endif
		662	#endif
		663	#endif
		664
		665	#if defined(PNG_pHYs_SUPPORTED)
		666	png_uint_32 PNGAPI
		667	png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
		668	png_uint_32 res_x, png_uint_32 res_y, int *unit_type)
		669	{
		670	png_uint_32 retval = 0;
		671
		672	if (png_ptr != NULL && info_ptr != NULL &&
		673	(info_ptr->valid & PNG_INFO_pHYs))
		674	{
		675	png_debug1(1, "in %s retrieval function\n", "pHYs");
		676	if (res_x != NULL)
		677	{
		678	*res_x = info_ptr->x_pixels_per_unit;
		679	retval \|= PNG_INFO_pHYs;
		680	}
		681	if (res_y != NULL)
		682	{
		683	*res_y = info_ptr->y_pixels_per_unit;
		684	retval \|= PNG_INFO_pHYs;
		685	}
		686	if (unit_type != NULL)
		687	{
		688	*unit_type = (int)info_ptr->phys_unit_type;
		689	retval \|= PNG_INFO_pHYs;
		690	}
		691	}
		692	return (retval);
		693	}
		694	#endif
		695
		696	png_uint_32 PNGAPI
		697	png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
		698	int *num_palette)
		699	{
		700	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
		701	&& palette != NULL)
		702	{
		703	png_debug1(1, "in %s retrieval function\n", "PLTE");
		704	*palette = info_ptr->palette;
		705	*num_palette = info_ptr->num_palette;
		706	png_debug1(3, "num_palette = %d\n", *num_palette);
		707	return (PNG_INFO_PLTE);
		708	}
		709	return (0);
		710	}
		711
		712	#if defined(PNG_sBIT_SUPPORTED)
		713	png_uint_32 PNGAPI
		714	png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
		715	{
		716	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
		717	&& sig_bit != NULL)
		718	{
		719	png_debug1(1, "in %s retrieval function\n", "sBIT");
		720	*sig_bit = &(info_ptr->sig_bit);
		721	return (PNG_INFO_sBIT);
		722	}
		723	return (0);
		724	}
		725	#endif
		726
		727	#if defined(PNG_TEXT_SUPPORTED)
		728	png_uint_32 PNGAPI
		729	png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
		730	int *num_text)
		731	{
		732	if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
		733	{
		734	png_debug1(1, "in %s retrieval function\n",
		735	(png_ptr->chunk_name[0] == '\0' ? "text"
		736	: (png_const_charp)png_ptr->chunk_name));
		737	if (text_ptr != NULL)
		738	*text_ptr = info_ptr->text;
		739	if (num_text != NULL)
		740	*num_text = info_ptr->num_text;
		741	return ((png_uint_32)info_ptr->num_text);
		742	}
		743	if (num_text != NULL)
		744	*num_text = 0;
		745	return(0);
		746	}
		747	#endif
		748
		749	#if defined(PNG_tIME_SUPPORTED)
		750	png_uint_32 PNGAPI
		751	png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
		752	{
		753	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
		754	&& mod_time != NULL)
		755	{
		756	png_debug1(1, "in %s retrieval function\n", "tIME");
		757	*mod_time = &(info_ptr->mod_time);
		758	return (PNG_INFO_tIME);
		759	}
		760	return (0);
		761	}
		762	#endif
		763
		764	#if defined(PNG_tRNS_SUPPORTED)
		765	png_uint_32 PNGAPI
		766	png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
		767	png_bytep trans, int num_trans, png_color_16p *trans_values)
		768	{
		769	png_uint_32 retval = 0;
		770	if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
		771	{
		772	png_debug1(1, "in %s retrieval function\n", "tRNS");
		773	if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		774	{
		775	if (trans != NULL)
		776	{
		777	*trans = info_ptr->trans;
		778	retval \|= PNG_INFO_tRNS;
		779	}
		780	if (trans_values != NULL)
		781	*trans_values = &(info_ptr->trans_values);
		782	}
		783	else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
		784	{
		785	if (trans_values != NULL)
		786	{
		787	*trans_values = &(info_ptr->trans_values);
		788	retval \|= PNG_INFO_tRNS;
		789	}
		790	if(trans != NULL)
		791	*trans = NULL;
		792	}
		793	if(num_trans != NULL)
		794	{
		795	*num_trans = info_ptr->num_trans;
		796	retval \|= PNG_INFO_tRNS;
		797	}
		798	}
		799	return (retval);
		800	}
		801	#endif
		802
		803	#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
		804	png_uint_32 PNGAPI
		805	png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
		806	png_unknown_chunkpp unknowns)
		807	{
		808	if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
		809	*unknowns = info_ptr->unknown_chunks;
		810	return ((png_uint_32)info_ptr->unknown_chunks_num);
		811	}
		812	#endif
		813
		814	#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		815	png_byte PNGAPI
		816	png_get_rgb_to_gray_status (png_structp png_ptr)
		817	{
		818	return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
		819	}
		820	#endif
		821
		822	#if defined(PNG_USER_CHUNKS_SUPPORTED)
		823	png_voidp PNGAPI
		824	png_get_user_chunk_ptr(png_structp png_ptr)
		825	{
		826	return (png_ptr? png_ptr->user_chunk_ptr : NULL);
		827	}
		828	#endif
		829
		830
		831	png_uint_32 PNGAPI
		832	png_get_compression_buffer_size(png_structp png_ptr)
		833	{
		834	return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
		835	}
		836
		837
		838	#ifndef PNG_1_0_X
		839	#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
		840	/* this function was added to libpng 1.2.0 and should exist by default */
		841	png_uint_32 PNGAPI
		842	png_get_asm_flags (png_structp png_ptr)
		843	{
		844	return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L);
		845	}
		846
		847	/* this function was added to libpng 1.2.0 and should exist by default */
		848	png_uint_32 PNGAPI
		849	png_get_asm_flagmask (int flag_select)
		850	{
		851	png_uint_32 settable_asm_flags = 0;
		852
		853	if (flag_select & PNG_SELECT_READ)
		854	settable_asm_flags \|=
		855	PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \|
		856	PNG_ASM_FLAG_MMX_READ_INTERLACE \|
		857	PNG_ASM_FLAG_MMX_READ_FILTER_SUB \|
		858	PNG_ASM_FLAG_MMX_READ_FILTER_UP \|
		859	PNG_ASM_FLAG_MMX_READ_FILTER_AVG \|
		860	PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
		861	/* no non-MMX flags yet */
		862
		863	#if 0
		864	/* GRR: no write-flags yet, either, but someday... */
		865	if (flag_select & PNG_SELECT_WRITE)
		866	settable_asm_flags \|=
		867	PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
		868	#endif /* 0 */
		869
		870	return settable_asm_flags; /* _theoretically_ settable capabilities only */
		871	}
		872	#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
		873
		874
		875	#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
		876	/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */
		877	/* this function was added to libpng 1.2.0 */
		878	png_uint_32 PNGAPI
		879	png_get_mmx_flagmask (int flag_select, int *compilerID)
		880	{
		881	png_uint_32 settable_mmx_flags = 0;
		882
		883	if (flag_select & PNG_SELECT_READ)
		884	settable_mmx_flags \|=
		885	PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \|
		886	PNG_ASM_FLAG_MMX_READ_INTERLACE \|
		887	PNG_ASM_FLAG_MMX_READ_FILTER_SUB \|
		888	PNG_ASM_FLAG_MMX_READ_FILTER_UP \|
		889	PNG_ASM_FLAG_MMX_READ_FILTER_AVG \|
		890	PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
		891	#if 0
		892	/* GRR: no MMX write support yet, but someday... */
		893	if (flag_select & PNG_SELECT_WRITE)
		894	settable_mmx_flags \|=
		895	PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
		896	#endif /* 0 */
		897
		898	if (compilerID != NULL) {
		899	#ifdef PNG_USE_PNGVCRD
		900	compilerID = 1; / MSVC */
		901	#else
		902	#ifdef PNG_USE_PNGGCCRD
		903	compilerID = 2; / gcc/gas */
		904	#else
		905	compilerID = -1; / unknown (i.e., no asm/MMX code compiled) */
		906	#endif
		907	#endif
		908	}
		909
		910	return settable_mmx_flags; /* _theoretically_ settable capabilities only */
		911	}
		912
		913	/* this function was added to libpng 1.2.0 */
		914	png_byte PNGAPI
		915	png_get_mmx_bitdepth_threshold (png_structp png_ptr)
		916	{
		917	return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0);
		918	}
		919
		920	/* this function was added to libpng 1.2.0 */
		921	png_uint_32 PNGAPI
		922	png_get_mmx_rowbytes_threshold (png_structp png_ptr)
		923	{
		924	return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L);
		925	}
		926	#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
		927	#endif /* PNG_1_0_X */

Subversion Repositories shark

(root)/shark/trunk/ports/png/pngget.c @ 706 - Rev 96