pngrtran.c source code [POCO/PDF/src/pngrtran.c]

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

Browse the source code of POCO/PDF/src/pngrtran.c