Context Navigation

pngtrans.c

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
Property svn:executable set to ``*
File size: 17.7 KB

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

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

Context Navigation

source: svn/newcon3bcm2_21bu/dst/dlib/src/PNG/pngtrans.c

Download in other formats: