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