/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/png/pngtrans.c
ViewVC logotype

Annotation of /trunk/3rdparty/wxWidgets/src/png/pngtrans.c

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22