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