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

Rev	Author	Line No.	Line
96	giacomo	1
		2	/* pngrtran.c - transforms the data in a row for PNG readers
		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	* This file contains functions optionally called by an application
		11	* in order to tell libpng how to handle data when reading a PNG.
		12	* Transformations that are used in both reading and writing are
		13	* in pngtrans.c.
		14	*/
		15
		16	#define PNG_INTERNAL
		17	#include "png.h"
		18
		19	/* Set the action on getting a CRC error for an ancillary or critical chunk. */
		20	void PNGAPI
		21	png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
		22	{
		23	png_debug(1, "in png_set_crc_action\n");
		24	/* Tell libpng how we react to CRC errors in critical chunks */
		25	switch (crit_action)
		26	{
		27	case PNG_CRC_NO_CHANGE: /* leave setting as is */
		28	break;
		29	case PNG_CRC_WARN_USE: /* warn/use data */
		30	png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
		31	png_ptr->flags \|= PNG_FLAG_CRC_CRITICAL_USE;
		32	break;
		33	case PNG_CRC_QUIET_USE: /* quiet/use data */
		34	png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
		35	png_ptr->flags \|= PNG_FLAG_CRC_CRITICAL_USE \|
		36	PNG_FLAG_CRC_CRITICAL_IGNORE;
		37	break;
		38	case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
		39	png_warning(png_ptr, "Can't discard critical data on CRC error.");
		40	case PNG_CRC_ERROR_QUIT: /* error/quit */
		41	case PNG_CRC_DEFAULT:
		42	default:
		43	png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
		44	break;
		45	}
		46
		47	switch (ancil_action)
		48	{
		49	case PNG_CRC_NO_CHANGE: /* leave setting as is */
		50	break;
		51	case PNG_CRC_WARN_USE: /* warn/use data */
		52	png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
		53	png_ptr->flags \|= PNG_FLAG_CRC_ANCILLARY_USE;
		54	break;
		55	case PNG_CRC_QUIET_USE: /* quiet/use data */
		56	png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
		57	png_ptr->flags \|= PNG_FLAG_CRC_ANCILLARY_USE \|
		58	PNG_FLAG_CRC_ANCILLARY_NOWARN;
		59	break;
		60	case PNG_CRC_ERROR_QUIT: /* error/quit */
		61	png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
		62	png_ptr->flags \|= PNG_FLAG_CRC_ANCILLARY_NOWARN;
		63	break;
		64	case PNG_CRC_WARN_DISCARD: /* warn/discard data */
		65	case PNG_CRC_DEFAULT:
		66	default:
		67	png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
		68	break;
		69	}
		70	}
		71
		72	#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
		73	defined(PNG_FLOATING_POINT_SUPPORTED)
		74	/* handle alpha and tRNS via a background color */
		75	void PNGAPI
		76	png_set_background(png_structp png_ptr,
		77	png_color_16p background_color, int background_gamma_code,
		78	int need_expand, double background_gamma)
		79	{
		80	png_debug(1, "in png_set_background\n");
		81	if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
		82	{
		83	png_warning(png_ptr, "Application must supply a known background gamma");
		84	return;
		85	}
		86
		87	png_ptr->transformations \|= PNG_BACKGROUND;
		88	png_memcpy(&(png_ptr->background), background_color, sizeof(png_color_16));
		89	png_ptr->background_gamma = (float)background_gamma;
		90	png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
		91	png_ptr->transformations \|= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
		92
		93	/* Note: if need_expand is set and color_type is either RGB or RGB_ALPHA
		94	* (in which case need_expand is superfluous anyway), the background color
		95	* might actually be gray yet not be flagged as such. This is not a problem
		96	* for the current code, which uses PNG_BACKGROUND_IS_GRAY only to
		97	* decide when to do the png_do_gray_to_rgb() transformation.
		98	*/
		99	if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) \|\|
		100	(!need_expand && background_color->red == background_color->green &&
		101	background_color->red == background_color->blue))
		102	png_ptr->mode \|= PNG_BACKGROUND_IS_GRAY;
		103	}
		104	#endif
		105
		106	#if defined(PNG_READ_16_TO_8_SUPPORTED)
		107	/* strip 16 bit depth files to 8 bit depth */
		108	void PNGAPI
		109	png_set_strip_16(png_structp png_ptr)
		110	{
		111	png_debug(1, "in png_set_strip_16\n");
		112	png_ptr->transformations \|= PNG_16_TO_8;
		113	}
		114	#endif
		115
		116	#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
		117	void PNGAPI
		118	png_set_strip_alpha(png_structp png_ptr)
		119	{
		120	png_debug(1, "in png_set_strip_alpha\n");
		121	png_ptr->transformations \|= PNG_STRIP_ALPHA;
		122	}
		123	#endif
		124
		125	#if defined(PNG_READ_DITHER_SUPPORTED)
		126	/* Dither file to 8 bit. Supply a palette, the current number
		127	* of elements in the palette, the maximum number of elements
		128	* allowed, and a histogram if possible. If the current number
		129	* of colors is greater then the maximum number, the palette will be
		130	* modified to fit in the maximum number. "full_dither" indicates
		131	* whether we need a dithering cube set up for RGB images, or if we
		132	* simply are reducing the number of colors in a paletted image.
		133	*/
		134
		135	typedef struct png_dsort_struct
		136	{
		137	struct png_dsort_struct FAR * next;
		138	png_byte left;
		139	png_byte right;
		140	} png_dsort;
		141	typedef png_dsort FAR * png_dsortp;
		142	typedef png_dsort FAR * FAR * png_dsortpp;
		143
		144	void PNGAPI
		145	png_set_dither(png_structp png_ptr, png_colorp palette,
		146	int num_palette, int maximum_colors, png_uint_16p histogram,
		147	int full_dither)
		148	{
		149	png_debug(1, "in png_set_dither\n");
		150	png_ptr->transformations \|= PNG_DITHER;
		151
		152	if (!full_dither)
		153	{
		154	int i;
		155
		156	png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
		157	(png_uint_32)(num_palette * sizeof (png_byte)));
		158	for (i = 0; i < num_palette; i++)
		159	png_ptr->dither_index[i] = (png_byte)i;
		160	}
		161
		162	if (num_palette > maximum_colors)
		163	{
		164	if (histogram != NULL)
		165	{
		166	/* This is easy enough, just throw out the least used colors.
		167	Perhaps not the best solution, but good enough. */
		168
		169	int i;
		170
		171	/* initialize an array to sort colors */
		172	png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
		173	(png_uint_32)(num_palette * sizeof (png_byte)));
		174
		175	/* initialize the dither_sort array */
		176	for (i = 0; i < num_palette; i++)
		177	png_ptr->dither_sort[i] = (png_byte)i;
		178
		179	/* Find the least used palette entries by starting a
		180	bubble sort, and running it until we have sorted
		181	out enough colors. Note that we don't care about
		182	sorting all the colors, just finding which are
		183	least used. */
		184
		185	for (i = num_palette - 1; i >= maximum_colors; i--)
		186	{
		187	int done; /* to stop early if the list is pre-sorted */
		188	int j;
		189
		190	done = 1;
		191	for (j = 0; j < i; j++)
		192	{
		193	if (histogram[png_ptr->dither_sort[j]]
		194	< histogram[png_ptr->dither_sort[j + 1]])
		195	{
		196	png_byte t;
		197
		198	t = png_ptr->dither_sort[j];
		199	png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
		200	png_ptr->dither_sort[j + 1] = t;
		201	done = 0;
		202	}
		203	}
		204	if (done)
		205	break;
		206	}
		207
		208	/* swap the palette around, and set up a table, if necessary */
		209	if (full_dither)
		210	{
		211	int j = num_palette;
		212
		213	/* put all the useful colors within the max, but don't
		214	move the others */
		215	for (i = 0; i < maximum_colors; i++)
		216	{
		217	if ((int)png_ptr->dither_sort[i] >= maximum_colors)
		218	{
		219	do
		220	j--;
		221	while ((int)png_ptr->dither_sort[j] >= maximum_colors);
		222	palette[i] = palette[j];
		223	}
		224	}
		225	}
		226	else
		227	{
		228	int j = num_palette;
		229
		230	/* move all the used colors inside the max limit, and
		231	develop a translation table */
		232	for (i = 0; i < maximum_colors; i++)
		233	{
		234	/* only move the colors we need to */
		235	if ((int)png_ptr->dither_sort[i] >= maximum_colors)
		236	{
		237	png_color tmp_color;
		238
		239	do
		240	j--;
		241	while ((int)png_ptr->dither_sort[j] >= maximum_colors);
		242
		243	tmp_color = palette[j];
		244	palette[j] = palette[i];
		245	palette[i] = tmp_color;
		246	/* indicate where the color went */
		247	png_ptr->dither_index[j] = (png_byte)i;
		248	png_ptr->dither_index[i] = (png_byte)j;
		249	}
		250	}
		251
		252	/* find closest color for those colors we are not using */
		253	for (i = 0; i < num_palette; i++)
		254	{
		255	if ((int)png_ptr->dither_index[i] >= maximum_colors)
		256	{
		257	int min_d, k, min_k, d_index;
		258
		259	/* find the closest color to one we threw out */
		260	d_index = png_ptr->dither_index[i];
		261	min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
		262	for (k = 1, min_k = 0; k < maximum_colors; k++)
		263	{
		264	int d;
		265
		266	d = PNG_COLOR_DIST(palette[d_index], palette[k]);
		267
		268	if (d < min_d)
		269	{
		270	min_d = d;
		271	min_k = k;
		272	}
		273	}
		274	/* point to closest color */
		275	png_ptr->dither_index[i] = (png_byte)min_k;
		276	}
		277	}
		278	}
		279	png_free(png_ptr, png_ptr->dither_sort);
		280	png_ptr->dither_sort=NULL;
		281	}
		282	else
		283	{
		284	/* This is much harder to do simply (and quickly). Perhaps
		285	we need to go through a median cut routine, but those
		286	don't always behave themselves with only a few colors
		287	as input. So we will just find the closest two colors,
		288	and throw out one of them (chosen somewhat randomly).
		289	[We don't understand this at all, so if someone wants to
		290	work on improving it, be our guest - AED, GRP]
		291	*/
		292	int i;
		293	int max_d;
		294	int num_new_palette;
		295	png_dsortp t;
		296	png_dsortpp hash;
		297
		298	t=NULL;
		299
		300	/* initialize palette index arrays */
		301	png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
		302	(png_uint_32)(num_palette * sizeof (png_byte)));
		303	png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
		304	(png_uint_32)(num_palette * sizeof (png_byte)));
		305
		306	/* initialize the sort array */
		307	for (i = 0; i < num_palette; i++)
		308	{
		309	png_ptr->index_to_palette[i] = (png_byte)i;
		310	png_ptr->palette_to_index[i] = (png_byte)i;
		311	}
		312
		313	hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
		314	sizeof (png_dsortp)));
		315	for (i = 0; i < 769; i++)
		316	hash[i] = NULL;
		317	/* png_memset(hash, 0, 769 * sizeof (png_dsortp)); */
		318
		319	num_new_palette = num_palette;
		320
		321	/* initial wild guess at how far apart the farthest pixel
		322	pair we will be eliminating will be. Larger
		323	numbers mean more areas will be allocated, Smaller
		324	numbers run the risk of not saving enough data, and
		325	having to do this all over again.
		326
		327	I have not done extensive checking on this number.
		328	*/
		329	max_d = 96;
		330
		331	while (num_new_palette > maximum_colors)
		332	{
		333	for (i = 0; i < num_new_palette - 1; i++)
		334	{
		335	int j;
		336
		337	for (j = i + 1; j < num_new_palette; j++)
		338	{
		339	int d;
		340
		341	d = PNG_COLOR_DIST(palette[i], palette[j]);
		342
		343	if (d <= max_d)
		344	{
		345
		346	t = (png_dsortp)png_malloc_warn(png_ptr,
		347	(png_uint_32)(sizeof(png_dsort)));
		348	if (t == NULL)
		349	break;
		350	t->next = hash[d];
		351	t->left = (png_byte)i;
		352	t->right = (png_byte)j;
		353	hash[d] = t;
		354	}
		355	}
		356	if (t == NULL)
		357	break;
		358	}
		359
		360	if (t != NULL)
		361	for (i = 0; i <= max_d; i++)
		362	{
		363	if (hash[i] != NULL)
		364	{
		365	png_dsortp p;
		366
		367	for (p = hash[i]; p; p = p->next)
		368	{
		369	if ((int)png_ptr->index_to_palette[p->left]
		370	< num_new_palette &&
		371	(int)png_ptr->index_to_palette[p->right]
		372	< num_new_palette)
		373	{
		374	int j, next_j;
		375
		376	if (num_new_palette & 0x01)
		377	{
		378	j = p->left;
		379	next_j = p->right;
		380	}
		381	else
		382	{
		383	j = p->right;
		384	next_j = p->left;
		385	}
		386
		387	num_new_palette--;
		388	palette[png_ptr->index_to_palette[j]]
		389	= palette[num_new_palette];
		390	if (!full_dither)
		391	{
		392	int k;
		393
		394	for (k = 0; k < num_palette; k++)
		395	{
		396	if (png_ptr->dither_index[k] ==
		397	png_ptr->index_to_palette[j])
		398	png_ptr->dither_index[k] =
		399	png_ptr->index_to_palette[next_j];
		400	if ((int)png_ptr->dither_index[k] ==
		401	num_new_palette)
		402	png_ptr->dither_index[k] =
		403	png_ptr->index_to_palette[j];
		404	}
		405	}
		406
		407	png_ptr->index_to_palette[png_ptr->palette_to_index
		408	[num_new_palette]] = png_ptr->index_to_palette[j];
		409	png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
		410	= png_ptr->palette_to_index[num_new_palette];
		411
		412	png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
		413	png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
		414	}
		415	if (num_new_palette <= maximum_colors)
		416	break;
		417	}
		418	if (num_new_palette <= maximum_colors)
		419	break;
		420	}
		421	}
		422
		423	for (i = 0; i < 769; i++)
		424	{
		425	if (hash[i] != NULL)
		426	{
		427	png_dsortp p = hash[i];
		428	while (p)
		429	{
		430	t = p->next;
		431	png_free(png_ptr, p);
		432	p = t;
		433	}
		434	}
		435	hash[i] = 0;
		436	}
		437	max_d += 96;
		438	}
		439	png_free(png_ptr, hash);
		440	png_free(png_ptr, png_ptr->palette_to_index);
		441	png_free(png_ptr, png_ptr->index_to_palette);
		442	png_ptr->palette_to_index=NULL;
		443	png_ptr->index_to_palette=NULL;
		444	}
		445	num_palette = maximum_colors;
		446	}
		447	if (png_ptr->palette == NULL)
		448	{
		449	png_ptr->palette = palette;
		450	}
		451	png_ptr->num_palette = (png_uint_16)num_palette;
		452
		453	if (full_dither)
		454	{
		455	int i;
		456	png_bytep distance;
		457	int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
		458	PNG_DITHER_BLUE_BITS;
		459	int num_red = (1 << PNG_DITHER_RED_BITS);
		460	int num_green = (1 << PNG_DITHER_GREEN_BITS);
		461	int num_blue = (1 << PNG_DITHER_BLUE_BITS);
		462	png_size_t num_entries = ((png_size_t)1 << total_bits);
		463
		464	png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
		465	(png_uint_32)(num_entries * sizeof (png_byte)));
		466
		467	png_memset(png_ptr->palette_lookup, 0, num_entries * sizeof (png_byte));
		468
		469	distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
		470	sizeof(png_byte)));
		471
		472	png_memset(distance, 0xff, num_entries * sizeof(png_byte));
		473
		474	for (i = 0; i < num_palette; i++)
		475	{
		476	int ir, ig, ib;
		477	int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
		478	int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
		479	int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
		480
		481	for (ir = 0; ir < num_red; ir++)
		482	{
		483	int dr = abs(ir - r);
		484	int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
		485
		486	for (ig = 0; ig < num_green; ig++)
		487	{
		488	int dg = abs(ig - g);
		489	int dt = dr + dg;
		490	int dm = ((dr > dg) ? dr : dg);
		491	int index_g = index_r \| (ig << PNG_DITHER_BLUE_BITS);
		492
		493	for (ib = 0; ib < num_blue; ib++)
		494	{
		495	int d_index = index_g \| ib;
		496	int db = abs(ib - b);
		497	int dmax = ((dm > db) ? dm : db);
		498	int d = dmax + dt + db;
		499
		500	if (d < (int)distance[d_index])
		501	{
		502	distance[d_index] = (png_byte)d;
		503	png_ptr->palette_lookup[d_index] = (png_byte)i;
		504	}
		505	}
		506	}
		507	}
		508	}
		509
		510	png_free(png_ptr, distance);
		511	}
		512	}
		513	#endif
		514
		515	#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
		516	/* Transform the image from the file_gamma to the screen_gamma. We
		517	* only do transformations on images where the file_gamma and screen_gamma
		518	* are not close reciprocals, otherwise it slows things down slightly, and
		519	* also needlessly introduces small errors.
		520	*
		521	* We will turn off gamma transformation later if no semitransparent entries
		522	* are present in the tRNS array for palette images. We can't do it here
		523	* because we don't necessarily have the tRNS chunk yet.
		524	*/
		525	void PNGAPI
		526	png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
		527	{
		528	png_debug(1, "in png_set_gamma\n");
		529	if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) \|\|
		530	(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) \|\|
		531	(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
		532	png_ptr->transformations \|= PNG_GAMMA;
		533	png_ptr->gamma = (float)file_gamma;
		534	png_ptr->screen_gamma = (float)scrn_gamma;
		535	}
		536	#endif
		537
		538	#if defined(PNG_READ_EXPAND_SUPPORTED)
		539	/* Expand paletted images to RGB, expand grayscale images of
		540	* less than 8-bit depth to 8-bit depth, and expand tRNS chunks
		541	* to alpha channels.
		542	*/
		543	void PNGAPI
		544	png_set_expand(png_structp png_ptr)
		545	{
		546	png_debug(1, "in png_set_expand\n");
		547	png_ptr->transformations \|= PNG_EXPAND;
		548	}
		549
		550	/* GRR 19990627: the following three functions currently are identical
		551	* to png_set_expand(). However, it is entirely reasonable that someone
		552	* might wish to expand an indexed image to RGB but not expand a single,
		553	* fully transparent palette entry to a full alpha channel--perhaps instead
		554	* convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
		555	* the transparent color with a particular RGB value, or drop tRNS entirely.
		556	* IOW, a future version of the library may make the transformations flag
		557	* a bit more fine-grained, with separate bits for each of these three
		558	* functions.
		559	*
		560	* More to the point, these functions make it obvious what libpng will be
		561	* doing, whereas "expand" can (and does) mean any number of things.
		562	*/
		563
		564	/* Expand paletted images to RGB. */
		565	void PNGAPI
		566	png_set_palette_to_rgb(png_structp png_ptr)
		567	{
		568	png_debug(1, "in png_set_expand\n");
		569	png_ptr->transformations \|= PNG_EXPAND;
		570	}
		571
		572	/* Expand grayscale images of less than 8-bit depth to 8 bits. */
		573	void PNGAPI
		574	png_set_gray_1_2_4_to_8(png_structp png_ptr)
		575	{
		576	png_debug(1, "in png_set_expand\n");
		577	png_ptr->transformations \|= PNG_EXPAND;
		578	}
		579
		580	/* Expand tRNS chunks to alpha channels. */
		581	void PNGAPI
		582	png_set_tRNS_to_alpha(png_structp png_ptr)
		583	{
		584	png_debug(1, "in png_set_expand\n");
		585	png_ptr->transformations \|= PNG_EXPAND;
		586	}
		587	#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
		588
		589	#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
		590	void PNGAPI
		591	png_set_gray_to_rgb(png_structp png_ptr)
		592	{
		593	png_debug(1, "in png_set_gray_to_rgb\n");
		594	png_ptr->transformations \|= PNG_GRAY_TO_RGB;
		595	}
		596	#endif
		597
		598	#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		599	#if defined(PNG_FLOATING_POINT_SUPPORTED)
		600	/* Convert a RGB image to a grayscale of the same width. This allows us,
		601	* for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
		602	*/
		603
		604	void PNGAPI
		605	png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
		606	double green)
		607	{
		608	int red_fixed = (int)((float)red*100000.0 + 0.5);
		609	int green_fixed = (int)((float)green*100000.0 + 0.5);
		610	png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
		611	}
		612	#endif
		613
		614	void PNGAPI
		615	png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
		616	png_fixed_point red, png_fixed_point green)
		617	{
		618	png_debug(1, "in png_set_rgb_to_gray\n");
		619	switch(error_action)
		620	{
		621	case 1: png_ptr->transformations \|= PNG_RGB_TO_GRAY;
		622	break;
		623	case 2: png_ptr->transformations \|= PNG_RGB_TO_GRAY_WARN;
		624	break;
		625	case 3: png_ptr->transformations \|= PNG_RGB_TO_GRAY_ERR;
		626	}
		627	if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		628	#if defined(PNG_READ_EXPAND_SUPPORTED)
		629	png_ptr->transformations \|= PNG_EXPAND;
		630	#else
		631	{
		632	png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
		633	png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
		634	}
		635	#endif
		636	{
		637	png_uint_16 red_int, green_int;
		638	if(red < 0 \|\| green < 0)
		639	{
		640	red_int = 6968; /* .212671 * 32768 + .5 */
		641	green_int = 23434; /* .715160 * 32768 + .5 */
		642	}
		643	else if(red + green < 100000L)
		644	{
		645	red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
		646	green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
		647	}
		648	else
		649	{
		650	png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
		651	red_int = 6968;
		652	green_int = 23434;
		653	}
		654	png_ptr->rgb_to_gray_red_coeff = red_int;
		655	png_ptr->rgb_to_gray_green_coeff = green_int;
		656	png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(32768-red_int-green_int);
		657	}
		658	}
		659	#endif
		660
		661	#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) \|\| \
		662	defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) \|\| \
		663	defined(PNG_LEGACY_SUPPORTED)
		664	void PNGAPI
		665	png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
		666	read_user_transform_fn)
		667	{
		668	png_debug(1, "in png_set_read_user_transform_fn\n");
		669	#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
		670	png_ptr->transformations \|= PNG_USER_TRANSFORM;
		671	png_ptr->read_user_transform_fn = read_user_transform_fn;
		672	#endif
		673	#ifdef PNG_LEGACY_SUPPORTED
		674	if(read_user_transform_fn)
		675	png_warning(png_ptr,
		676	"This version of libpng does not support user transforms");
		677	#endif
		678	}
		679	#endif
		680
		681	/* Initialize everything needed for the read. This includes modifying
		682	* the palette.
		683	*/
		684	void /* PRIVATE */
		685	png_init_read_transformations(png_structp png_ptr)
		686	{
		687	png_debug(1, "in png_init_read_transformations\n");
		688	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		689	if(png_ptr != NULL)
		690	#endif
		691	{
		692	#if defined(PNG_READ_BACKGROUND_SUPPORTED) \|\| defined(PNG_READ_SHIFT_SUPPORTED) \
		693	\|\| defined(PNG_READ_GAMMA_SUPPORTED)
		694	int color_type = png_ptr->color_type;
		695	#endif
		696
		697	#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
		698	if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
		699	(png_ptr->transformations & PNG_EXPAND))
		700	{
		701	if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */
		702	{
		703	/* expand background chunk. */
		704	switch (png_ptr->bit_depth)
		705	{
		706	case 1:
		707	png_ptr->background.gray *= (png_uint_16)0xff;
		708	png_ptr->background.red = png_ptr->background.green
		709	= png_ptr->background.blue = png_ptr->background.gray;
		710	break;
		711	case 2:
		712	png_ptr->background.gray *= (png_uint_16)0x55;
		713	png_ptr->background.red = png_ptr->background.green
		714	= png_ptr->background.blue = png_ptr->background.gray;
		715	break;
		716	case 4:
		717	png_ptr->background.gray *= (png_uint_16)0x11;
		718	png_ptr->background.red = png_ptr->background.green
		719	= png_ptr->background.blue = png_ptr->background.gray;
		720	break;
		721	case 8:
		722	case 16:
		723	png_ptr->background.red = png_ptr->background.green
		724	= png_ptr->background.blue = png_ptr->background.gray;
		725	break;
		726	}
		727	}
		728	else if (color_type == PNG_COLOR_TYPE_PALETTE)
		729	{
		730	png_ptr->background.red =
		731	png_ptr->palette[png_ptr->background.index].red;
		732	png_ptr->background.green =
		733	png_ptr->palette[png_ptr->background.index].green;
		734	png_ptr->background.blue =
		735	png_ptr->palette[png_ptr->background.index].blue;
		736
		737	#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
		738	if (png_ptr->transformations & PNG_INVERT_ALPHA)
		739	{
		740	#if defined(PNG_READ_EXPAND_SUPPORTED)
		741	if (!(png_ptr->transformations & PNG_EXPAND))
		742	#endif
		743	{
		744	/* invert the alpha channel (in tRNS) unless the pixels are
		745	going to be expanded, in which case leave it for later */
		746	int i,istop;
		747	istop=(int)png_ptr->num_trans;
		748	for (i=0; i<istop; i++)
		749	png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
		750	}
		751	}
		752	#endif
		753
		754	}
		755	}
		756	#endif
		757
		758	#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
		759	png_ptr->background_1 = png_ptr->background;
		760	#endif
		761	#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
		762
		763	if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
		764	&& (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
		765	< PNG_GAMMA_THRESHOLD))
		766	{
		767	int i,k;
		768	k=0;
		769	for (i=0; i<png_ptr->num_trans; i++)
		770	{
		771	if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
		772	k=1; /* partial transparency is present */
		773	}
		774	if (k == 0)
		775	png_ptr->transformations &= (~PNG_GAMMA);
		776	}
		777
		778	if (png_ptr->transformations & (PNG_GAMMA \| PNG_RGB_TO_GRAY))
		779	{
		780	png_build_gamma_table(png_ptr);
		781	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		782	if (png_ptr->transformations & PNG_BACKGROUND)
		783	{
		784	if (color_type == PNG_COLOR_TYPE_PALETTE)
		785	{
		786	/* could skip if no transparency and
		787	*/
		788	png_color back, back_1;
		789	png_colorp palette = png_ptr->palette;
		790	int num_palette = png_ptr->num_palette;
		791	int i;
		792	if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
		793	{
		794	back.red = png_ptr->gamma_table[png_ptr->background.red];
		795	back.green = png_ptr->gamma_table[png_ptr->background.green];
		796	back.blue = png_ptr->gamma_table[png_ptr->background.blue];
		797
		798	back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
		799	back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
		800	back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
		801	}
		802	else
		803	{
		804	double g, gs;
		805
		806	switch (png_ptr->background_gamma_type)
		807	{
		808	case PNG_BACKGROUND_GAMMA_SCREEN:
		809	g = (png_ptr->screen_gamma);
		810	gs = 1.0;
		811	break;
		812	case PNG_BACKGROUND_GAMMA_FILE:
		813	g = 1.0 / (png_ptr->gamma);
		814	gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
		815	break;
		816	case PNG_BACKGROUND_GAMMA_UNIQUE:
		817	g = 1.0 / (png_ptr->background_gamma);
		818	gs = 1.0 / (png_ptr->background_gamma *
		819	png_ptr->screen_gamma);
		820	break;
		821	default:
		822	g = 1.0; /* back_1 */
		823	gs = 1.0; /* back */
		824	}
		825
		826	if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
		827	{
		828	back.red = (png_byte)png_ptr->background.red;
		829	back.green = (png_byte)png_ptr->background.green;
		830	back.blue = (png_byte)png_ptr->background.blue;
		831	}
		832	else
		833	{
		834	back.red = (png_byte)(pow(
		835	(double)png_ptr->background.red/255, gs) * 255.0 + .5);
		836	back.green = (png_byte)(pow(
		837	(double)png_ptr->background.green/255, gs) * 255.0 + .5);
		838	back.blue = (png_byte)(pow(
		839	(double)png_ptr->background.blue/255, gs) * 255.0 + .5);
		840	}
		841
		842	back_1.red = (png_byte)(pow(
		843	(double)png_ptr->background.red/255, g) * 255.0 + .5);
		844	back_1.green = (png_byte)(pow(
		845	(double)png_ptr->background.green/255, g) * 255.0 + .5);
		846	back_1.blue = (png_byte)(pow(
		847	(double)png_ptr->background.blue/255, g) * 255.0 + .5);
		848	}
		849	for (i = 0; i < num_palette; i++)
		850	{
		851	if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
		852	{
		853	if (png_ptr->trans[i] == 0)
		854	{
		855	palette[i] = back;
		856	}
		857	else /* if (png_ptr->trans[i] != 0xff) */
		858	{
		859	png_byte v, w;
		860
		861	v = png_ptr->gamma_to_1[palette[i].red];
		862	png_composite(w, v, png_ptr->trans[i], back_1.red);
		863	palette[i].red = png_ptr->gamma_from_1[w];
		864
		865	v = png_ptr->gamma_to_1[palette[i].green];
		866	png_composite(w, v, png_ptr->trans[i], back_1.green);
		867	palette[i].green = png_ptr->gamma_from_1[w];
		868
		869	v = png_ptr->gamma_to_1[palette[i].blue];
		870	png_composite(w, v, png_ptr->trans[i], back_1.blue);
		871	palette[i].blue = png_ptr->gamma_from_1[w];
		872	}
		873	}
		874	else
		875	{
		876	palette[i].red = png_ptr->gamma_table[palette[i].red];
		877	palette[i].green = png_ptr->gamma_table[palette[i].green];
		878	palette[i].blue = png_ptr->gamma_table[palette[i].blue];
		879	}
		880	}
		881	}
		882	/* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
		883	else
		884	/* color_type != PNG_COLOR_TYPE_PALETTE */
		885	{
		886	double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
		887	double g = 1.0;
		888	double gs = 1.0;
		889
		890	switch (png_ptr->background_gamma_type)
		891	{
		892	case PNG_BACKGROUND_GAMMA_SCREEN:
		893	g = (png_ptr->screen_gamma);
		894	gs = 1.0;
		895	break;
		896	case PNG_BACKGROUND_GAMMA_FILE:
		897	g = 1.0 / (png_ptr->gamma);
		898	gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
		899	break;
		900	case PNG_BACKGROUND_GAMMA_UNIQUE:
		901	g = 1.0 / (png_ptr->background_gamma);
		902	gs = 1.0 / (png_ptr->background_gamma *
		903	png_ptr->screen_gamma);
		904	break;
		905	}
		906
		907	png_ptr->background_1.gray = (png_uint_16)(pow(
		908	(double)png_ptr->background.gray / m, g) * m + .5);
		909	png_ptr->background.gray = (png_uint_16)(pow(
		910	(double)png_ptr->background.gray / m, gs) * m + .5);
		911
		912	if ((png_ptr->background.red != png_ptr->background.green) \|\|
		913	(png_ptr->background.red != png_ptr->background.blue) \|\|
		914	(png_ptr->background.red != png_ptr->background.gray))
		915	{
		916	/* RGB or RGBA with color background */
		917	png_ptr->background_1.red = (png_uint_16)(pow(
		918	(double)png_ptr->background.red / m, g) * m + .5);
		919	png_ptr->background_1.green = (png_uint_16)(pow(
		920	(double)png_ptr->background.green / m, g) * m + .5);
		921	png_ptr->background_1.blue = (png_uint_16)(pow(
		922	(double)png_ptr->background.blue / m, g) * m + .5);
		923	png_ptr->background.red = (png_uint_16)(pow(
		924	(double)png_ptr->background.red / m, gs) * m + .5);
		925	png_ptr->background.green = (png_uint_16)(pow(
		926	(double)png_ptr->background.green / m, gs) * m + .5);
		927	png_ptr->background.blue = (png_uint_16)(pow(
		928	(double)png_ptr->background.blue / m, gs) * m + .5);
		929	}
		930	else
		931	{
		932	/* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
		933	png_ptr->background_1.red = png_ptr->background_1.green
		934	= png_ptr->background_1.blue = png_ptr->background_1.gray;
		935	png_ptr->background.red = png_ptr->background.green
		936	= png_ptr->background.blue = png_ptr->background.gray;
		937	}
		938	}
		939	}
		940	else
		941	/* transformation does not include PNG_BACKGROUND */
		942	#endif /* PNG_READ_BACKGROUND_SUPPORTED */
		943	if (color_type == PNG_COLOR_TYPE_PALETTE)
		944	{
		945	png_colorp palette = png_ptr->palette;
		946	int num_palette = png_ptr->num_palette;
		947	int i;
		948
		949	for (i = 0; i < num_palette; i++)
		950	{
		951	palette[i].red = png_ptr->gamma_table[palette[i].red];
		952	palette[i].green = png_ptr->gamma_table[palette[i].green];
		953	palette[i].blue = png_ptr->gamma_table[palette[i].blue];
		954	}
		955	}
		956	}
		957	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		958	else
		959	#endif
		960	#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
		961	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		962	/* No GAMMA transformation */
		963	if ((png_ptr->transformations & PNG_BACKGROUND) &&
		964	(color_type == PNG_COLOR_TYPE_PALETTE))
		965	{
		966	int i;
		967	int istop = (int)png_ptr->num_trans;
		968	png_color back;
		969	png_colorp palette = png_ptr->palette;
		970
		971	back.red = (png_byte)png_ptr->background.red;
		972	back.green = (png_byte)png_ptr->background.green;
		973	back.blue = (png_byte)png_ptr->background.blue;
		974
		975	for (i = 0; i < istop; i++)
		976	{
		977	if (png_ptr->trans[i] == 0)
		978	{
		979	palette[i] = back;
		980	}
		981	else if (png_ptr->trans[i] != 0xff)
		982	{
		983	/* The png_composite() macro is defined in png.h */
		984	png_composite(palette[i].red, palette[i].red,
		985	png_ptr->trans[i], back.red);
		986	png_composite(palette[i].green, palette[i].green,
		987	png_ptr->trans[i], back.green);
		988	png_composite(palette[i].blue, palette[i].blue,
		989	png_ptr->trans[i], back.blue);
		990	}
		991	}
		992	}
		993	#endif /* PNG_READ_BACKGROUND_SUPPORTED */
		994
		995	#if defined(PNG_READ_SHIFT_SUPPORTED)
		996	if ((png_ptr->transformations & PNG_SHIFT) &&
		997	(color_type == PNG_COLOR_TYPE_PALETTE))
		998	{
		999	png_uint_16 i;
		1000	png_uint_16 istop = png_ptr->num_palette;
		1001	int sr = 8 - png_ptr->sig_bit.red;
		1002	int sg = 8 - png_ptr->sig_bit.green;
		1003	int sb = 8 - png_ptr->sig_bit.blue;
		1004
		1005	if (sr < 0 \|\| sr > 8)
		1006	sr = 0;
		1007	if (sg < 0 \|\| sg > 8)
		1008	sg = 0;
		1009	if (sb < 0 \|\| sb > 8)
		1010	sb = 0;
		1011	for (i = 0; i < istop; i++)
		1012	{
		1013	png_ptr->palette[i].red >>= sr;
		1014	png_ptr->palette[i].green >>= sg;
		1015	png_ptr->palette[i].blue >>= sb;
		1016	}
		1017	}
		1018	#endif /* PNG_READ_SHIFT_SUPPORTED */
		1019	}
		1020	#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
		1021	&& !defined(PNG_READ_BACKGROUND_SUPPORTED)
		1022	if(png_ptr)
		1023	return;
		1024	#endif
		1025	}
		1026
		1027	/* Modify the info structure to reflect the transformations. The
		1028	* info should be updated so a PNG file could be written with it,
		1029	* assuming the transformations result in valid PNG data.
		1030	*/
		1031	void /* PRIVATE */
		1032	png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
		1033	{
		1034	png_debug(1, "in png_read_transform_info\n");
		1035	#if defined(PNG_READ_EXPAND_SUPPORTED)
		1036	if (png_ptr->transformations & PNG_EXPAND)
		1037	{
		1038	if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		1039	{
		1040	if (png_ptr->num_trans)
		1041	info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
		1042	else
		1043	info_ptr->color_type = PNG_COLOR_TYPE_RGB;
		1044	info_ptr->bit_depth = 8;
		1045	info_ptr->num_trans = 0;
		1046	}
		1047	else
		1048	{
		1049	if (png_ptr->num_trans)
		1050	info_ptr->color_type \|= PNG_COLOR_MASK_ALPHA;
		1051	if (info_ptr->bit_depth < 8)
		1052	info_ptr->bit_depth = 8;
		1053	info_ptr->num_trans = 0;
		1054	}
		1055	}
		1056	#endif
		1057
		1058	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		1059	if (png_ptr->transformations & PNG_BACKGROUND)
		1060	{
		1061	info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
		1062	info_ptr->num_trans = 0;
		1063	info_ptr->background = png_ptr->background;
		1064	}
		1065	#endif
		1066
		1067	#if defined(PNG_READ_GAMMA_SUPPORTED)
		1068	if (png_ptr->transformations & PNG_GAMMA)
		1069	{
		1070	#ifdef PNG_FLOATING_POINT_SUPPORTED
		1071	info_ptr->gamma = png_ptr->gamma;
		1072	#endif
		1073	#ifdef PNG_FIXED_POINT_SUPPORTED
		1074	info_ptr->int_gamma = png_ptr->int_gamma;
		1075	#endif
		1076	}
		1077	#endif
		1078
		1079	#if defined(PNG_READ_16_TO_8_SUPPORTED)
		1080	if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
		1081	info_ptr->bit_depth = 8;
		1082	#endif
		1083
		1084	#if defined(PNG_READ_DITHER_SUPPORTED)
		1085	if (png_ptr->transformations & PNG_DITHER)
		1086	{
		1087	if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) \|\|
		1088	(info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
		1089	png_ptr->palette_lookup && info_ptr->bit_depth == 8)
		1090	{
		1091	info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
		1092	}
		1093	}
		1094	#endif
		1095
		1096	#if defined(PNG_READ_PACK_SUPPORTED)
		1097	if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
		1098	info_ptr->bit_depth = 8;
		1099	#endif
		1100
		1101	#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
		1102	if (png_ptr->transformations & PNG_GRAY_TO_RGB)
		1103	info_ptr->color_type \|= PNG_COLOR_MASK_COLOR;
		1104	#endif
		1105
		1106	#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		1107	if (png_ptr->transformations & PNG_RGB_TO_GRAY)
		1108	info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
		1109	#endif
		1110
		1111	if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		1112	info_ptr->channels = 1;
		1113	else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
		1114	info_ptr->channels = 3;
		1115	else
		1116	info_ptr->channels = 1;
		1117
		1118	#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
		1119	if (png_ptr->transformations & PNG_STRIP_ALPHA)
		1120	info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
		1121	#endif
		1122
		1123	if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
		1124	info_ptr->channels++;
		1125
		1126	#if defined(PNG_READ_FILLER_SUPPORTED)
		1127	/* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
		1128	if ((png_ptr->transformations & PNG_FILLER) &&
		1129	((info_ptr->color_type == PNG_COLOR_TYPE_RGB) \|\|
		1130	(info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
		1131	{
		1132	info_ptr->channels++;
		1133	#if 0 /* if adding a true alpha channel not just filler */
		1134	info_ptr->color_type \|= PNG_COLOR_MASK_ALPHA;
		1135	#endif
		1136	}
		1137	#endif
		1138
		1139	#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
		1140	defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
		1141	if(png_ptr->transformations & PNG_USER_TRANSFORM)
		1142	{
		1143	if(info_ptr->bit_depth < png_ptr->user_transform_depth)
		1144	info_ptr->bit_depth = png_ptr->user_transform_depth;
		1145	if(info_ptr->channels < png_ptr->user_transform_channels)
		1146	info_ptr->channels = png_ptr->user_transform_channels;
		1147	}
		1148	#endif
		1149
		1150	info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
		1151	info_ptr->bit_depth);
		1152	info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3);
		1153
		1154	#if !defined(PNG_READ_EXPAND_SUPPORTED)
		1155	if(png_ptr)
		1156	return;
		1157	#endif
		1158	}
		1159
		1160	/* Transform the row. The order of transformations is significant,
		1161	* and is very touchy. If you add a transformation, take care to
		1162	* decide how it fits in with the other transformations here.
		1163	*/
		1164	void /* PRIVATE */
		1165	png_do_read_transformations(png_structp png_ptr)
		1166	{
		1167	png_debug(1, "in png_do_read_transformations\n");
		1168	#if !defined(PNG_USELESS_TESTS_SUPPORTED)
		1169	if (png_ptr->row_buf == NULL)
		1170	{
		1171	#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
		1172	char msg[50];
		1173
		1174	sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number,
		1175	png_ptr->pass);
		1176	png_error(png_ptr, msg);
		1177	#else
		1178	png_error(png_ptr, "NULL row buffer");
		1179	#endif
		1180	}
		1181	#endif
		1182
		1183	#if defined(PNG_READ_EXPAND_SUPPORTED)
		1184	if (png_ptr->transformations & PNG_EXPAND)
		1185	{
		1186	if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
		1187	{
		1188	png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1189	png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
		1190	}
		1191	else
		1192	{
		1193	if (png_ptr->num_trans)
		1194	png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1195	&(png_ptr->trans_values));
		1196	else
		1197	png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1198	NULL);
		1199	}
		1200	}
		1201	#endif
		1202
		1203	#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
		1204	if (png_ptr->transformations & PNG_STRIP_ALPHA)
		1205	png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1206	PNG_FLAG_FILLER_AFTER);
		1207	#endif
		1208
		1209	#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		1210	if (png_ptr->transformations & PNG_RGB_TO_GRAY)
		1211	{
		1212	int rgb_error =
		1213	png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
		1214	if(rgb_error)
		1215	{
		1216	png_ptr->rgb_to_gray_status=1;
		1217	if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN)
		1218	png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
		1219	if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR)
		1220	png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
		1221	}
		1222	}
		1223	#endif
		1224
		1225	/*
		1226	From Andreas Dilger e-mail to png-implement, 26 March 1998:
		1227
		1228	In most cases, the "simple transparency" should be done prior to doing
		1229	gray-to-RGB, or you will have to test 3x as many bytes to check if a
		1230	pixel is transparent. You would also need to make sure that the
		1231	transparency information is upgraded to RGB.
		1232
		1233	To summarize, the current flow is:
		1234	- Gray + simple transparency -> compare 1 or 2 gray bytes and composite
		1235	with background "in place" if transparent,
		1236	convert to RGB if necessary
		1237	- Gray + alpha -> composite with gray background and remove alpha bytes,
		1238	convert to RGB if necessary
		1239
		1240	To support RGB backgrounds for gray images we need:
		1241	- Gray + simple transparency -> convert to RGB + simple transparency, compare
		1242	3 or 6 bytes and composite with background
		1243	"in place" if transparent (3x compare/pixel
		1244	compared to doing composite with gray bkgrnd)
		1245	- Gray + alpha -> convert to RGB + alpha, composite with background and
		1246	remove alpha bytes (3x float operations/pixel
		1247	compared with composite on gray background)
		1248
		1249	Greg's change will do this. The reason it wasn't done before is for
		1250	performance, as this increases the per-pixel operations. If we would check
		1251	in advance if the background was gray or RGB, and position the gray-to-RGB
		1252	transform appropriately, then it would save a lot of work/time.
		1253	*/
		1254
		1255	#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
		1256	/* if gray -> RGB, do so now only if background is non-gray; else do later
		1257	* for performance reasons */
		1258	if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
		1259	!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
		1260	png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1261	#endif
		1262
		1263	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		1264	if ((png_ptr->transformations & PNG_BACKGROUND) &&
		1265	((png_ptr->num_trans != 0 ) \|\|
		1266	(png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
		1267	png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1268	&(png_ptr->trans_values), &(png_ptr->background)
		1269	#if defined(PNG_READ_GAMMA_SUPPORTED)
		1270	, &(png_ptr->background_1),
		1271	png_ptr->gamma_table, png_ptr->gamma_from_1,
		1272	png_ptr->gamma_to_1, png_ptr->gamma_16_table,
		1273	png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
		1274	png_ptr->gamma_shift
		1275	#endif
		1276	);
		1277	#endif
		1278
		1279	#if defined(PNG_READ_GAMMA_SUPPORTED)
		1280	if ((png_ptr->transformations & PNG_GAMMA) &&
		1281	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		1282	!((png_ptr->transformations & PNG_BACKGROUND) &&
		1283	((png_ptr->num_trans != 0) \|\|
		1284	(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
		1285	#endif
		1286	(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
		1287	png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1288	png_ptr->gamma_table, png_ptr->gamma_16_table,
		1289	png_ptr->gamma_shift);
		1290	#endif
		1291
		1292	#if defined(PNG_READ_16_TO_8_SUPPORTED)
		1293	if (png_ptr->transformations & PNG_16_TO_8)
		1294	png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1295	#endif
		1296
		1297	#if defined(PNG_READ_DITHER_SUPPORTED)
		1298	if (png_ptr->transformations & PNG_DITHER)
		1299	{
		1300	png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
		1301	png_ptr->palette_lookup, png_ptr->dither_index);
		1302	if(png_ptr->row_info.rowbytes == (png_uint_32)0)
		1303	png_error(png_ptr, "png_do_dither returned rowbytes=0");
		1304	}
		1305	#endif
		1306
		1307	#if defined(PNG_READ_INVERT_SUPPORTED)
		1308	if (png_ptr->transformations & PNG_INVERT_MONO)
		1309	png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1310	#endif
		1311
		1312	#if defined(PNG_READ_SHIFT_SUPPORTED)
		1313	if (png_ptr->transformations & PNG_SHIFT)
		1314	png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1315	&(png_ptr->shift));
		1316	#endif
		1317
		1318	#if defined(PNG_READ_PACK_SUPPORTED)
		1319	if (png_ptr->transformations & PNG_PACK)
		1320	png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1321	#endif
		1322
		1323	#if defined(PNG_READ_BGR_SUPPORTED)
		1324	if (png_ptr->transformations & PNG_BGR)
		1325	png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1326	#endif
		1327
		1328	#if defined(PNG_READ_PACKSWAP_SUPPORTED)
		1329	if (png_ptr->transformations & PNG_PACKSWAP)
		1330	png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1331	#endif
		1332
		1333	#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
		1334	/* if gray -> RGB, do so now only if we did not do so above */
		1335	if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
		1336	(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
		1337	png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1338	#endif
		1339
		1340	#if defined(PNG_READ_FILLER_SUPPORTED)
		1341	if (png_ptr->transformations & PNG_FILLER)
		1342	png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
		1343	(png_uint_32)png_ptr->filler, png_ptr->flags);
		1344	#endif
		1345
		1346	#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
		1347	if (png_ptr->transformations & PNG_INVERT_ALPHA)
		1348	png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1349	#endif
		1350
		1351	#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
		1352	if (png_ptr->transformations & PNG_SWAP_ALPHA)
		1353	png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1354	#endif
		1355
		1356	#if defined(PNG_READ_SWAP_SUPPORTED)
		1357	if (png_ptr->transformations & PNG_SWAP_BYTES)
		1358	png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
		1359	#endif
		1360
		1361	#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
		1362	if (png_ptr->transformations & PNG_USER_TRANSFORM)
		1363	{
		1364	if(png_ptr->read_user_transform_fn != NULL)
		1365	((png_ptr->read_user_transform_fn)) / user read transform function */
		1366	(png_ptr, /* png_ptr */
		1367	&(png_ptr->row_info), /* row_info: */
		1368	/* png_uint_32 width; width of row */
		1369	/* png_uint_32 rowbytes; number of bytes in row */
		1370	/* png_byte color_type; color type of pixels */
		1371	/* png_byte bit_depth; bit depth of samples */
		1372	/* png_byte channels; number of channels (1-4) */
		1373	/* png_byte pixel_depth; bits per pixel (depthchannels) /
		1374	png_ptr->row_buf + 1); /* start of pixel data for row */
		1375	#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
		1376	if(png_ptr->user_transform_depth)
		1377	png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
		1378	if(png_ptr->user_transform_channels)
		1379	png_ptr->row_info.channels = png_ptr->user_transform_channels;
		1380	#endif
		1381	png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
		1382	png_ptr->row_info.channels);
		1383	png_ptr->row_info.rowbytes = (png_ptr->row_info.width *
		1384	png_ptr->row_info.pixel_depth+7)>>3;
		1385	}
		1386	#endif
		1387
		1388	}
		1389
		1390	#if defined(PNG_READ_PACK_SUPPORTED)
		1391	/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
		1392	* without changing the actual values. Thus, if you had a row with
		1393	* a bit depth of 1, you would end up with bytes that only contained
		1394	* the numbers 0 or 1. If you would rather they contain 0 and 255, use
		1395	* png_do_shift() after this.
		1396	*/
		1397	void /* PRIVATE */
		1398	png_do_unpack(png_row_infop row_info, png_bytep row)
		1399	{
		1400	png_debug(1, "in png_do_unpack\n");
		1401	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1402	if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
		1403	#else
		1404	if (row_info->bit_depth < 8)
		1405	#endif
		1406	{
		1407	png_uint_32 i;
		1408	png_uint_32 row_width=row_info->width;
		1409
		1410	switch (row_info->bit_depth)
		1411	{
		1412	case 1:
		1413	{
		1414	png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
		1415	png_bytep dp = row + (png_size_t)row_width - 1;
		1416	png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
		1417	for (i = 0; i < row_width; i++)
		1418	{
		1419	dp = (png_byte)((sp >> shift) & 0x01);
		1420	if (shift == 7)
		1421	{
		1422	shift = 0;
		1423	sp--;
		1424	}
		1425	else
		1426	shift++;
		1427
		1428	dp--;
		1429	}
		1430	break;
		1431	}
		1432	case 2:
		1433	{
		1434
		1435	png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
		1436	png_bytep dp = row + (png_size_t)row_width - 1;
		1437	png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
		1438	for (i = 0; i < row_width; i++)
		1439	{
		1440	dp = (png_byte)((sp >> shift) & 0x03);
		1441	if (shift == 6)
		1442	{
		1443	shift = 0;
		1444	sp--;
		1445	}
		1446	else
		1447	shift += 2;
		1448
		1449	dp--;
		1450	}
		1451	break;
		1452	}
		1453	case 4:
		1454	{
		1455	png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
		1456	png_bytep dp = row + (png_size_t)row_width - 1;
		1457	png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
		1458	for (i = 0; i < row_width; i++)
		1459	{
		1460	dp = (png_byte)((sp >> shift) & 0x0f);
		1461	if (shift == 4)
		1462	{
		1463	shift = 0;
		1464	sp--;
		1465	}
		1466	else
		1467	shift = 4;
		1468
		1469	dp--;
		1470	}
		1471	break;
		1472	}
		1473	}
		1474	row_info->bit_depth = 8;
		1475	row_info->pixel_depth = (png_byte)(8 * row_info->channels);
		1476	row_info->rowbytes = row_width * row_info->channels;
		1477	}
		1478	}
		1479	#endif
		1480
		1481	#if defined(PNG_READ_SHIFT_SUPPORTED)
		1482	/* Reverse the effects of png_do_shift. This routine merely shifts the
		1483	* pixels back to their significant bits values. Thus, if you have
		1484	* a row of bit depth 8, but only 5 are significant, this will shift
		1485	* the values back to 0 through 31.
		1486	*/
		1487	void /* PRIVATE */
		1488	png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
		1489	{
		1490	png_debug(1, "in png_do_unshift\n");
		1491	if (
		1492	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1493	row != NULL && row_info != NULL && sig_bits != NULL &&
		1494	#endif
		1495	row_info->color_type != PNG_COLOR_TYPE_PALETTE)
		1496	{
		1497	int shift[4];
		1498	int channels = 0;
		1499	int c;
		1500	png_uint_16 value = 0;
		1501	png_uint_32 row_width = row_info->width;
		1502
		1503	if (row_info->color_type & PNG_COLOR_MASK_COLOR)
		1504	{
		1505	shift[channels++] = row_info->bit_depth - sig_bits->red;
		1506	shift[channels++] = row_info->bit_depth - sig_bits->green;
		1507	shift[channels++] = row_info->bit_depth - sig_bits->blue;
		1508	}
		1509	else
		1510	{
		1511	shift[channels++] = row_info->bit_depth - sig_bits->gray;
		1512	}
		1513	if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
		1514	{
		1515	shift[channels++] = row_info->bit_depth - sig_bits->alpha;
		1516	}
		1517
		1518	for (c = 0; c < channels; c++)
		1519	{
		1520	if (shift[c] <= 0)
		1521	shift[c] = 0;
		1522	else
		1523	value = 1;
		1524	}
		1525
		1526	if (!value)
		1527	return;
		1528
		1529	switch (row_info->bit_depth)
		1530	{
		1531	case 2:
		1532	{
		1533	png_bytep bp;
		1534	png_uint_32 i;
		1535	png_uint_32 istop = row_info->rowbytes;
		1536
		1537	for (bp = row, i = 0; i < istop; i++)
		1538	{
		1539	*bp >>= 1;
		1540	*bp++ &= 0x55;
		1541	}
		1542	break;
		1543	}
		1544	case 4:
		1545	{
		1546	png_bytep bp = row;
		1547	png_uint_32 i;
		1548	png_uint_32 istop = row_info->rowbytes;
		1549	png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) \|
		1550	(png_byte)((int)0xf >> shift[0]));
		1551
		1552	for (i = 0; i < istop; i++)
		1553	{
		1554	*bp >>= shift[0];
		1555	*bp++ &= mask;
		1556	}
		1557	break;
		1558	}
		1559	case 8:
		1560	{
		1561	png_bytep bp = row;
		1562	png_uint_32 i;
		1563	png_uint_32 istop = row_width * channels;
		1564
		1565	for (i = 0; i < istop; i++)
		1566	{
		1567	*bp++ >>= shift[i%channels];
		1568	}
		1569	break;
		1570	}
		1571	case 16:
		1572	{
		1573	png_bytep bp = row;
		1574	png_uint_32 i;
		1575	png_uint_32 istop = channels * row_width;
		1576
		1577	for (i = 0; i < istop; i++)
		1578	{
		1579	value = (png_uint_16)((bp << 8) + (bp + 1));
		1580	value >>= shift[i%channels];
		1581	*bp++ = (png_byte)(value >> 8);
		1582	*bp++ = (png_byte)(value & 0xff);
		1583	}
		1584	break;
		1585	}
		1586	}
		1587	}
		1588	}
		1589	#endif
		1590
		1591	#if defined(PNG_READ_16_TO_8_SUPPORTED)
		1592	/* chop rows of bit depth 16 down to 8 */
		1593	void /* PRIVATE */
		1594	png_do_chop(png_row_infop row_info, png_bytep row)
		1595	{
		1596	png_debug(1, "in png_do_chop\n");
		1597	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1598	if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
		1599	#else
		1600	if (row_info->bit_depth == 16)
		1601	#endif
		1602	{
		1603	png_bytep sp = row;
		1604	png_bytep dp = row;
		1605	png_uint_32 i;
		1606	png_uint_32 istop = row_info->width * row_info->channels;
		1607
		1608	for (i = 0; i<istop; i++, sp += 2, dp++)
		1609	{
		1610	#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
		1611	/* This does a more accurate scaling of the 16-bit color
		1612	* value, rather than a simple low-byte truncation.
		1613	*
		1614	* What the ideal calculation should be:
		1615	* dp = (((((png_uint_32)(sp) << 8) \|
		1616	* (png_uint_32)((sp + 1))) 255 + 127) / (png_uint_32)65535L;
		1617	*
		1618	* GRR: no, I think this is what it really should be:
		1619	* dp = (((((png_uint_32)(sp) << 8) \|
		1620	* (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
		1621	*
		1622	* GRR: here's the exact calculation with shifts:
		1623	* temp = (((png_uint_32)(sp) << 8) \| (png_uint_32)((sp + 1))) + 128L;
		1624	* *dp = (temp - (temp >> 8)) >> 8;
		1625	*
		1626	* Approximate calculation with shift/add instead of multiply/divide:
		1627	* dp = ((((png_uint_32)(sp) << 8) \|
		1628	* (png_uint_32)((int)((sp + 1)) - sp)) + 128) >> 8;
		1629	*
		1630	* What we actually do to avoid extra shifting and conversion:
		1631	*/
		1632
		1633	dp = sp + ((((int)((sp + 1)) - sp) > 128) ? 1 : 0);
		1634	#else
		1635	/* Simply discard the low order byte */
		1636	dp = sp;
		1637	#endif
		1638	}
		1639	row_info->bit_depth = 8;
		1640	row_info->pixel_depth = (png_byte)(8 * row_info->channels);
		1641	row_info->rowbytes = row_info->width * row_info->channels;
		1642	}
		1643	}
		1644	#endif
		1645
		1646	#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
		1647	void /* PRIVATE */
		1648	png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
		1649	{
		1650	png_debug(1, "in png_do_read_swap_alpha\n");
		1651	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1652	if (row != NULL && row_info != NULL)
		1653	#endif
		1654	{
		1655	png_uint_32 row_width = row_info->width;
		1656	if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
		1657	{
		1658	/* This converts from RGBA to ARGB */
		1659	if (row_info->bit_depth == 8)
		1660	{
		1661	png_bytep sp = row + row_info->rowbytes;
		1662	png_bytep dp = sp;
		1663	png_byte save;
		1664	png_uint_32 i;
		1665
		1666	for (i = 0; i < row_width; i++)
		1667	{
		1668	save = *(--sp);
		1669	(--dp) = (--sp);
		1670	(--dp) = (--sp);
		1671	(--dp) = (--sp);
		1672	*(--dp) = save;
		1673	}
		1674	}
		1675	/* This converts from RRGGBBAA to AARRGGBB */
		1676	else
		1677	{
		1678	png_bytep sp = row + row_info->rowbytes;
		1679	png_bytep dp = sp;
		1680	png_byte save[2];
		1681	png_uint_32 i;
		1682
		1683	for (i = 0; i < row_width; i++)
		1684	{
		1685	save[0] = *(--sp);
		1686	save[1] = *(--sp);
		1687	(--dp) = (--sp);
		1688	(--dp) = (--sp);
		1689	(--dp) = (--sp);
		1690	(--dp) = (--sp);
		1691	(--dp) = (--sp);
		1692	(--dp) = (--sp);
		1693	*(--dp) = save[0];
		1694	*(--dp) = save[1];
		1695	}
		1696	}
		1697	}
		1698	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
		1699	{
		1700	/* This converts from GA to AG */
		1701	if (row_info->bit_depth == 8)
		1702	{
		1703	png_bytep sp = row + row_info->rowbytes;
		1704	png_bytep dp = sp;
		1705	png_byte save;
		1706	png_uint_32 i;
		1707
		1708	for (i = 0; i < row_width; i++)
		1709	{
		1710	save = *(--sp);
		1711	(--dp) = (--sp);
		1712	*(--dp) = save;
		1713	}
		1714	}
		1715	/* This converts from GGAA to AAGG */
		1716	else
		1717	{
		1718	png_bytep sp = row + row_info->rowbytes;
		1719	png_bytep dp = sp;
		1720	png_byte save[2];
		1721	png_uint_32 i;
		1722
		1723	for (i = 0; i < row_width; i++)
		1724	{
		1725	save[0] = *(--sp);
		1726	save[1] = *(--sp);
		1727	(--dp) = (--sp);
		1728	(--dp) = (--sp);
		1729	*(--dp) = save[0];
		1730	*(--dp) = save[1];
		1731	}
		1732	}
		1733	}
		1734	}
		1735	}
		1736	#endif
		1737
		1738	#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
		1739	void /* PRIVATE */
		1740	png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
		1741	{
		1742	png_debug(1, "in png_do_read_invert_alpha\n");
		1743	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1744	if (row != NULL && row_info != NULL)
		1745	#endif
		1746	{
		1747	png_uint_32 row_width = row_info->width;
		1748	if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
		1749	{
		1750	/* This inverts the alpha channel in RGBA */
		1751	if (row_info->bit_depth == 8)
		1752	{
		1753	png_bytep sp = row + row_info->rowbytes;
		1754	png_bytep dp = sp;
		1755	png_uint_32 i;
		1756
		1757	for (i = 0; i < row_width; i++)
		1758	{
		1759	(--dp) = (png_byte)(255 - (--sp));
		1760
		1761	/* This does nothing:
		1762	(--dp) = (--sp);
		1763	(--dp) = (--sp);
		1764	(--dp) = (--sp);
		1765	We can replace it with:
		1766	*/
		1767	sp-=3;
		1768	dp=sp;
		1769	}
		1770	}
		1771	/* This inverts the alpha channel in RRGGBBAA */
		1772	else
		1773	{
		1774	png_bytep sp = row + row_info->rowbytes;
		1775	png_bytep dp = sp;
		1776	png_uint_32 i;
		1777
		1778	for (i = 0; i < row_width; i++)
		1779	{
		1780	(--dp) = (png_byte)(255 - (--sp));
		1781	(--dp) = (png_byte)(255 - (--sp));
		1782
		1783	/* This does nothing:
		1784	(--dp) = (--sp);
		1785	(--dp) = (--sp);
		1786	(--dp) = (--sp);
		1787	(--dp) = (--sp);
		1788	(--dp) = (--sp);
		1789	(--dp) = (--sp);
		1790	We can replace it with:
		1791	*/
		1792	sp-=6;
		1793	dp=sp;
		1794	}
		1795	}
		1796	}
		1797	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
		1798	{
		1799	/* This inverts the alpha channel in GA */
		1800	if (row_info->bit_depth == 8)
		1801	{
		1802	png_bytep sp = row + row_info->rowbytes;
		1803	png_bytep dp = sp;
		1804	png_uint_32 i;
		1805
		1806	for (i = 0; i < row_width; i++)
		1807	{
		1808	(--dp) = (png_byte)(255 - (--sp));
		1809	(--dp) = (--sp);
		1810	}
		1811	}
		1812	/* This inverts the alpha channel in GGAA */
		1813	else
		1814	{
		1815	png_bytep sp = row + row_info->rowbytes;
		1816	png_bytep dp = sp;
		1817	png_uint_32 i;
		1818
		1819	for (i = 0; i < row_width; i++)
		1820	{
		1821	(--dp) = (png_byte)(255 - (--sp));
		1822	(--dp) = (png_byte)(255 - (--sp));
		1823	/*
		1824	(--dp) = (--sp);
		1825	(--dp) = (--sp);
		1826	*/
		1827	sp-=2;
		1828	dp=sp;
		1829	}
		1830	}
		1831	}
		1832	}
		1833	}
		1834	#endif
		1835
		1836	#if defined(PNG_READ_FILLER_SUPPORTED)
		1837	/* Add filler channel if we have RGB color */
		1838	void /* PRIVATE */
		1839	png_do_read_filler(png_row_infop row_info, png_bytep row,
		1840	png_uint_32 filler, png_uint_32 flags)
		1841	{
		1842	png_uint_32 i;
		1843	png_uint_32 row_width = row_info->width;
		1844
		1845	png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
		1846	png_byte lo_filler = (png_byte)(filler & 0xff);
		1847
		1848	png_debug(1, "in png_do_read_filler\n");
		1849	if (
		1850	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		1851	row != NULL && row_info != NULL &&
		1852	#endif
		1853	row_info->color_type == PNG_COLOR_TYPE_GRAY)
		1854	{
		1855	if(row_info->bit_depth == 8)
		1856	{
		1857	/* This changes the data from G to GX */
		1858	if (flags & PNG_FLAG_FILLER_AFTER)
		1859	{
		1860	png_bytep sp = row + (png_size_t)row_width;
		1861	png_bytep dp = sp + (png_size_t)row_width;
		1862	for (i = 1; i < row_width; i++)
		1863	{
		1864	*(--dp) = lo_filler;
		1865	(--dp) = (--sp);
		1866	}
		1867	*(--dp) = lo_filler;
		1868	row_info->channels = 2;
		1869	row_info->pixel_depth = 16;
		1870	row_info->rowbytes = row_width * 2;
		1871	}
		1872	/* This changes the data from G to XG */
		1873	else
		1874	{
		1875	png_bytep sp = row + (png_size_t)row_width;
		1876	png_bytep dp = sp + (png_size_t)row_width;
		1877	for (i = 0; i < row_width; i++)
		1878	{
		1879	(--dp) = (--sp);
		1880	*(--dp) = lo_filler;
		1881	}
		1882	row_info->channels = 2;
		1883	row_info->pixel_depth = 16;
		1884	row_info->rowbytes = row_width * 2;
		1885	}
		1886	}
		1887	else if(row_info->bit_depth == 16)
		1888	{
		1889	/* This changes the data from GG to GGXX */
		1890	if (flags & PNG_FLAG_FILLER_AFTER)
		1891	{
		1892	png_bytep sp = row + (png_size_t)row_width;
		1893	png_bytep dp = sp + (png_size_t)row_width;
		1894	for (i = 1; i < row_width; i++)
		1895	{
		1896	*(--dp) = hi_filler;
		1897	*(--dp) = lo_filler;
		1898	(--dp) = (--sp);
		1899	(--dp) = (--sp);
		1900	}
		1901	*(--dp) = hi_filler;
		1902	*(--dp) = lo_filler;
		1903	row_info->channels = 2;
		1904	row_info->pixel_depth = 32;
		1905	row_info->rowbytes = row_width * 4;
		1906	}
		1907	/* This changes the data from GG to XXGG */
		1908	else
		1909	{
		1910	png_bytep sp = row + (png_size_t)row_width;
		1911	png_bytep dp = sp + (png_size_t)row_width;
		1912	for (i = 0; i < row_width; i++)
		1913	{
		1914	(--dp) = (--sp);
		1915	(--dp) = (--sp);
		1916	*(--dp) = hi_filler;
		1917	*(--dp) = lo_filler;
		1918	}
		1919	row_info->channels = 2;
		1920	row_info->pixel_depth = 32;
		1921	row_info->rowbytes = row_width * 4;
		1922	}
		1923	}
		1924	} /* COLOR_TYPE == GRAY */
		1925	else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
		1926	{
		1927	if(row_info->bit_depth == 8)
		1928	{
		1929	/* This changes the data from RGB to RGBX */
		1930	if (flags & PNG_FLAG_FILLER_AFTER)
		1931	{
		1932	png_bytep sp = row + (png_size_t)row_width * 3;
		1933	png_bytep dp = sp + (png_size_t)row_width;
		1934	for (i = 1; i < row_width; i++)
		1935	{
		1936	*(--dp) = lo_filler;
		1937	(--dp) = (--sp);
		1938	(--dp) = (--sp);
		1939	(--dp) = (--sp);
		1940	}
		1941	*(--dp) = lo_filler;
		1942	row_info->channels = 4;
		1943	row_info->pixel_depth = 32;
		1944	row_info->rowbytes = row_width * 4;
		1945	}
		1946	/* This changes the data from RGB to XRGB */
		1947	else
		1948	{
		1949	png_bytep sp = row + (png_size_t)row_width * 3;
		1950	png_bytep dp = sp + (png_size_t)row_width;
		1951	for (i = 0; i < row_width; i++)
		1952	{
		1953	(--dp) = (--sp);
		1954	(--dp) = (--sp);
		1955	(--dp) = (--sp);
		1956	*(--dp) = lo_filler;
		1957	}
		1958	row_info->channels = 4;
		1959	row_info->pixel_depth = 32;
		1960	row_info->rowbytes = row_width * 4;
		1961	}
		1962	}
		1963	else if(row_info->bit_depth == 16)
		1964	{
		1965	/* This changes the data from RRGGBB to RRGGBBXX */
		1966	if (flags & PNG_FLAG_FILLER_AFTER)
		1967	{
		1968	png_bytep sp = row + (png_size_t)row_width * 3;
		1969	png_bytep dp = sp + (png_size_t)row_width;
		1970	for (i = 1; i < row_width; i++)
		1971	{
		1972	*(--dp) = hi_filler;
		1973	*(--dp) = lo_filler;
		1974	(--dp) = (--sp);
		1975	(--dp) = (--sp);
		1976	(--dp) = (--sp);
		1977	(--dp) = (--sp);
		1978	(--dp) = (--sp);
		1979	(--dp) = (--sp);
		1980	}
		1981	*(--dp) = hi_filler;
		1982	*(--dp) = lo_filler;
		1983	row_info->channels = 4;
		1984	row_info->pixel_depth = 64;
		1985	row_info->rowbytes = row_width * 8;
		1986	}
		1987	/* This changes the data from RRGGBB to XXRRGGBB */
		1988	else
		1989	{
		1990	png_bytep sp = row + (png_size_t)row_width * 3;
		1991	png_bytep dp = sp + (png_size_t)row_width;
		1992	for (i = 0; i < row_width; i++)
		1993	{
		1994	(--dp) = (--sp);
		1995	(--dp) = (--sp);
		1996	(--dp) = (--sp);
		1997	(--dp) = (--sp);
		1998	(--dp) = (--sp);
		1999	(--dp) = (--sp);
		2000	*(--dp) = hi_filler;
		2001	*(--dp) = lo_filler;
		2002	}
		2003	row_info->channels = 4;
		2004	row_info->pixel_depth = 64;
		2005	row_info->rowbytes = row_width * 8;
		2006	}
		2007	}
		2008	} /* COLOR_TYPE == RGB */
		2009	}
		2010	#endif
		2011
		2012	#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
		2013	/* expand grayscale files to RGB, with or without alpha */
		2014	void /* PRIVATE */
		2015	png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
		2016	{
		2017	png_uint_32 i;
		2018	png_uint_32 row_width = row_info->width;
		2019
		2020	png_debug(1, "in png_do_gray_to_rgb\n");
		2021	if (row_info->bit_depth >= 8 &&
		2022	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		2023	row != NULL && row_info != NULL &&
		2024	#endif
		2025	!(row_info->color_type & PNG_COLOR_MASK_COLOR))
		2026	{
		2027	if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
		2028	{
		2029	if (row_info->bit_depth == 8)
		2030	{
		2031	png_bytep sp = row + (png_size_t)row_width - 1;
		2032	png_bytep dp = sp + (png_size_t)row_width * 2;
		2033	for (i = 0; i < row_width; i++)
		2034	{
		2035	(dp--) = sp;
		2036	(dp--) = sp;
		2037	(dp--) = (sp--);
		2038	}
		2039	}
		2040	else
		2041	{
		2042	png_bytep sp = row + (png_size_t)row_width * 2 - 1;
		2043	png_bytep dp = sp + (png_size_t)row_width * 4;
		2044	for (i = 0; i < row_width; i++)
		2045	{
		2046	(dp--) = sp;
		2047	(dp--) = (sp - 1);
		2048	(dp--) = sp;
		2049	(dp--) = (sp - 1);
		2050	(dp--) = (sp--);
		2051	(dp--) = (sp--);
		2052	}
		2053	}
		2054	}
		2055	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
		2056	{
		2057	if (row_info->bit_depth == 8)
		2058	{
		2059	png_bytep sp = row + (png_size_t)row_width * 2 - 1;
		2060	png_bytep dp = sp + (png_size_t)row_width * 2;
		2061	for (i = 0; i < row_width; i++)
		2062	{
		2063	(dp--) = (sp--);
		2064	(dp--) = sp;
		2065	(dp--) = sp;
		2066	(dp--) = (sp--);
		2067	}
		2068	}
		2069	else
		2070	{
		2071	png_bytep sp = row + (png_size_t)row_width * 4 - 1;
		2072	png_bytep dp = sp + (png_size_t)row_width * 4;
		2073	for (i = 0; i < row_width; i++)
		2074	{
		2075	(dp--) = (sp--);
		2076	(dp--) = (sp--);
		2077	(dp--) = sp;
		2078	(dp--) = (sp - 1);
		2079	(dp--) = sp;
		2080	(dp--) = (sp - 1);
		2081	(dp--) = (sp--);
		2082	(dp--) = (sp--);
		2083	}
		2084	}
		2085	}
		2086	row_info->channels += (png_byte)2;
		2087	row_info->color_type \|= PNG_COLOR_MASK_COLOR;
		2088	row_info->pixel_depth = (png_byte)(row_info->channels *
		2089	row_info->bit_depth);
		2090	row_info->rowbytes = ((row_width *
		2091	row_info->pixel_depth + 7) >> 3);
		2092	}
		2093	}
		2094	#endif
		2095
		2096	#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		2097	/* reduce RGB files to grayscale, with or without alpha
		2098	* using the equation given in Poynton's ColorFAQ at
		2099	* <http://www.inforamp.net/~poynton/>
		2100	* Copyright (c) 1998-01-04 Charles Poynton poynton@inforamp.net
		2101	*
		2102	* Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
		2103	*
		2104	* We approximate this with
		2105	*
		2106	* Y = 0.21268 * R + 0.7151 * G + 0.07217 * B
		2107	*
		2108	* which can be expressed with integers as
		2109	*
		2110	* Y = (6969 * R + 23434 * G + 2365 * B)/32768
		2111	*
		2112	* The calculation is to be done in a linear colorspace.
		2113	*
		2114	* Other integer coefficents can be used via png_set_rgb_to_gray().
		2115	*/
		2116	int /* PRIVATE */
		2117	png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
		2118
		2119	{
		2120	png_uint_32 i;
		2121
		2122	png_uint_32 row_width = row_info->width;
		2123	int rgb_error = 0;
		2124
		2125	png_debug(1, "in png_do_rgb_to_gray\n");
		2126	if (
		2127	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		2128	row != NULL && row_info != NULL &&
		2129	#endif
		2130	(row_info->color_type & PNG_COLOR_MASK_COLOR))
		2131	{
		2132	png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
		2133	png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
		2134	png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
		2135
		2136	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
		2137	{
		2138	if (row_info->bit_depth == 8)
		2139	{
		2140	#if defined(PNG_READ_GAMMA_SUPPORTED) \|\| defined(PNG_READ_BACKGROUND_SUPPORTED)
		2141	if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
		2142	{
		2143	png_bytep sp = row;
		2144	png_bytep dp = row;
		2145
		2146	for (i = 0; i < row_width; i++)
		2147	{
		2148	png_byte red = png_ptr->gamma_to_1[*(sp++)];
		2149	png_byte green = png_ptr->gamma_to_1[*(sp++)];
		2150	png_byte blue = png_ptr->gamma_to_1[*(sp++)];
		2151	if(red != green \|\| red != blue)
		2152	{
		2153	rgb_error \|= 1;
		2154	*(dp++) = png_ptr->gamma_from_1[
		2155	(rcred+gcgreen+bc*blue)>>15];
		2156	}
		2157	else
		2158	(dp++) = (sp-1);
		2159	}
		2160	}
		2161	else
		2162	#endif
		2163	{
		2164	png_bytep sp = row;
		2165	png_bytep dp = row;
		2166	for (i = 0; i < row_width; i++)
		2167	{
		2168	png_byte red = *(sp++);
		2169	png_byte green = *(sp++);
		2170	png_byte blue = *(sp++);
		2171	if(red != green \|\| red != blue)
		2172	{
		2173	rgb_error \|= 1;
		2174	(dp++) = (png_byte)((rcred+gcgreen+bcblue)>>15);
		2175	}
		2176	else
		2177	(dp++) = (sp-1);
		2178	}
		2179	}
		2180	}
		2181
		2182	else /* RGB bit_depth == 16 */
		2183	{
		2184	#if defined(PNG_READ_GAMMA_SUPPORTED) \|\| defined(PNG_READ_BACKGROUND_SUPPORTED)
		2185	if (png_ptr->gamma_16_to_1 != NULL &&
		2186	png_ptr->gamma_16_from_1 != NULL)
		2187	{
		2188	png_bytep sp = row;
		2189	png_bytep dp = row;
		2190	for (i = 0; i < row_width; i++)
		2191	{
		2192	png_uint_16 red, green, blue, w;
		2193
		2194	red = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2195	green = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2196	blue = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2197
		2198	if(red == green && red == blue)
		2199	w = red;
		2200	else
		2201	{
		2202	png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
		2203	png_ptr->gamma_shift][red>>8];
		2204	png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
		2205	png_ptr->gamma_shift][green>>8];
		2206	png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
		2207	png_ptr->gamma_shift][blue>>8];
		2208	png_uint_16 gray16 = (png_uint_16)((rcred_1 + gcgreen_1
		2209	+ bc*blue_1)>>15);
		2210	w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
		2211	png_ptr->gamma_shift][gray16 >> 8];
		2212	rgb_error \|= 1;
		2213	}
		2214
		2215	*(dp++) = (png_byte)((w>>8) & 0xff);
		2216	*(dp++) = (png_byte)(w & 0xff);
		2217	}
		2218	}
		2219	else
		2220	#endif
		2221	{
		2222	png_bytep sp = row;
		2223	png_bytep dp = row;
		2224	for (i = 0; i < row_width; i++)
		2225	{
		2226	png_uint_16 red, green, blue, gray16;
		2227
		2228	red = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2229	green = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2230	blue = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2231
		2232	if(red != green \|\| red != blue)
		2233	rgb_error \|= 1;
		2234	gray16 = (png_uint_16)((rcred + gcgreen + bc*blue)>>15);
		2235	*(dp++) = (png_byte)((gray16>>8) & 0xff);
		2236	*(dp++) = (png_byte)(gray16 & 0xff);
		2237	}
		2238	}
		2239	}
		2240	}
		2241	if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
		2242	{
		2243	if (row_info->bit_depth == 8)
		2244	{
		2245	#if defined(PNG_READ_GAMMA_SUPPORTED) \|\| defined(PNG_READ_BACKGROUND_SUPPORTED)
		2246	if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
		2247	{
		2248	png_bytep sp = row;
		2249	png_bytep dp = row;
		2250	for (i = 0; i < row_width; i++)
		2251	{
		2252	png_byte red = png_ptr->gamma_to_1[*(sp++)];
		2253	png_byte green = png_ptr->gamma_to_1[*(sp++)];
		2254	png_byte blue = png_ptr->gamma_to_1[*(sp++)];
		2255	if(red != green \|\| red != blue)
		2256	rgb_error \|= 1;
		2257	*(dp++) = png_ptr->gamma_from_1
		2258	[(rcred + gcgreen + bc*blue)>>15];
		2259	(dp++) = (sp++); /* alpha */
		2260	}
		2261	}
		2262	else
		2263	#endif
		2264	{
		2265	png_bytep sp = row;
		2266	png_bytep dp = row;
		2267	for (i = 0; i < row_width; i++)
		2268	{
		2269	png_byte red = *(sp++);
		2270	png_byte green = *(sp++);
		2271	png_byte blue = *(sp++);
		2272	if(red != green \|\| red != blue)
		2273	rgb_error \|= 1;
		2274	(dp++) = (png_byte)((gcred + gcgreen + bcblue)>>8);
		2275	(dp++) = (sp++); /* alpha */
		2276	}
		2277	}
		2278	}
		2279	else /* RGBA bit_depth == 16 */
		2280	{
		2281	#if defined(PNG_READ_GAMMA_SUPPORTED) \|\| defined(PNG_READ_BACKGROUND_SUPPORTED)
		2282	if (png_ptr->gamma_16_to_1 != NULL &&
		2283	png_ptr->gamma_16_from_1 != NULL)
		2284	{
		2285	png_bytep sp = row;
		2286	png_bytep dp = row;
		2287	for (i = 0; i < row_width; i++)
		2288	{
		2289	png_uint_16 red, green, blue, w;
		2290
		2291	red = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2292	green = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2293	blue = (png_uint_16)((((sp))<<8) \| (sp+1)); sp+=2;
		2294
		2295	if(red == green && red == blue)
		2296	w = red;
		2297	else
		2298	{
		2299	png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
		2300	png_ptr->gamma_shift][red>>8];
		2301	png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
		2302	png_ptr->gamma_shift][green>>8];
		2303	png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
		2304	png_ptr->gamma_shift][blue>>8];
		2305	png_uint_16 gray16 = (png_uint_16)((rc * red_1
		2306	+ gc * green_1 + bc * blue_1)>>15);
		2307	w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
		2308	png_ptr->gamma_shift][gray16 >> 8];
		2309	rgb_error \|= 1;
		2310	}
		2311
		2312	*(dp++) = (png_byte)((w>>8) & 0xff);
		2313	*(dp++) = (png_byte)(w & 0xff);
		2314	(dp++) = (sp++); /* alpha */
		2315	(dp++) = (sp++);
		2316	}
		2317	}
		2318	else
		2319	#endif
		2320	{
		2321	png_bytep sp = row;
		2322	png_bytep dp = row;
		2323	for (i = 0; i < row_width; i++)
		2324	{
		2325	png_uint_16 red, green, blue, gray16;
		2326	red = (png_uint_16)(((sp)<<8) \| (sp+1)); sp+=2;
		2327	green = (png_uint_16)(((sp)<<8) \| (sp+1)); sp+=2;
		2328	blue = (png_uint_16)(((sp)<<8) \| (sp+1)); sp+=2;
		2329	if(red != green \|\| red != blue)
		2330	rgb_error \|= 1;
		2331	gray16 = (png_uint_16)((rcred + gcgreen + bc*blue)>>15);
		2332	*(dp++) = (png_byte)((gray16>>8) & 0xff);
		2333	*(dp++) = (png_byte)(gray16 & 0xff);
		2334	(dp++) = (sp++); /* alpha */
		2335	(dp++) = (sp++);
		2336	}
		2337	}
		2338	}
		2339	}
		2340	row_info->channels -= (png_byte)2;
		2341	row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
		2342	row_info->pixel_depth = (png_byte)(row_info->channels *
		2343	row_info->bit_depth);
		2344	row_info->rowbytes = ((row_width *
		2345	row_info->pixel_depth + 7) >> 3);
		2346	}
		2347	return rgb_error;
		2348	}
		2349	#endif
		2350
		2351	/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
		2352	* large of png_color. This lets grayscale images be treated as
		2353	* paletted. Most useful for gamma correction and simplification
		2354	* of code.
		2355	*/
		2356	void PNGAPI
		2357	png_build_grayscale_palette(int bit_depth, png_colorp palette)
		2358	{
		2359	int num_palette;
		2360	int color_inc;
		2361	int i;
		2362	int v;
		2363
		2364	png_debug(1, "in png_do_build_grayscale_palette\n");
		2365	if (palette == NULL)
		2366	return;
		2367
		2368	switch (bit_depth)
		2369	{
		2370	case 1:
		2371	num_palette = 2;
		2372	color_inc = 0xff;
		2373	break;
		2374	case 2:
		2375	num_palette = 4;
		2376	color_inc = 0x55;
		2377	break;
		2378	case 4:
		2379	num_palette = 16;
		2380	color_inc = 0x11;
		2381	break;
		2382	case 8:
		2383	num_palette = 256;
		2384	color_inc = 1;
		2385	break;
		2386	default:
		2387	num_palette = 0;
		2388	color_inc = 0;
		2389	break;
		2390	}
		2391
		2392	for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
		2393	{
		2394	palette[i].red = (png_byte)v;
		2395	palette[i].green = (png_byte)v;
		2396	palette[i].blue = (png_byte)v;
		2397	}
		2398	}
		2399
		2400	/* This function is currently unused. Do we really need it? */
		2401	#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
		2402	void /* PRIVATE */
		2403	png_correct_palette(png_structp png_ptr, png_colorp palette,
		2404	int num_palette)
		2405	{
		2406	png_debug(1, "in png_correct_palette\n");
		2407	#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
		2408	defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
		2409	if (png_ptr->transformations & (PNG_GAMMA \| PNG_BACKGROUND))
		2410	{
		2411	png_color back, back_1;
		2412
		2413	if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
		2414	{
		2415	back.red = png_ptr->gamma_table[png_ptr->background.red];
		2416	back.green = png_ptr->gamma_table[png_ptr->background.green];
		2417	back.blue = png_ptr->gamma_table[png_ptr->background.blue];
		2418
		2419	back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
		2420	back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
		2421	back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
		2422	}
		2423	else
		2424	{
		2425	double g;
		2426
		2427	g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
		2428
		2429	if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN \|\|
		2430	fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
		2431	{
		2432	back.red = png_ptr->background.red;
		2433	back.green = png_ptr->background.green;
		2434	back.blue = png_ptr->background.blue;
		2435	}
		2436	else
		2437	{
		2438	back.red =
		2439	(png_byte)(pow((double)png_ptr->background.red/255, g) *
		2440	255.0 + 0.5);
		2441	back.green =
		2442	(png_byte)(pow((double)png_ptr->background.green/255, g) *
		2443	255.0 + 0.5);
		2444	back.blue =
		2445	(png_byte)(pow((double)png_ptr->background.blue/255, g) *
		2446	255.0 + 0.5);
		2447	}
		2448
		2449	g = 1.0 / png_ptr->background_gamma;
		2450
		2451	back_1.red =
		2452	(png_byte)(pow((double)png_ptr->background.red/255, g) *
		2453	255.0 + 0.5);
		2454	back_1.green =
		2455	(png_byte)(pow((double)png_ptr->background.green/255, g) *
		2456	255.0 + 0.5);
		2457	back_1.blue =
		2458	(png_byte)(pow((double)png_ptr->background.blue/255, g) *
		2459	255.0 + 0.5);
		2460	}
		2461
		2462	if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		2463	{
		2464	png_uint_32 i;
		2465
		2466	for (i = 0; i < (png_uint_32)num_palette; i++)
		2467	{
		2468	if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
		2469	{
		2470	palette[i] = back;
		2471	}
		2472	else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
		2473	{
		2474	png_byte v, w;
		2475
		2476	v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
		2477	png_composite(w, v, png_ptr->trans[i], back_1.red);
		2478	palette[i].red = png_ptr->gamma_from_1[w];
		2479
		2480	v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
		2481	png_composite(w, v, png_ptr->trans[i], back_1.green);
		2482	palette[i].green = png_ptr->gamma_from_1[w];
		2483
		2484	v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
		2485	png_composite(w, v, png_ptr->trans[i], back_1.blue);
		2486	palette[i].blue = png_ptr->gamma_from_1[w];
		2487	}
		2488	else
		2489	{
		2490	palette[i].red = png_ptr->gamma_table[palette[i].red];
		2491	palette[i].green = png_ptr->gamma_table[palette[i].green];
		2492	palette[i].blue = png_ptr->gamma_table[palette[i].blue];
		2493	}
		2494	}
		2495	}
		2496	else
		2497	{
		2498	int i;
		2499
		2500	for (i = 0; i < num_palette; i++)
		2501	{
		2502	if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
		2503	{
		2504	palette[i] = back;
		2505	}
		2506	else
		2507	{
		2508	palette[i].red = png_ptr->gamma_table[palette[i].red];
		2509	palette[i].green = png_ptr->gamma_table[palette[i].green];
		2510	palette[i].blue = png_ptr->gamma_table[palette[i].blue];
		2511	}
		2512	}
		2513	}
		2514	}
		2515	else
		2516	#endif
		2517	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2518	if (png_ptr->transformations & PNG_GAMMA)
		2519	{
		2520	int i;
		2521
		2522	for (i = 0; i < num_palette; i++)
		2523	{
		2524	palette[i].red = png_ptr->gamma_table[palette[i].red];
		2525	palette[i].green = png_ptr->gamma_table[palette[i].green];
		2526	palette[i].blue = png_ptr->gamma_table[palette[i].blue];
		2527	}
		2528	}
		2529	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		2530	else
		2531	#endif
		2532	#endif
		2533	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		2534	if (png_ptr->transformations & PNG_BACKGROUND)
		2535	{
		2536	if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		2537	{
		2538	png_color back;
		2539
		2540	back.red = (png_byte)png_ptr->background.red;
		2541	back.green = (png_byte)png_ptr->background.green;
		2542	back.blue = (png_byte)png_ptr->background.blue;
		2543
		2544	for (i = 0; i < (int)png_ptr->num_trans; i++)
		2545	{
		2546	if (png_ptr->trans[i] == 0)
		2547	{
		2548	palette[i].red = back.red;
		2549	palette[i].green = back.green;
		2550	palette[i].blue = back.blue;
		2551	}
		2552	else if (png_ptr->trans[i] != 0xff)
		2553	{
		2554	png_composite(palette[i].red, png_ptr->palette[i].red,
		2555	png_ptr->trans[i], back.red);
		2556	png_composite(palette[i].green, png_ptr->palette[i].green,
		2557	png_ptr->trans[i], back.green);
		2558	png_composite(palette[i].blue, png_ptr->palette[i].blue,
		2559	png_ptr->trans[i], back.blue);
		2560	}
		2561	}
		2562	}
		2563	else /* assume grayscale palette (what else could it be?) */
		2564	{
		2565	int i;
		2566
		2567	for (i = 0; i < num_palette; i++)
		2568	{
		2569	if (i == (png_byte)png_ptr->trans_values.gray)
		2570	{
		2571	palette[i].red = (png_byte)png_ptr->background.red;
		2572	palette[i].green = (png_byte)png_ptr->background.green;
		2573	palette[i].blue = (png_byte)png_ptr->background.blue;
		2574	}
		2575	}
		2576	}
		2577	}
		2578	#endif
		2579	}
		2580	#endif
		2581
		2582	#if defined(PNG_READ_BACKGROUND_SUPPORTED)
		2583	/* Replace any alpha or transparency with the supplied background color.
		2584	* "background" is already in the screen gamma, while "background_1" is
		2585	* at a gamma of 1.0. Paletted files have already been taken care of.
		2586	*/
		2587	void /* PRIVATE */
		2588	png_do_background(png_row_infop row_info, png_bytep row,
		2589	png_color_16p trans_values, png_color_16p background
		2590	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2591	, png_color_16p background_1,
		2592	png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
		2593	png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
		2594	png_uint_16pp gamma_16_to_1, int gamma_shift
		2595	#endif
		2596	)
		2597	{
		2598	png_bytep sp, dp;
		2599	png_uint_32 i;
		2600	png_uint_32 row_width=row_info->width;
		2601	int shift;
		2602
		2603	png_debug(1, "in png_do_background\n");
		2604	if (background != NULL &&
		2605	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		2606	row != NULL && row_info != NULL &&
		2607	#endif
		2608	(!(row_info->color_type & PNG_COLOR_MASK_ALPHA) \|\|
		2609	(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
		2610	{
		2611	switch (row_info->color_type)
		2612	{
		2613	case PNG_COLOR_TYPE_GRAY:
		2614	{
		2615	switch (row_info->bit_depth)
		2616	{
		2617	case 1:
		2618	{
		2619	sp = row;
		2620	shift = 7;
		2621	for (i = 0; i < row_width; i++)
		2622	{
		2623	if ((png_uint_16)((*sp >> shift) & 0x01)
		2624	== trans_values->gray)
		2625	{
		2626	*sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
		2627	*sp \|= (png_byte)(background->gray << shift);
		2628	}
		2629	if (!shift)
		2630	{
		2631	shift = 7;
		2632	sp++;
		2633	}
		2634	else
		2635	shift--;
		2636	}
		2637	break;
		2638	}
		2639	case 2:
		2640	{
		2641	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2642	if (gamma_table != NULL)
		2643	{
		2644	sp = row;
		2645	shift = 6;
		2646	for (i = 0; i < row_width; i++)
		2647	{
		2648	if ((png_uint_16)((*sp >> shift) & 0x03)
		2649	== trans_values->gray)
		2650	{
		2651	*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
		2652	*sp \|= (png_byte)(background->gray << shift);
		2653	}
		2654	else
		2655	{
		2656	png_byte p = (png_byte)((*sp >> shift) & 0x03);
		2657	png_byte g = (png_byte)((gamma_table [p \| (p << 2) \|
		2658	(p << 4) \| (p << 6)] >> 6) & 0x03);
		2659	*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
		2660	*sp \|= (png_byte)(g << shift);
		2661	}
		2662	if (!shift)
		2663	{
		2664	shift = 6;
		2665	sp++;
		2666	}
		2667	else
		2668	shift -= 2;
		2669	}
		2670	}
		2671	else
		2672	#endif
		2673	{
		2674	sp = row;
		2675	shift = 6;
		2676	for (i = 0; i < row_width; i++)
		2677	{
		2678	if ((png_uint_16)((*sp >> shift) & 0x03)
		2679	== trans_values->gray)
		2680	{
		2681	*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
		2682	*sp \|= (png_byte)(background->gray << shift);
		2683	}
		2684	if (!shift)
		2685	{
		2686	shift = 6;
		2687	sp++;
		2688	}
		2689	else
		2690	shift -= 2;
		2691	}
		2692	}
		2693	break;
		2694	}
		2695	case 4:
		2696	{
		2697	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2698	if (gamma_table != NULL)
		2699	{
		2700	sp = row;
		2701	shift = 4;
		2702	for (i = 0; i < row_width; i++)
		2703	{
		2704	if ((png_uint_16)((*sp >> shift) & 0x0f)
		2705	== trans_values->gray)
		2706	{
		2707	*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
		2708	*sp \|= (png_byte)(background->gray << shift);
		2709	}
		2710	else
		2711	{
		2712	png_byte p = (png_byte)((*sp >> shift) & 0x0f);
		2713	png_byte g = (png_byte)((gamma_table[p \|
		2714	(p << 4)] >> 4) & 0x0f);
		2715	*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
		2716	*sp \|= (png_byte)(g << shift);
		2717	}
		2718	if (!shift)
		2719	{
		2720	shift = 4;
		2721	sp++;
		2722	}
		2723	else
		2724	shift -= 4;
		2725	}
		2726	}
		2727	else
		2728	#endif
		2729	{
		2730	sp = row;
		2731	shift = 4;
		2732	for (i = 0; i < row_width; i++)
		2733	{
		2734	if ((png_uint_16)((*sp >> shift) & 0x0f)
		2735	== trans_values->gray)
		2736	{
		2737	*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
		2738	*sp \|= (png_byte)(background->gray << shift);
		2739	}
		2740	if (!shift)
		2741	{
		2742	shift = 4;
		2743	sp++;
		2744	}
		2745	else
		2746	shift -= 4;
		2747	}
		2748	}
		2749	break;
		2750	}
		2751	case 8:
		2752	{
		2753	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2754	if (gamma_table != NULL)
		2755	{
		2756	sp = row;
		2757	for (i = 0; i < row_width; i++, sp++)
		2758	{
		2759	if (*sp == trans_values->gray)
		2760	{
		2761	*sp = (png_byte)background->gray;
		2762	}
		2763	else
		2764	{
		2765	sp = gamma_table[sp];
		2766	}
		2767	}
		2768	}
		2769	else
		2770	#endif
		2771	{
		2772	sp = row;
		2773	for (i = 0; i < row_width; i++, sp++)
		2774	{
		2775	if (*sp == trans_values->gray)
		2776	{
		2777	*sp = (png_byte)background->gray;
		2778	}
		2779	}
		2780	}
		2781	break;
		2782	}
		2783	case 16:
		2784	{
		2785	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2786	if (gamma_16 != NULL)
		2787	{
		2788	sp = row;
		2789	for (i = 0; i < row_width; i++, sp += 2)
		2790	{
		2791	png_uint_16 v;
		2792
		2793	v = (png_uint_16)(((sp) << 8) + (sp + 1));
		2794	if (v == trans_values->gray)
		2795	{
		2796	/* background is already in screen gamma */
		2797	*sp = (png_byte)((background->gray >> 8) & 0xff);
		2798	*(sp + 1) = (png_byte)(background->gray & 0xff);
		2799	}
		2800	else
		2801	{
		2802	v = gamma_16[(sp + 1) >> gamma_shift][sp];
		2803	*sp = (png_byte)((v >> 8) & 0xff);
		2804	*(sp + 1) = (png_byte)(v & 0xff);
		2805	}
		2806	}
		2807	}
		2808	else
		2809	#endif
		2810	{
		2811	sp = row;
		2812	for (i = 0; i < row_width; i++, sp += 2)
		2813	{
		2814	png_uint_16 v;
		2815
		2816	v = (png_uint_16)(((sp) << 8) + (sp + 1));
		2817	if (v == trans_values->gray)
		2818	{
		2819	*sp = (png_byte)((background->gray >> 8) & 0xff);
		2820	*(sp + 1) = (png_byte)(background->gray & 0xff);
		2821	}
		2822	}
		2823	}
		2824	break;
		2825	}
		2826	}
		2827	break;
		2828	}
		2829	case PNG_COLOR_TYPE_RGB:
		2830	{
		2831	if (row_info->bit_depth == 8)
		2832	{
		2833	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2834	if (gamma_table != NULL)
		2835	{
		2836	sp = row;
		2837	for (i = 0; i < row_width; i++, sp += 3)
		2838	{
		2839	if (*sp == trans_values->red &&
		2840	*(sp + 1) == trans_values->green &&
		2841	*(sp + 2) == trans_values->blue)
		2842	{
		2843	*sp = (png_byte)background->red;
		2844	*(sp + 1) = (png_byte)background->green;
		2845	*(sp + 2) = (png_byte)background->blue;
		2846	}
		2847	else
		2848	{
		2849	sp = gamma_table[sp];
		2850	(sp + 1) = gamma_table[(sp + 1)];
		2851	(sp + 2) = gamma_table[(sp + 2)];
		2852	}
		2853	}
		2854	}
		2855	else
		2856	#endif
		2857	{
		2858	sp = row;
		2859	for (i = 0; i < row_width; i++, sp += 3)
		2860	{
		2861	if (*sp == trans_values->red &&
		2862	*(sp + 1) == trans_values->green &&
		2863	*(sp + 2) == trans_values->blue)
		2864	{
		2865	*sp = (png_byte)background->red;
		2866	*(sp + 1) = (png_byte)background->green;
		2867	*(sp + 2) = (png_byte)background->blue;
		2868	}
		2869	}
		2870	}
		2871	}
		2872	else /* if (row_info->bit_depth == 16) */
		2873	{
		2874	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2875	if (gamma_16 != NULL)
		2876	{
		2877	sp = row;
		2878	for (i = 0; i < row_width; i++, sp += 6)
		2879	{
		2880	png_uint_16 r = (png_uint_16)(((sp) << 8) + (sp + 1));
		2881	png_uint_16 g = (png_uint_16)((((sp+2)) << 8) + (sp+3));
		2882	png_uint_16 b = (png_uint_16)((((sp+4)) << 8) + (sp+5));
		2883	if (r == trans_values->red && g == trans_values->green &&
		2884	b == trans_values->blue)
		2885	{
		2886	/* background is already in screen gamma */
		2887	*sp = (png_byte)((background->red >> 8) & 0xff);
		2888	*(sp + 1) = (png_byte)(background->red & 0xff);
		2889	*(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
		2890	*(sp + 3) = (png_byte)(background->green & 0xff);
		2891	*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
		2892	*(sp + 5) = (png_byte)(background->blue & 0xff);
		2893	}
		2894	else
		2895	{
		2896	png_uint_16 v = gamma_16[(sp + 1) >> gamma_shift][sp];
		2897	*sp = (png_byte)((v >> 8) & 0xff);
		2898	*(sp + 1) = (png_byte)(v & 0xff);
		2899	v = gamma_16[(sp + 3) >> gamma_shift][(sp + 2)];
		2900	*(sp + 2) = (png_byte)((v >> 8) & 0xff);
		2901	*(sp + 3) = (png_byte)(v & 0xff);
		2902	v = gamma_16[(sp + 5) >> gamma_shift][(sp + 4)];
		2903	*(sp + 4) = (png_byte)((v >> 8) & 0xff);
		2904	*(sp + 5) = (png_byte)(v & 0xff);
		2905	}
		2906	}
		2907	}
		2908	else
		2909	#endif
		2910	{
		2911	sp = row;
		2912	for (i = 0; i < row_width; i++, sp += 6)
		2913	{
		2914	png_uint_16 r = (png_uint_16)(((sp) << 8) + (sp+1));
		2915	png_uint_16 g = (png_uint_16)((((sp+2)) << 8) + (sp+3));
		2916	png_uint_16 b = (png_uint_16)((((sp+4)) << 8) + (sp+5));
		2917
		2918	if (r == trans_values->red && g == trans_values->green &&
		2919	b == trans_values->blue)
		2920	{
		2921	*sp = (png_byte)((background->red >> 8) & 0xff);
		2922	*(sp + 1) = (png_byte)(background->red & 0xff);
		2923	*(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
		2924	*(sp + 3) = (png_byte)(background->green & 0xff);
		2925	*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
		2926	*(sp + 5) = (png_byte)(background->blue & 0xff);
		2927	}
		2928	}
		2929	}
		2930	}
		2931	break;
		2932	}
		2933	case PNG_COLOR_TYPE_GRAY_ALPHA:
		2934	{
		2935	if (row_info->bit_depth == 8)
		2936	{
		2937	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2938	if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
		2939	gamma_table != NULL)
		2940	{
		2941	sp = row;
		2942	dp = row;
		2943	for (i = 0; i < row_width; i++, sp += 2, dp++)
		2944	{
		2945	png_uint_16 a = *(sp + 1);
		2946
		2947	if (a == 0xff)
		2948	{
		2949	dp = gamma_table[sp];
		2950	}
		2951	else if (a == 0)
		2952	{
		2953	/* background is already in screen gamma */
		2954	*dp = (png_byte)background->gray;
		2955	}
		2956	else
		2957	{
		2958	png_byte v, w;
		2959
		2960	v = gamma_to_1[*sp];
		2961	png_composite(w, v, a, background_1->gray);
		2962	*dp = gamma_from_1[w];
		2963	}
		2964	}
		2965	}
		2966	else
		2967	#endif
		2968	{
		2969	sp = row;
		2970	dp = row;
		2971	for (i = 0; i < row_width; i++, sp += 2, dp++)
		2972	{
		2973	png_byte a = *(sp + 1);
		2974
		2975	if (a == 0xff)
		2976	{
		2977	dp = sp;
		2978	}
		2979	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2980	else if (a == 0)
		2981	{
		2982	*dp = (png_byte)background->gray;
		2983	}
		2984	else
		2985	{
		2986	png_composite(dp, sp, a, background_1->gray);
		2987	}
		2988	#else
		2989	*dp = (png_byte)background->gray;
		2990	#endif
		2991	}
		2992	}
		2993	}
		2994	else /* if (png_ptr->bit_depth == 16) */
		2995	{
		2996	#if defined(PNG_READ_GAMMA_SUPPORTED)
		2997	if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
		2998	gamma_16_to_1 != NULL)
		2999	{
		3000	sp = row;
		3001	dp = row;
		3002	for (i = 0; i < row_width; i++, sp += 4, dp += 2)
		3003	{
		3004	png_uint_16 a = (png_uint_16)((((sp+2)) << 8) + (sp+3));
		3005
		3006	if (a == (png_uint_16)0xffff)
		3007	{
		3008	png_uint_16 v;
		3009
		3010	v = gamma_16[(sp + 1) >> gamma_shift][sp];
		3011	*dp = (png_byte)((v >> 8) & 0xff);
		3012	*(dp + 1) = (png_byte)(v & 0xff);
		3013	}
		3014	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3015	else if (a == 0)
		3016	#else
		3017	else
		3018	#endif
		3019	{
		3020	/* background is already in screen gamma */
		3021	*dp = (png_byte)((background->gray >> 8) & 0xff);
		3022	*(dp + 1) = (png_byte)(background->gray & 0xff);
		3023	}
		3024	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3025	else
		3026	{
		3027	png_uint_16 g, v, w;
		3028
		3029	g = gamma_16_to_1[(sp + 1) >> gamma_shift][sp];
		3030	png_composite_16(v, g, a, background_1->gray);
		3031	w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
		3032	*dp = (png_byte)((w >> 8) & 0xff);
		3033	*(dp + 1) = (png_byte)(w & 0xff);
		3034	}
		3035	#endif
		3036	}
		3037	}
		3038	else
		3039	#endif
		3040	{
		3041	sp = row;
		3042	dp = row;
		3043	for (i = 0; i < row_width; i++, sp += 4, dp += 2)
		3044	{
		3045	png_uint_16 a = (png_uint_16)((((sp+2)) << 8) + (sp+3));
		3046	if (a == (png_uint_16)0xffff)
		3047	{
		3048	png_memcpy(dp, sp, 2);
		3049	}
		3050	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3051	else if (a == 0)
		3052	#else
		3053	else
		3054	#endif
		3055	{
		3056	*dp = (png_byte)((background->gray >> 8) & 0xff);
		3057	*(dp + 1) = (png_byte)(background->gray & 0xff);
		3058	}
		3059	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3060	else
		3061	{
		3062	png_uint_16 g, v;
		3063
		3064	g = (png_uint_16)(((sp) << 8) + (sp + 1));
		3065	png_composite_16(v, g, a, background_1->gray);
		3066	*dp = (png_byte)((v >> 8) & 0xff);
		3067	*(dp + 1) = (png_byte)(v & 0xff);
		3068	}
		3069	#endif
		3070	}
		3071	}
		3072	}
		3073	break;
		3074	}
		3075	case PNG_COLOR_TYPE_RGB_ALPHA:
		3076	{
		3077	if (row_info->bit_depth == 8)
		3078	{
		3079	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3080	if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
		3081	gamma_table != NULL)
		3082	{
		3083	sp = row;
		3084	dp = row;
		3085	for (i = 0; i < row_width; i++, sp += 4, dp += 3)
		3086	{
		3087	png_byte a = *(sp + 3);
		3088
		3089	if (a == 0xff)
		3090	{
		3091	dp = gamma_table[sp];
		3092	(dp + 1) = gamma_table[(sp + 1)];
		3093	(dp + 2) = gamma_table[(sp + 2)];
		3094	}
		3095	else if (a == 0)
		3096	{
		3097	/* background is already in screen gamma */
		3098	*dp = (png_byte)background->red;
		3099	*(dp + 1) = (png_byte)background->green;
		3100	*(dp + 2) = (png_byte)background->blue;
		3101	}
		3102	else
		3103	{
		3104	png_byte v, w;
		3105
		3106	v = gamma_to_1[*sp];
		3107	png_composite(w, v, a, background_1->red);
		3108	*dp = gamma_from_1[w];
		3109	v = gamma_to_1[*(sp + 1)];
		3110	png_composite(w, v, a, background_1->green);
		3111	*(dp + 1) = gamma_from_1[w];
		3112	v = gamma_to_1[*(sp + 2)];
		3113	png_composite(w, v, a, background_1->blue);
		3114	*(dp + 2) = gamma_from_1[w];
		3115	}
		3116	}
		3117	}
		3118	else
		3119	#endif
		3120	{
		3121	sp = row;
		3122	dp = row;
		3123	for (i = 0; i < row_width; i++, sp += 4, dp += 3)
		3124	{
		3125	png_byte a = *(sp + 3);
		3126
		3127	if (a == 0xff)
		3128	{
		3129	dp = sp;
		3130	(dp + 1) = (sp + 1);
		3131	(dp + 2) = (sp + 2);
		3132	}
		3133	else if (a == 0)
		3134	{
		3135	*dp = (png_byte)background->red;
		3136	*(dp + 1) = (png_byte)background->green;
		3137	*(dp + 2) = (png_byte)background->blue;
		3138	}
		3139	else
		3140	{
		3141	png_composite(dp, sp, a, background->red);
		3142	png_composite((dp + 1), (sp + 1), a,
		3143	background->green);
		3144	png_composite((dp + 2), (sp + 2), a,
		3145	background->blue);
		3146	}
		3147	}
		3148	}
		3149	}
		3150	else /* if (row_info->bit_depth == 16) */
		3151	{
		3152	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3153	if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
		3154	gamma_16_to_1 != NULL)
		3155	{
		3156	sp = row;
		3157	dp = row;
		3158	for (i = 0; i < row_width; i++, sp += 8, dp += 6)
		3159	{
		3160	png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
		3161	<< 8) + (png_uint_16)(*(sp + 7)));
		3162	if (a == (png_uint_16)0xffff)
		3163	{
		3164	png_uint_16 v;
		3165
		3166	v = gamma_16[(sp + 1) >> gamma_shift][sp];
		3167	*dp = (png_byte)((v >> 8) & 0xff);
		3168	*(dp + 1) = (png_byte)(v & 0xff);
		3169	v = gamma_16[(sp + 3) >> gamma_shift][(sp + 2)];
		3170	*(dp + 2) = (png_byte)((v >> 8) & 0xff);
		3171	*(dp + 3) = (png_byte)(v & 0xff);
		3172	v = gamma_16[(sp + 5) >> gamma_shift][(sp + 4)];
		3173	*(dp + 4) = (png_byte)((v >> 8) & 0xff);
		3174	*(dp + 5) = (png_byte)(v & 0xff);
		3175	}
		3176	else if (a == 0)
		3177	{
		3178	/* background is already in screen gamma */
		3179	*dp = (png_byte)((background->red >> 8) & 0xff);
		3180	*(dp + 1) = (png_byte)(background->red & 0xff);
		3181	*(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
		3182	*(dp + 3) = (png_byte)(background->green & 0xff);
		3183	*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
		3184	*(dp + 5) = (png_byte)(background->blue & 0xff);
		3185	}
		3186	else
		3187	{
		3188	png_uint_16 v, w, x;
		3189
		3190	v = gamma_16_to_1[(sp + 1) >> gamma_shift][sp];
		3191	png_composite_16(w, v, a, background_1->red);
		3192	x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
		3193	*dp = (png_byte)((x >> 8) & 0xff);
		3194	*(dp + 1) = (png_byte)(x & 0xff);
		3195	v = gamma_16_to_1[(sp + 3) >> gamma_shift][(sp + 2)];
		3196	png_composite_16(w, v, a, background_1->green);
		3197	x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
		3198	*(dp + 2) = (png_byte)((x >> 8) & 0xff);
		3199	*(dp + 3) = (png_byte)(x & 0xff);
		3200	v = gamma_16_to_1[(sp + 5) >> gamma_shift][(sp + 4)];
		3201	png_composite_16(w, v, a, background_1->blue);
		3202	x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
		3203	*(dp + 4) = (png_byte)((x >> 8) & 0xff);
		3204	*(dp + 5) = (png_byte)(x & 0xff);
		3205	}
		3206	}
		3207	}
		3208	else
		3209	#endif
		3210	{
		3211	sp = row;
		3212	dp = row;
		3213	for (i = 0; i < row_width; i++, sp += 8, dp += 6)
		3214	{
		3215	png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
		3216	<< 8) + (png_uint_16)(*(sp + 7)));
		3217	if (a == (png_uint_16)0xffff)
		3218	{
		3219	png_memcpy(dp, sp, 6);
		3220	}
		3221	else if (a == 0)
		3222	{
		3223	*dp = (png_byte)((background->red >> 8) & 0xff);
		3224	*(dp + 1) = (png_byte)(background->red & 0xff);
		3225	*(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
		3226	*(dp + 3) = (png_byte)(background->green & 0xff);
		3227	*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
		3228	*(dp + 5) = (png_byte)(background->blue & 0xff);
		3229	}
		3230	else
		3231	{
		3232	png_uint_16 v;
		3233
		3234	png_uint_16 r = (png_uint_16)(((sp) << 8) + (sp + 1));
		3235	png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
		3236	+ *(sp + 3));
		3237	png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
		3238	+ *(sp + 5));
		3239
		3240	png_composite_16(v, r, a, background->red);
		3241	*dp = (png_byte)((v >> 8) & 0xff);
		3242	*(dp + 1) = (png_byte)(v & 0xff);
		3243	png_composite_16(v, g, a, background->green);
		3244	*(dp + 2) = (png_byte)((v >> 8) & 0xff);
		3245	*(dp + 3) = (png_byte)(v & 0xff);
		3246	png_composite_16(v, b, a, background->blue);
		3247	*(dp + 4) = (png_byte)((v >> 8) & 0xff);
		3248	*(dp + 5) = (png_byte)(v & 0xff);
		3249	}
		3250	}
		3251	}
		3252	}
		3253	break;
		3254	}
		3255	}
		3256
		3257	if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
		3258	{
		3259	row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
		3260	row_info->channels--;
		3261	row_info->pixel_depth = (png_byte)(row_info->channels *
		3262	row_info->bit_depth);
		3263	row_info->rowbytes = ((row_width *
		3264	row_info->pixel_depth + 7) >> 3);
		3265	}
		3266	}
		3267	}
		3268	#endif
		3269
		3270	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3271	/* Gamma correct the image, avoiding the alpha channel. Make sure
		3272	* you do this after you deal with the transparency issue on grayscale
		3273	* or RGB images. If your bit depth is 8, use gamma_table, if it
		3274	* is 16, use gamma_16_table and gamma_shift. Build these with
		3275	* build_gamma_table().
		3276	*/
		3277	void /* PRIVATE */
		3278	png_do_gamma(png_row_infop row_info, png_bytep row,
		3279	png_bytep gamma_table, png_uint_16pp gamma_16_table,
		3280	int gamma_shift)
		3281	{
		3282	png_bytep sp;
		3283	png_uint_32 i;
		3284	png_uint_32 row_width=row_info->width;
		3285
		3286	png_debug(1, "in png_do_gamma\n");
		3287	if (
		3288	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		3289	row != NULL && row_info != NULL &&
		3290	#endif
		3291	((row_info->bit_depth <= 8 && gamma_table != NULL) \|\|
		3292	(row_info->bit_depth == 16 && gamma_16_table != NULL)))
		3293	{
		3294	switch (row_info->color_type)
		3295	{
		3296	case PNG_COLOR_TYPE_RGB:
		3297	{
		3298	if (row_info->bit_depth == 8)
		3299	{
		3300	sp = row;
		3301	for (i = 0; i < row_width; i++)
		3302	{
		3303	sp = gamma_table[sp];
		3304	sp++;
		3305	sp = gamma_table[sp];
		3306	sp++;
		3307	sp = gamma_table[sp];
		3308	sp++;
		3309	}
		3310	}
		3311	else /* if (row_info->bit_depth == 16) */
		3312	{
		3313	sp = row;
		3314	for (i = 0; i < row_width; i++)
		3315	{
		3316	png_uint_16 v;
		3317
		3318	v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3319	*sp = (png_byte)((v >> 8) & 0xff);
		3320	*(sp + 1) = (png_byte)(v & 0xff);
		3321	sp += 2;
		3322	v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3323	*sp = (png_byte)((v >> 8) & 0xff);
		3324	*(sp + 1) = (png_byte)(v & 0xff);
		3325	sp += 2;
		3326	v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3327	*sp = (png_byte)((v >> 8) & 0xff);
		3328	*(sp + 1) = (png_byte)(v & 0xff);
		3329	sp += 2;
		3330	}
		3331	}
		3332	break;
		3333	}
		3334	case PNG_COLOR_TYPE_RGB_ALPHA:
		3335	{
		3336	if (row_info->bit_depth == 8)
		3337	{
		3338	sp = row;
		3339	for (i = 0; i < row_width; i++)
		3340	{
		3341	sp = gamma_table[sp];
		3342	sp++;
		3343	sp = gamma_table[sp];
		3344	sp++;
		3345	sp = gamma_table[sp];
		3346	sp++;
		3347	sp++;
		3348	}
		3349	}
		3350	else /* if (row_info->bit_depth == 16) */
		3351	{
		3352	sp = row;
		3353	for (i = 0; i < row_width; i++)
		3354	{
		3355	png_uint_16 v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3356	*sp = (png_byte)((v >> 8) & 0xff);
		3357	*(sp + 1) = (png_byte)(v & 0xff);
		3358	sp += 2;
		3359	v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3360	*sp = (png_byte)((v >> 8) & 0xff);
		3361	*(sp + 1) = (png_byte)(v & 0xff);
		3362	sp += 2;
		3363	v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3364	*sp = (png_byte)((v >> 8) & 0xff);
		3365	*(sp + 1) = (png_byte)(v & 0xff);
		3366	sp += 4;
		3367	}
		3368	}
		3369	break;
		3370	}
		3371	case PNG_COLOR_TYPE_GRAY_ALPHA:
		3372	{
		3373	if (row_info->bit_depth == 8)
		3374	{
		3375	sp = row;
		3376	for (i = 0; i < row_width; i++)
		3377	{
		3378	sp = gamma_table[sp];
		3379	sp += 2;
		3380	}
		3381	}
		3382	else /* if (row_info->bit_depth == 16) */
		3383	{
		3384	sp = row;
		3385	for (i = 0; i < row_width; i++)
		3386	{
		3387	png_uint_16 v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3388	*sp = (png_byte)((v >> 8) & 0xff);
		3389	*(sp + 1) = (png_byte)(v & 0xff);
		3390	sp += 4;
		3391	}
		3392	}
		3393	break;
		3394	}
		3395	case PNG_COLOR_TYPE_GRAY:
		3396	{
		3397	if (row_info->bit_depth == 2)
		3398	{
		3399	sp = row;
		3400	for (i = 0; i < row_width; i += 4)
		3401	{
		3402	int a = *sp & 0xc0;
		3403	int b = *sp & 0x30;
		3404	int c = *sp & 0x0c;
		3405	int d = *sp & 0x03;
		3406
		3407	*sp = (png_byte)(
		3408	((((int)gamma_table[a\|(a>>2)\|(a>>4)\|(a>>6)]) ) & 0xc0)\|
		3409	((((int)gamma_table[(b<<2)\|b\|(b>>2)\|(b>>4)])>>2) & 0x30)\|
		3410	((((int)gamma_table[(c<<4)\|(c<<2)\|c\|(c>>2)])>>4) & 0x0c)\|
		3411	((((int)gamma_table[(d<<6)\|(d<<4)\|(d<<2)\|d])>>6) ));
		3412	sp++;
		3413	}
		3414	}
		3415	if (row_info->bit_depth == 4)
		3416	{
		3417	sp = row;
		3418	for (i = 0; i < row_width; i += 2)
		3419	{
		3420	int msb = *sp & 0xf0;
		3421	int lsb = *sp & 0x0f;
		3422
		3423	*sp = (png_byte)((((int)gamma_table[msb \| (msb >> 4)]) & 0xf0)
		3424	\| (((int)gamma_table[(lsb << 4) \| lsb]) >> 4));
		3425	sp++;
		3426	}
		3427	}
		3428	else if (row_info->bit_depth == 8)
		3429	{
		3430	sp = row;
		3431	for (i = 0; i < row_width; i++)
		3432	{
		3433	sp = gamma_table[sp];
		3434	sp++;
		3435	}
		3436	}
		3437	else if (row_info->bit_depth == 16)
		3438	{
		3439	sp = row;
		3440	for (i = 0; i < row_width; i++)
		3441	{
		3442	png_uint_16 v = gamma_16_table[(sp + 1) >> gamma_shift][sp];
		3443	*sp = (png_byte)((v >> 8) & 0xff);
		3444	*(sp + 1) = (png_byte)(v & 0xff);
		3445	sp += 2;
		3446	}
		3447	}
		3448	break;
		3449	}
		3450	}
		3451	}
		3452	}
		3453	#endif
		3454
		3455	#if defined(PNG_READ_EXPAND_SUPPORTED)
		3456	/* Expands a palette row to an RGB or RGBA row depending
		3457	* upon whether you supply trans and num_trans.
		3458	*/
		3459	void /* PRIVATE */
		3460	png_do_expand_palette(png_row_infop row_info, png_bytep row,
		3461	png_colorp palette, png_bytep trans, int num_trans)
		3462	{
		3463	int shift, value;
		3464	png_bytep sp, dp;
		3465	png_uint_32 i;
		3466	png_uint_32 row_width=row_info->width;
		3467
		3468	png_debug(1, "in png_do_expand_palette\n");
		3469	if (
		3470	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		3471	row != NULL && row_info != NULL &&
		3472	#endif
		3473	row_info->color_type == PNG_COLOR_TYPE_PALETTE)
		3474	{
		3475	if (row_info->bit_depth < 8)
		3476	{
		3477	switch (row_info->bit_depth)
		3478	{
		3479	case 1:
		3480	{
		3481	sp = row + (png_size_t)((row_width - 1) >> 3);
		3482	dp = row + (png_size_t)row_width - 1;
		3483	shift = 7 - (int)((row_width + 7) & 0x07);
		3484	for (i = 0; i < row_width; i++)
		3485	{
		3486	if ((*sp >> shift) & 0x01)
		3487	*dp = 1;
		3488	else
		3489	*dp = 0;
		3490	if (shift == 7)
		3491	{
		3492	shift = 0;
		3493	sp--;
		3494	}
		3495	else
		3496	shift++;
		3497
		3498	dp--;
		3499	}
		3500	break;
		3501	}
		3502	case 2:
		3503	{
		3504	sp = row + (png_size_t)((row_width - 1) >> 2);
		3505	dp = row + (png_size_t)row_width - 1;
		3506	shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
		3507	for (i = 0; i < row_width; i++)
		3508	{
		3509	value = (*sp >> shift) & 0x03;
		3510	*dp = (png_byte)value;
		3511	if (shift == 6)
		3512	{
		3513	shift = 0;
		3514	sp--;
		3515	}
		3516	else
		3517	shift += 2;
		3518
		3519	dp--;
		3520	}
		3521	break;
		3522	}
		3523	case 4:
		3524	{
		3525	sp = row + (png_size_t)((row_width - 1) >> 1);
		3526	dp = row + (png_size_t)row_width - 1;
		3527	shift = (int)((row_width & 0x01) << 2);
		3528	for (i = 0; i < row_width; i++)
		3529	{
		3530	value = (*sp >> shift) & 0x0f;
		3531	*dp = (png_byte)value;
		3532	if (shift == 4)
		3533	{
		3534	shift = 0;
		3535	sp--;
		3536	}
		3537	else
		3538	shift += 4;
		3539
		3540	dp--;
		3541	}
		3542	break;
		3543	}
		3544	}
		3545	row_info->bit_depth = 8;
		3546	row_info->pixel_depth = 8;
		3547	row_info->rowbytes = row_width;
		3548	}
		3549	switch (row_info->bit_depth)
		3550	{
		3551	case 8:
		3552	{
		3553	if (trans != NULL)
		3554	{
		3555	sp = row + (png_size_t)row_width - 1;
		3556	dp = row + (png_size_t)(row_width << 2) - 1;
		3557
		3558	for (i = 0; i < row_width; i++)
		3559	{
		3560	if ((int)(*sp) >= num_trans)
		3561	*dp-- = 0xff;
		3562	else
		3563	dp-- = trans[sp];
		3564	dp-- = palette[sp].blue;
		3565	dp-- = palette[sp].green;
		3566	dp-- = palette[sp].red;
		3567	sp--;
		3568	}
		3569	row_info->bit_depth = 8;
		3570	row_info->pixel_depth = 32;
		3571	row_info->rowbytes = row_width * 4;
		3572	row_info->color_type = 6;
		3573	row_info->channels = 4;
		3574	}
		3575	else
		3576	{
		3577	sp = row + (png_size_t)row_width - 1;
		3578	dp = row + (png_size_t)(row_width * 3) - 1;
		3579
		3580	for (i = 0; i < row_width; i++)
		3581	{
		3582	dp-- = palette[sp].blue;
		3583	dp-- = palette[sp].green;
		3584	dp-- = palette[sp].red;
		3585	sp--;
		3586	}
		3587	row_info->bit_depth = 8;
		3588	row_info->pixel_depth = 24;
		3589	row_info->rowbytes = row_width * 3;
		3590	row_info->color_type = 2;
		3591	row_info->channels = 3;
		3592	}
		3593	break;
		3594	}
		3595	}
		3596	}
		3597	}
		3598
		3599	/* If the bit depth < 8, it is expanded to 8. Also, if the
		3600	* transparency value is supplied, an alpha channel is built.
		3601	*/
		3602	void /* PRIVATE */
		3603	png_do_expand(png_row_infop row_info, png_bytep row,
		3604	png_color_16p trans_value)
		3605	{
		3606	int shift, value;
		3607	png_bytep sp, dp;
		3608	png_uint_32 i;
		3609	png_uint_32 row_width=row_info->width;
		3610
		3611	png_debug(1, "in png_do_expand\n");
		3612	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		3613	if (row != NULL && row_info != NULL)
		3614	#endif
		3615	{
		3616	if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
		3617	{
		3618	png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
		3619
		3620	if (row_info->bit_depth < 8)
		3621	{
		3622	switch (row_info->bit_depth)
		3623	{
		3624	case 1:
		3625	{
		3626	gray = (png_uint_16)(gray*0xff);
		3627	sp = row + (png_size_t)((row_width - 1) >> 3);
		3628	dp = row + (png_size_t)row_width - 1;
		3629	shift = 7 - (int)((row_width + 7) & 0x07);
		3630	for (i = 0; i < row_width; i++)
		3631	{
		3632	if ((*sp >> shift) & 0x01)
		3633	*dp = 0xff;
		3634	else
		3635	*dp = 0;
		3636	if (shift == 7)
		3637	{
		3638	shift = 0;
		3639	sp--;
		3640	}
		3641	else
		3642	shift++;
		3643
		3644	dp--;
		3645	}
		3646	break;
		3647	}
		3648	case 2:
		3649	{
		3650	gray = (png_uint_16)(gray*0x55);
		3651	sp = row + (png_size_t)((row_width - 1) >> 2);
		3652	dp = row + (png_size_t)row_width - 1;
		3653	shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
		3654	for (i = 0; i < row_width; i++)
		3655	{
		3656	value = (*sp >> shift) & 0x03;
		3657	*dp = (png_byte)(value \| (value << 2) \| (value << 4) \|
		3658	(value << 6));
		3659	if (shift == 6)
		3660	{
		3661	shift = 0;
		3662	sp--;
		3663	}
		3664	else
		3665	shift += 2;
		3666
		3667	dp--;
		3668	}
		3669	break;
		3670	}
		3671	case 4:
		3672	{
		3673	gray = (png_uint_16)(gray*0x11);
		3674	sp = row + (png_size_t)((row_width - 1) >> 1);
		3675	dp = row + (png_size_t)row_width - 1;
		3676	shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
		3677	for (i = 0; i < row_width; i++)
		3678	{
		3679	value = (*sp >> shift) & 0x0f;
		3680	*dp = (png_byte)(value \| (value << 4));
		3681	if (shift == 4)
		3682	{
		3683	shift = 0;
		3684	sp--;
		3685	}
		3686	else
		3687	shift = 4;
		3688
		3689	dp--;
		3690	}
		3691	break;
		3692	}
		3693	}
		3694	row_info->bit_depth = 8;
		3695	row_info->pixel_depth = 8;
		3696	row_info->rowbytes = row_width;
		3697	}
		3698
		3699	if (trans_value != NULL)
		3700	{
		3701	if (row_info->bit_depth == 8)
		3702	{
		3703	sp = row + (png_size_t)row_width - 1;
		3704	dp = row + (png_size_t)(row_width << 1) - 1;
		3705	for (i = 0; i < row_width; i++)
		3706	{
		3707	if (*sp == gray)
		3708	*dp-- = 0;
		3709	else
		3710	*dp-- = 0xff;
		3711	dp-- = sp--;
		3712	}
		3713	}
		3714	else if (row_info->bit_depth == 16)
		3715	{
		3716	sp = row + row_info->rowbytes - 1;
		3717	dp = row + (row_info->rowbytes << 1) - 1;
		3718	for (i = 0; i < row_width; i++)
		3719	{
		3720	if (((png_uint_16)*(sp) \|
		3721	((png_uint_16)*(sp - 1) << 8)) == gray)
		3722	{
		3723	*dp-- = 0;
		3724	*dp-- = 0;
		3725	}
		3726	else
		3727	{
		3728	*dp-- = 0xff;
		3729	*dp-- = 0xff;
		3730	}
		3731	dp-- = sp--;
		3732	dp-- = sp--;
		3733	}
		3734	}
		3735	row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
		3736	row_info->channels = 2;
		3737	row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
		3738	row_info->rowbytes =
		3739	((row_width * row_info->pixel_depth) >> 3);
		3740	}
		3741	}
		3742	else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
		3743	{
		3744	if (row_info->bit_depth == 8)
		3745	{
		3746	sp = row + (png_size_t)row_info->rowbytes - 1;
		3747	dp = row + (png_size_t)(row_width << 2) - 1;
		3748	for (i = 0; i < row_width; i++)
		3749	{
		3750	if (*(sp - 2) == trans_value->red &&
		3751	*(sp - 1) == trans_value->green &&
		3752	*(sp - 0) == trans_value->blue)
		3753	*dp-- = 0;
		3754	else
		3755	*dp-- = 0xff;
		3756	dp-- = sp--;
		3757	dp-- = sp--;
		3758	dp-- = sp--;
		3759	}
		3760	}
		3761	else if (row_info->bit_depth == 16)
		3762	{
		3763	sp = row + row_info->rowbytes - 1;
		3764	dp = row + (png_size_t)(row_width << 3) - 1;
		3765	for (i = 0; i < row_width; i++)
		3766	{
		3767	if ((((png_uint_16)*(sp - 4) \|
		3768	((png_uint_16)*(sp - 5) << 8)) == trans_value->red) &&
		3769	(((png_uint_16)*(sp - 2) \|
		3770	((png_uint_16)*(sp - 3) << 8)) == trans_value->green) &&
		3771	(((png_uint_16)*(sp - 0) \|
		3772	((png_uint_16)*(sp - 1) << 8)) == trans_value->blue))
		3773	{
		3774	*dp-- = 0;
		3775	*dp-- = 0;
		3776	}
		3777	else
		3778	{
		3779	*dp-- = 0xff;
		3780	*dp-- = 0xff;
		3781	}
		3782	dp-- = sp--;
		3783	dp-- = sp--;
		3784	dp-- = sp--;
		3785	dp-- = sp--;
		3786	dp-- = sp--;
		3787	dp-- = sp--;
		3788	}
		3789	}
		3790	row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
		3791	row_info->channels = 4;
		3792	row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
		3793	row_info->rowbytes =
		3794	((row_width * row_info->pixel_depth) >> 3);
		3795	}
		3796	}
		3797	}
		3798	#endif
		3799
		3800	#if defined(PNG_READ_DITHER_SUPPORTED)
		3801	void /* PRIVATE */
		3802	png_do_dither(png_row_infop row_info, png_bytep row,
		3803	png_bytep palette_lookup, png_bytep dither_lookup)
		3804	{
		3805	png_bytep sp, dp;
		3806	png_uint_32 i;
		3807	png_uint_32 row_width=row_info->width;
		3808
		3809	png_debug(1, "in png_do_dither\n");
		3810	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		3811	if (row != NULL && row_info != NULL)
		3812	#endif
		3813	{
		3814	if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
		3815	palette_lookup && row_info->bit_depth == 8)
		3816	{
		3817	int r, g, b, p;
		3818	sp = row;
		3819	dp = row;
		3820	for (i = 0; i < row_width; i++)
		3821	{
		3822	r = *sp++;
		3823	g = *sp++;
		3824	b = *sp++;
		3825
		3826	/* this looks real messy, but the compiler will reduce
		3827	it down to a reasonable formula. For example, with
		3828	5 bits per color, we get:
		3829	p = (((r >> 3) & 0x1f) << 10) \|
		3830	(((g >> 3) & 0x1f) << 5) \|
		3831	((b >> 3) & 0x1f);
		3832	*/
		3833	p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
		3834	((1 << PNG_DITHER_RED_BITS) - 1)) <<
		3835	(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) \|
		3836	(((g >> (8 - PNG_DITHER_GREEN_BITS)) &
		3837	((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
		3838	(PNG_DITHER_BLUE_BITS)) \|
		3839	((b >> (8 - PNG_DITHER_BLUE_BITS)) &
		3840	((1 << PNG_DITHER_BLUE_BITS) - 1));
		3841
		3842	*dp++ = palette_lookup[p];
		3843	}
		3844	row_info->color_type = PNG_COLOR_TYPE_PALETTE;
		3845	row_info->channels = 1;
		3846	row_info->pixel_depth = row_info->bit_depth;
		3847	row_info->rowbytes =
		3848	((row_width * row_info->pixel_depth + 7) >> 3);
		3849	}
		3850	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
		3851	palette_lookup != NULL && row_info->bit_depth == 8)
		3852	{
		3853	int r, g, b, p;
		3854	sp = row;
		3855	dp = row;
		3856	for (i = 0; i < row_width; i++)
		3857	{
		3858	r = *sp++;
		3859	g = *sp++;
		3860	b = *sp++;
		3861	sp++;
		3862
		3863	p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
		3864	((1 << PNG_DITHER_RED_BITS) - 1)) <<
		3865	(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) \|
		3866	(((g >> (8 - PNG_DITHER_GREEN_BITS)) &
		3867	((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
		3868	(PNG_DITHER_BLUE_BITS)) \|
		3869	((b >> (8 - PNG_DITHER_BLUE_BITS)) &
		3870	((1 << PNG_DITHER_BLUE_BITS) - 1));
		3871
		3872	*dp++ = palette_lookup[p];
		3873	}
		3874	row_info->color_type = PNG_COLOR_TYPE_PALETTE;
		3875	row_info->channels = 1;
		3876	row_info->pixel_depth = row_info->bit_depth;
		3877	row_info->rowbytes =
		3878	((row_width * row_info->pixel_depth + 7) >> 3);
		3879	}
		3880	else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
		3881	dither_lookup && row_info->bit_depth == 8)
		3882	{
		3883	sp = row;
		3884	for (i = 0; i < row_width; i++, sp++)
		3885	{
		3886	sp = dither_lookup[sp];
		3887	}
		3888	}
		3889	}
		3890	}
		3891	#endif
		3892
		3893	#ifdef PNG_FLOATING_POINT_SUPPORTED
		3894	#if defined(PNG_READ_GAMMA_SUPPORTED)
		3895	static int png_gamma_shift[] =
		3896	{0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0};
		3897
		3898	/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
		3899	* tables, we don't make a full table if we are reducing to 8-bit in
		3900	* the future. Note also how the gamma_16 tables are segmented so that
		3901	* we don't need to allocate > 64K chunks for a full 16-bit table.
		3902	*/
		3903	void /* PRIVATE */
		3904	png_build_gamma_table(png_structp png_ptr)
		3905	{
		3906	png_debug(1, "in png_build_gamma_table\n");
		3907	if(png_ptr->gamma != 0.0)
		3908	{
		3909	if (png_ptr->bit_depth <= 8)
		3910	{
		3911	int i;
		3912	double g;
		3913
		3914	if (png_ptr->screen_gamma > .000001)
		3915	g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
		3916	else
		3917	g = 1.0;
		3918
		3919	png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
		3920	(png_uint_32)256);
		3921
		3922	for (i = 0; i < 256; i++)
		3923	{
		3924	png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
		3925	g) * 255.0 + .5);
		3926	}
		3927
		3928	#if defined(PNG_READ_BACKGROUND_SUPPORTED) \|\| \
		3929	defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		3930	if (png_ptr->transformations & ((PNG_BACKGROUND) \| PNG_RGB_TO_GRAY))
		3931	{
		3932
		3933	g = 1.0 / (png_ptr->gamma);
		3934
		3935	png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
		3936	(png_uint_32)256);
		3937
		3938	for (i = 0; i < 256; i++)
		3939	{
		3940	png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
		3941	g) * 255.0 + .5);
		3942	}
		3943
		3944
		3945	png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
		3946	(png_uint_32)256);
		3947
		3948	if(png_ptr->screen_gamma > 0.000001)
		3949	g = 1.0 / png_ptr->screen_gamma;
		3950	else
		3951	g = png_ptr->gamma; /* probably doing rgb_to_gray */
		3952
		3953	for (i = 0; i < 256; i++)
		3954	{
		3955	png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
		3956	g) * 255.0 + .5);
		3957
		3958	}
		3959	}
		3960	#endif /* PNG_READ_BACKGROUND_SUPPORTED \|\| PNG_RGB_TO_GRAY_SUPPORTED */
		3961	}
		3962	else
		3963	{
		3964	double g;
		3965	int i, j, shift, num;
		3966	int sig_bit;
		3967	png_uint_32 ig;
		3968
		3969	if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
		3970	{
		3971	sig_bit = (int)png_ptr->sig_bit.red;
		3972	if ((int)png_ptr->sig_bit.green > sig_bit)
		3973	sig_bit = png_ptr->sig_bit.green;
		3974	if ((int)png_ptr->sig_bit.blue > sig_bit)
		3975	sig_bit = png_ptr->sig_bit.blue;
		3976	}
		3977	else
		3978	{
		3979	sig_bit = (int)png_ptr->sig_bit.gray;
		3980	}
		3981
		3982	if (sig_bit > 0)
		3983	shift = 16 - sig_bit;
		3984	else
		3985	shift = 0;
		3986
		3987	if (png_ptr->transformations & PNG_16_TO_8)
		3988	{
		3989	if (shift < (16 - PNG_MAX_GAMMA_8))
		3990	shift = (16 - PNG_MAX_GAMMA_8);
		3991	}
		3992
		3993	if (shift > 8)
		3994	shift = 8;
		3995	if (shift < 0)
		3996	shift = 0;
		3997
		3998	png_ptr->gamma_shift = (png_byte)shift;
		3999
		4000	num = (1 << (8 - shift));
		4001
		4002	if (png_ptr->screen_gamma > .000001)
		4003	g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
		4004	else
		4005	g = 1.0;
		4006
		4007	png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
		4008	(png_uint_32)(num * sizeof (png_uint_16p)));
		4009
		4010	if (png_ptr->transformations & (PNG_16_TO_8 \| PNG_BACKGROUND))
		4011	{
		4012	double fin, fout;
		4013	png_uint_32 last, max;
		4014
		4015	for (i = 0; i < num; i++)
		4016	{
		4017	png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
		4018	(png_uint_32)(256 * sizeof (png_uint_16)));
		4019	}
		4020
		4021	g = 1.0 / g;
		4022	last = 0;
		4023	for (i = 0; i < 256; i++)
		4024	{
		4025	fout = ((double)i + 0.5) / 256.0;
		4026	fin = pow(fout, g);
		4027	max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
		4028	while (last <= max)
		4029	{
		4030	png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
		4031	[(int)(last >> (8 - shift))] = (png_uint_16)(
		4032	(png_uint_16)i \| ((png_uint_16)i << 8));
		4033	last++;
		4034	}
		4035	}
		4036	while (last < ((png_uint_32)num << 8))
		4037	{
		4038	png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
		4039	[(int)(last >> (8 - shift))] = (png_uint_16)65535L;
		4040	last++;
		4041	}
		4042	}
		4043	else
		4044	{
		4045	for (i = 0; i < num; i++)
		4046	{
		4047	png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
		4048	(png_uint_32)(256 * sizeof (png_uint_16)));
		4049
		4050	ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
		4051	for (j = 0; j < 256; j++)
		4052	{
		4053	png_ptr->gamma_16_table[i][j] =
		4054	(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
		4055	65535.0, g) * 65535.0 + .5);
		4056	}
		4057	}
		4058	}
		4059
		4060	#if defined(PNG_READ_BACKGROUND_SUPPORTED) \|\| \
		4061	defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
		4062	if (png_ptr->transformations & (PNG_BACKGROUND \| PNG_RGB_TO_GRAY))
		4063	{
		4064
		4065	g = 1.0 / (png_ptr->gamma);
		4066
		4067	png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
		4068	(png_uint_32)(num * sizeof (png_uint_16p )));
		4069
		4070	for (i = 0; i < num; i++)
		4071	{
		4072	png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
		4073	(png_uint_32)(256 * sizeof (png_uint_16)));
		4074
		4075	ig = (((png_uint_32)i *
		4076	(png_uint_32)png_gamma_shift[shift]) >> 4);
		4077	for (j = 0; j < 256; j++)
		4078	{
		4079	png_ptr->gamma_16_to_1[i][j] =
		4080	(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
		4081	65535.0, g) * 65535.0 + .5);
		4082	}
		4083	}
		4084
		4085	if(png_ptr->screen_gamma > 0.000001)
		4086	g = 1.0 / png_ptr->screen_gamma;
		4087	else
		4088	g = png_ptr->gamma; /* probably doing rgb_to_gray */
		4089
		4090	png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
		4091	(png_uint_32)(num * sizeof (png_uint_16p)));
		4092
		4093	for (i = 0; i < num; i++)
		4094	{
		4095	png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
		4096	(png_uint_32)(256 * sizeof (png_uint_16)));
		4097
		4098	ig = (((png_uint_32)i *
		4099	(png_uint_32)png_gamma_shift[shift]) >> 4);
		4100	for (j = 0; j < 256; j++)
		4101	{
		4102	png_ptr->gamma_16_from_1[i][j] =
		4103	(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
		4104	65535.0, g) * 65535.0 + .5);
		4105	}
		4106	}
		4107	}
		4108	#endif /* PNG_READ_BACKGROUND_SUPPORTED \|\| PNG_RGB_TO_GRAY_SUPPORTED */
		4109	}
		4110	}
		4111	}
		4112	#endif
		4113	/* To do: install integer version of png_build_gamma_table here */
		4114	#endif
		4115
		4116	#if defined(PNG_MNG_FEATURES_SUPPORTED)
		4117	/* undoes intrapixel differencing */
		4118	void /* PRIVATE */
		4119	png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
		4120	{
		4121	png_debug(1, "in png_do_read_intrapixel\n");
		4122	if (
		4123	#if defined(PNG_USELESS_TESTS_SUPPORTED)
		4124	row != NULL && row_info != NULL &&
		4125	#endif
		4126	(row_info->color_type & PNG_COLOR_MASK_COLOR))
		4127	{
		4128	int bytes_per_pixel;
		4129	png_uint_32 row_width = row_info->width;
		4130	if (row_info->bit_depth == 8)
		4131	{
		4132	png_bytep rp;
		4133	png_uint_32 i;
		4134
		4135	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
		4136	bytes_per_pixel = 3;
		4137	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
		4138	bytes_per_pixel = 4;
		4139	else
		4140	return;
		4141
		4142	for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
		4143	{
		4144	(rp) = (png_byte)((256 + rp + *(rp+1))&0xff);
		4145	(rp+2) = (png_byte)((256 + (rp+2) + *(rp+1))&0xff);
		4146	}
		4147	}
		4148	else if (row_info->bit_depth == 16)
		4149	{
		4150	png_bytep rp;
		4151	png_uint_32 i;
		4152
		4153	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
		4154	bytes_per_pixel = 6;
		4155	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
		4156	bytes_per_pixel = 8;
		4157	else
		4158	return;
		4159
		4160	for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
		4161	{
		4162	png_uint_32 s0=(rp )<<8 \| (rp+1);
		4163	png_uint_32 s1=(rp+2)<<8 \| (rp+3);
		4164	png_uint_32 s2=(rp+4)<<8 \| (rp+5);
		4165	png_uint_32 red=(65536+s0+s1)&0xffff;
		4166	png_uint_32 blue=(65536+s2+s1)&0xffff;
		4167	*(rp ) = (png_byte)((red>>8)&0xff);
		4168	*(rp+1) = (png_byte)(red&0xff);
		4169	*(rp+4) = (png_byte)((blue>>8)&0xff);
		4170	*(rp+5) = (png_byte)(blue&0xff);
		4171	}
		4172	}
		4173	}
		4174	}
		4175	#endif /* PNG_MNG_FEATURES_SUPPORTED */

Subversion Repositories shark

(root)/shark/trunk/ports/png/pngrtran.c @ 379 - Rev 96