Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

pngget.c

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago
trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 22.8 KB

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

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

Context Navigation

source: trunk/src/3rdparty/libpng/pngget.c

Download in other formats: