pngtrans.c@ 67439

Last change on this file since 67439 was 58796, checked in by vboxsync, 9 years ago
libpng 1.2.54 unmodified
Property svn:eol-style set to `native`
File size: 20.6 KB

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

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

source: vbox/trunk/src/libs/libpng-1.2.54/pngtrans.c@ 67439

Download in other formats: