pngtrans.c@ 13371

Last change on this file since 13371 was 6393, checked in by vboxsync, 17 years ago
export libpng and zlib so Windows and OS/2 builds cleanly.
Property svn:eol-style set to `native`
File size: 19.9 KB

Line
1
2	/* pngtrans.c - transforms the data in a row (used by both readers and writers)
3	*
4	* libpng 1.2.8 - December 3, 2004
5	* For conditions of distribution and use, see copyright notice in png.h
6	* Copyright (c) 1998-2004 Glenn Randers-Pehrson
7	* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8	* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9	*/
10
11	#define PNG_INTERNAL
12	#include "png.h"
13
14	#if defined(PNG_READ_BGR_SUPPORTED) \|\| defined(PNG_WRITE_BGR_SUPPORTED)
15	/* turn on BGR-to-RGB mapping */
16	void PNGAPI
17	png_set_bgr(png_structp png_ptr)
18	{
19	png_debug(1, "in png_set_bgr\n");
20	png_ptr->transformations \|= PNG_BGR;
21	}
22	#endif
23
24	#if defined(PNG_READ_SWAP_SUPPORTED) \|\| defined(PNG_WRITE_SWAP_SUPPORTED)
25	/* turn on 16 bit byte swapping */
26	void PNGAPI
27	png_set_swap(png_structp png_ptr)
28	{
29	png_debug(1, "in png_set_swap\n");
30	if (png_ptr->bit_depth == 16)
31	png_ptr->transformations \|= PNG_SWAP_BYTES;
32	}
33	#endif
34
35	#if defined(PNG_READ_PACK_SUPPORTED) \|\| defined(PNG_WRITE_PACK_SUPPORTED)
36	/* turn on pixel packing */
37	void PNGAPI
38	png_set_packing(png_structp png_ptr)
39	{
40	png_debug(1, "in png_set_packing\n");
41	if (png_ptr->bit_depth < 8)
42	{
43	png_ptr->transformations \|= PNG_PACK;
44	png_ptr->usr_bit_depth = 8;
45	}
46	}
47	#endif
48
49	#if defined(PNG_READ_PACKSWAP_SUPPORTED)\|\|defined(PNG_WRITE_PACKSWAP_SUPPORTED)
50	/* turn on packed pixel swapping */
51	void PNGAPI
52	png_set_packswap(png_structp png_ptr)
53	{
54	png_debug(1, "in png_set_packswap\n");
55	if (png_ptr->bit_depth < 8)
56	png_ptr->transformations \|= PNG_PACKSWAP;
57	}
58	#endif
59
60	#if defined(PNG_READ_SHIFT_SUPPORTED) \|\| defined(PNG_WRITE_SHIFT_SUPPORTED)
61	void PNGAPI
62	png_set_shift(png_structp png_ptr, png_color_8p true_bits)
63	{
64	png_debug(1, "in png_set_shift\n");
65	png_ptr->transformations \|= PNG_SHIFT;
66	png_ptr->shift = *true_bits;
67	}
68	#endif
69
70	#if defined(PNG_READ_INTERLACING_SUPPORTED) \|\| \
71	defined(PNG_WRITE_INTERLACING_SUPPORTED)
72	int PNGAPI
73	png_set_interlace_handling(png_structp png_ptr)
74	{
75	png_debug(1, "in png_set_interlace handling\n");
76	if (png_ptr->interlaced)
77	{
78	png_ptr->transformations \|= PNG_INTERLACE;
79	return (7);
80	}
81
82	return (1);
83	}
84	#endif
85
86	#if defined(PNG_READ_FILLER_SUPPORTED) \|\| defined(PNG_WRITE_FILLER_SUPPORTED)
87	/* Add a filler byte on read, or remove a filler or alpha byte on write.
88	* The filler type has changed in v0.95 to allow future 2-byte fillers
89	* for 48-bit input data, as well as to avoid problems with some compilers
90	* that don't like bytes as parameters.
91	*/
92	void PNGAPI
93	png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
94	{
95	png_debug(1, "in png_set_filler\n");
96	png_ptr->transformations \|= PNG_FILLER;
97	png_ptr->filler = (png_byte)filler;
98	if (filler_loc == PNG_FILLER_AFTER)
99	png_ptr->flags \|= PNG_FLAG_FILLER_AFTER;
100	else
101	png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
102
103	/* This should probably go in the "do_read_filler" routine.
104	* I attempted to do that in libpng-1.0.1a but that caused problems
105	* so I restored it in libpng-1.0.2a
106	*/
107
108	if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
109	{
110	png_ptr->usr_channels = 4;
111	}
112
113	/* Also I added this in libpng-1.0.2a (what happens when we expand
114	* a less-than-8-bit grayscale to GA? */
115
116	if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
117	{
118	png_ptr->usr_channels = 2;
119	}
120	}
121
122	#if !defined(PNG_1_0_X)
123	/* Added to libpng-1.2.7 */
124	void PNGAPI
125	png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
126	{
127	png_debug(1, "in png_set_add_alpha\n");
128	png_set_filler(png_ptr, filler, filler_loc);
129	png_ptr->transformations \|= PNG_ADD_ALPHA;
130	}
131	#endif
132
133	#endif
134
135	#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) \|\| \
136	defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
137	void PNGAPI
138	png_set_swap_alpha(png_structp png_ptr)
139	{
140	png_debug(1, "in png_set_swap_alpha\n");
141	png_ptr->transformations \|= PNG_SWAP_ALPHA;
142	}
143	#endif
144
145	#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) \|\| \
146	defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
147	void PNGAPI
148	png_set_invert_alpha(png_structp png_ptr)
149	{
150	png_debug(1, "in png_set_invert_alpha\n");
151	png_ptr->transformations \|= PNG_INVERT_ALPHA;
152	}
153	#endif
154
155	#if defined(PNG_READ_INVERT_SUPPORTED) \|\| defined(PNG_WRITE_INVERT_SUPPORTED)
156	void PNGAPI
157	png_set_invert_mono(png_structp png_ptr)
158	{
159	png_debug(1, "in png_set_invert_mono\n");
160	png_ptr->transformations \|= PNG_INVERT_MONO;
161	}
162
163	/* invert monochrome grayscale data */
164	void /* PRIVATE */
165	png_do_invert(png_row_infop row_info, png_bytep row)
166	{
167	png_debug(1, "in png_do_invert\n");
168	/* This test removed from libpng version 1.0.13 and 1.2.0:
169	* if (row_info->bit_depth == 1 &&
170	*/
171	#if defined(PNG_USELESS_TESTS_SUPPORTED)
172	if (row == NULL \|\| row_info == NULL)
173	return;
174	#endif
175	if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
176	{
177	png_bytep rp = row;
178	png_uint_32 i;
179	png_uint_32 istop = row_info->rowbytes;
180
181	for (i = 0; i < istop; i++)
182	{
183	rp = (png_byte)(~(rp));
184	rp++;
185	}
186	}
187	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
188	row_info->bit_depth == 8)
189	{
190	png_bytep rp = row;
191	png_uint_32 i;
192	png_uint_32 istop = row_info->rowbytes;
193
194	for (i = 0; i < istop; i+=2)
195	{
196	rp = (png_byte)(~(rp));
197	rp+=2;
198	}
199	}
200	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
201	row_info->bit_depth == 16)
202	{
203	png_bytep rp = row;
204	png_uint_32 i;
205	png_uint_32 istop = row_info->rowbytes;
206
207	for (i = 0; i < istop; i+=4)
208	{
209	rp = (png_byte)(~(rp));
210	(rp+1) = (png_byte)(~((rp+1)));
211	rp+=4;
212	}
213	}
214	}
215	#endif
216
217	#if defined(PNG_READ_SWAP_SUPPORTED) \|\| defined(PNG_WRITE_SWAP_SUPPORTED)
218	/* swaps byte order on 16 bit depth images */
219	void /* PRIVATE */
220	png_do_swap(png_row_infop row_info, png_bytep row)
221	{
222	png_debug(1, "in png_do_swap\n");
223	if (
224	#if defined(PNG_USELESS_TESTS_SUPPORTED)
225	row != NULL && row_info != NULL &&
226	#endif
227	row_info->bit_depth == 16)
228	{
229	png_bytep rp = row;
230	png_uint_32 i;
231	png_uint_32 istop= row_info->width * row_info->channels;
232
233	for (i = 0; i < istop; i++, rp += 2)
234	{
235	png_byte t = *rp;
236	rp = (rp + 1);
237	*(rp + 1) = t;
238	}
239	}
240	}
241	#endif
242
243	#if defined(PNG_READ_PACKSWAP_SUPPORTED)\|\|defined(PNG_WRITE_PACKSWAP_SUPPORTED)
244	static png_byte onebppswaptable[256] = {
245	0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
246	0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
247	0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
248	0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
249	0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
250	0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
251	0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
252	0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
253	0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
254	0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
255	0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
256	0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
257	0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
258	0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
259	0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
260	0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
261	0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
262	0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
263	0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
264	0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
265	0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
266	0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
267	0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
268	0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
269	0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
270	0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
271	0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
272	0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
273	0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
274	0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
275	0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
276	0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
277	};
278
279	static png_byte twobppswaptable[256] = {
280	0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
281	0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
282	0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
283	0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
284	0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
285	0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
286	0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
287	0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
288	0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
289	0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
290	0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
291	0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
292	0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
293	0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
294	0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
295	0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
296	0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
297	0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
298	0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
299	0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
300	0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
301	0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
302	0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
303	0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
304	0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
305	0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
306	0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
307	0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
308	0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
309	0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
310	0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
311	0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
312	};
313
314	static png_byte fourbppswaptable[256] = {
315	0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
316	0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
317	0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
318	0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
319	0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
320	0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
321	0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
322	0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
323	0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
324	0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
325	0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
326	0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
327	0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
328	0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
329	0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
330	0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
331	0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
332	0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
333	0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
334	0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
335	0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
336	0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
337	0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
338	0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
339	0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
340	0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
341	0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
342	0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
343	0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
344	0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
345	0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
346	0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
347	};
348
349	/* swaps pixel packing order within bytes */
350	void /* PRIVATE */
351	png_do_packswap(png_row_infop row_info, png_bytep row)
352	{
353	png_debug(1, "in png_do_packswap\n");
354	if (
355	#if defined(PNG_USELESS_TESTS_SUPPORTED)
356	row != NULL && row_info != NULL &&
357	#endif
358	row_info->bit_depth < 8)
359	{
360	png_bytep rp, end, table;
361
362	end = row + row_info->rowbytes;
363
364	if (row_info->bit_depth == 1)
365	table = onebppswaptable;
366	else if (row_info->bit_depth == 2)
367	table = twobppswaptable;
368	else if (row_info->bit_depth == 4)
369	table = fourbppswaptable;
370	else
371	return;
372
373	for (rp = row; rp < end; rp++)
374	rp = table[rp];
375	}
376	}
377	#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
378
379	#if defined(PNG_WRITE_FILLER_SUPPORTED) \|\| \
380	defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
381	/* remove filler or alpha byte(s) */
382	void /* PRIVATE */
383	png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
384	{
385	png_debug(1, "in png_do_strip_filler\n");
386	#if defined(PNG_USELESS_TESTS_SUPPORTED)
387	if (row != NULL && row_info != NULL)
388	#endif
389	{
390	png_bytep sp=row;
391	png_bytep dp=row;
392	png_uint_32 row_width=row_info->width;
393	png_uint_32 i;
394
395	if ((row_info->color_type == PNG_COLOR_TYPE_RGB \|\|
396	(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
397	(flags & PNG_FLAG_STRIP_ALPHA))) &&
398	row_info->channels == 4)
399	{
400	if (row_info->bit_depth == 8)
401	{
402	/* This converts from RGBX or RGBA to RGB */
403	if (flags & PNG_FLAG_FILLER_AFTER)
404	{
405	dp+=3; sp+=4;
406	for (i = 1; i < row_width; i++)
407	{
408	dp++ = sp++;
409	dp++ = sp++;
410	dp++ = sp++;
411	sp++;
412	}
413	}
414	/* This converts from XRGB or ARGB to RGB */
415	else
416	{
417	for (i = 0; i < row_width; i++)
418	{
419	sp++;
420	dp++ = sp++;
421	dp++ = sp++;
422	dp++ = sp++;
423	}
424	}
425	row_info->pixel_depth = 24;
426	row_info->rowbytes = row_width * 3;
427	}
428	else /* if (row_info->bit_depth == 16) */
429	{
430	if (flags & PNG_FLAG_FILLER_AFTER)
431	{
432	/* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
433	sp += 8; dp += 6;
434	for (i = 1; i < row_width; i++)
435	{
436	/* This could be (although png_memcpy is probably slower):
437	png_memcpy(dp, sp, 6);
438	sp += 8;
439	dp += 6;
440	*/
441
442	dp++ = sp++;
443	dp++ = sp++;
444	dp++ = sp++;
445	dp++ = sp++;
446	dp++ = sp++;
447	dp++ = sp++;
448	sp += 2;
449	}
450	}
451	else
452	{
453	/* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
454	for (i = 0; i < row_width; i++)
455	{
456	/* This could be (although png_memcpy is probably slower):
457	png_memcpy(dp, sp, 6);
458	sp += 8;
459	dp += 6;
460	*/
461
462	sp+=2;
463	dp++ = sp++;
464	dp++ = sp++;
465	dp++ = sp++;
466	dp++ = sp++;
467	dp++ = sp++;
468	dp++ = sp++;
469	}
470	}
471	row_info->pixel_depth = 48;
472	row_info->rowbytes = row_width * 6;
473	}
474	row_info->channels = 3;
475	}
476	else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY \|\|
477	(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
478	(flags & PNG_FLAG_STRIP_ALPHA))) &&
479	row_info->channels == 2)
480	{
481	if (row_info->bit_depth == 8)
482	{
483	/* This converts from GX or GA to G */
484	if (flags & PNG_FLAG_FILLER_AFTER)
485	{
486	for (i = 0; i < row_width; i++)
487	{
488	dp++ = sp++;
489	sp++;
490	}
491	}
492	/* This converts from XG or AG to G */
493	else
494	{
495	for (i = 0; i < row_width; i++)
496	{
497	sp++;
498	dp++ = sp++;
499	}
500	}
501	row_info->pixel_depth = 8;
502	row_info->rowbytes = row_width;
503	}
504	else /* if (row_info->bit_depth == 16) */
505	{
506	if (flags & PNG_FLAG_FILLER_AFTER)
507	{
508	/* This converts from GGXX or GGAA to GG */
509	sp += 4; dp += 2;
510	for (i = 1; i < row_width; i++)
511	{
512	dp++ = sp++;
513	dp++ = sp++;
514	sp += 2;
515	}
516	}
517	else
518	{
519	/* This converts from XXGG or AAGG to GG */
520	for (i = 0; i < row_width; i++)
521	{
522	sp += 2;
523	dp++ = sp++;
524	dp++ = sp++;
525	}
526	}
527	row_info->pixel_depth = 16;
528	row_info->rowbytes = row_width * 2;
529	}
530	row_info->channels = 1;
531	}
532	if (flags & PNG_FLAG_STRIP_ALPHA)
533	row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
534	}
535	}
536	#endif
537
538	#if defined(PNG_READ_BGR_SUPPORTED) \|\| defined(PNG_WRITE_BGR_SUPPORTED)
539	/* swaps red and blue bytes within a pixel */
540	void /* PRIVATE */
541	png_do_bgr(png_row_infop row_info, png_bytep row)
542	{
543	png_debug(1, "in png_do_bgr\n");
544	if (
545	#if defined(PNG_USELESS_TESTS_SUPPORTED)
546	row != NULL && row_info != NULL &&
547	#endif
548	(row_info->color_type & PNG_COLOR_MASK_COLOR))
549	{
550	png_uint_32 row_width = row_info->width;
551	if (row_info->bit_depth == 8)
552	{
553	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
554	{
555	png_bytep rp;
556	png_uint_32 i;
557
558	for (i = 0, rp = row; i < row_width; i++, rp += 3)
559	{
560	png_byte save = *rp;
561	rp = (rp + 2);
562	*(rp + 2) = save;
563	}
564	}
565	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
566	{
567	png_bytep rp;
568	png_uint_32 i;
569
570	for (i = 0, rp = row; i < row_width; i++, rp += 4)
571	{
572	png_byte save = *rp;
573	rp = (rp + 2);
574	*(rp + 2) = save;
575	}
576	}
577	}
578	else if (row_info->bit_depth == 16)
579	{
580	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
581	{
582	png_bytep rp;
583	png_uint_32 i;
584
585	for (i = 0, rp = row; i < row_width; i++, rp += 6)
586	{
587	png_byte save = *rp;
588	rp = (rp + 4);
589	*(rp + 4) = save;
590	save = *(rp + 1);
591	(rp + 1) = (rp + 5);
592	*(rp + 5) = save;
593	}
594	}
595	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
596	{
597	png_bytep rp;
598	png_uint_32 i;
599
600	for (i = 0, rp = row; i < row_width; i++, rp += 8)
601	{
602	png_byte save = *rp;
603	rp = (rp + 4);
604	*(rp + 4) = save;
605	save = *(rp + 1);
606	(rp + 1) = (rp + 5);
607	*(rp + 5) = save;
608	}
609	}
610	}
611	}
612	}
613	#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
614
615	#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) \|\| \
616	defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) \|\| \
617	defined(PNG_LEGACY_SUPPORTED)
618	void PNGAPI
619	png_set_user_transform_info(png_structp png_ptr, png_voidp
620	user_transform_ptr, int user_transform_depth, int user_transform_channels)
621	{
622	png_debug(1, "in png_set_user_transform_info\n");
623	#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
624	png_ptr->user_transform_ptr = user_transform_ptr;
625	png_ptr->user_transform_depth = (png_byte)user_transform_depth;
626	png_ptr->user_transform_channels = (png_byte)user_transform_channels;
627	#else
628	if(user_transform_ptr \|\| user_transform_depth \|\| user_transform_channels)
629	png_warning(png_ptr,
630	"This version of libpng does not support user transform info");
631	#endif
632	}
633	#endif
634
635	/* This function returns a pointer to the user_transform_ptr associated with
636	* the user transform functions. The application should free any memory
637	* associated with this pointer before png_write_destroy and png_read_destroy
638	* are called.
639	*/
640	png_voidp PNGAPI
641	png_get_user_transform_ptr(png_structp png_ptr)
642	{
643	#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
644	return ((png_voidp)png_ptr->user_transform_ptr);
645	#else
646	if(png_ptr)
647	return (NULL);
648	return (NULL);
649	#endif
650	}

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

source: vbox/trunk/src/libs/libpng-1.2.8/pngtrans.c@ 13371

Download in other formats: