[DEVENUM]
[reactos.git] / reactos / dll / 3rdparty / 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.11 [June 14, 2012]
5 * Copyright (c) 1998-2012 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 * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
447 * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
448 */
449
450 /* GA, GX, XG cases */
451 if (row_info->channels == 2)
452 {
453 if (row_info->bit_depth == 8)
454 {
455 if (at_start) /* Skip initial filler */
456 ++sp;
457 else /* Skip initial channel and, for sp, the filler */
458 sp += 2, ++dp;
459
460 /* For a 1 pixel wide image there is nothing to do */
461 while (sp < ep)
462 *dp++ = *sp, sp += 2;
463
464 row_info->pixel_depth = 8;
465 }
466
467 else if (row_info->bit_depth == 16)
468 {
469 if (at_start) /* Skip initial filler */
470 sp += 2;
471 else /* Skip initial channel and, for sp, the filler */
472 sp += 4, dp += 2;
473
474 while (sp < ep)
475 *dp++ = *sp++, *dp++ = *sp, sp += 3;
476
477 row_info->pixel_depth = 16;
478 }
479
480 else
481 return; /* bad bit depth */
482
483 row_info->channels = 1;
484
485 /* Finally fix the color type if it records an alpha channel */
486 if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
487 row_info->color_type = PNG_COLOR_TYPE_GRAY;
488 }
489
490 /* RGBA, RGBX, XRGB cases */
491 else if (row_info->channels == 4)
492 {
493 if (row_info->bit_depth == 8)
494 {
495 if (at_start) /* Skip initial filler */
496 ++sp;
497 else /* Skip initial channels and, for sp, the filler */
498 sp += 4, dp += 3;
499
500 /* Note that the loop adds 3 to dp and 4 to sp each time. */
501 while (sp < ep)
502 *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
503
504 row_info->pixel_depth = 24;
505 }
506
507 else if (row_info->bit_depth == 16)
508 {
509 if (at_start) /* Skip initial filler */
510 sp += 2;
511 else /* Skip initial channels and, for sp, the filler */
512 sp += 8, dp += 6;
513
514 while (sp < ep)
515 {
516 /* Copy 6 bytes, skip 2 */
517 *dp++ = *sp++, *dp++ = *sp++;
518 *dp++ = *sp++, *dp++ = *sp++;
519 *dp++ = *sp++, *dp++ = *sp, sp += 3;
520 }
521
522 row_info->pixel_depth = 48;
523 }
524
525 else
526 return; /* bad bit depth */
527
528 row_info->channels = 3;
529
530 /* Finally fix the color type if it records an alpha channel */
531 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
532 row_info->color_type = PNG_COLOR_TYPE_RGB;
533 }
534
535 else
536 return; /* The filler channel has gone already */
537
538 /* Fix the rowbytes value. */
539 row_info->rowbytes = dp-row;
540 }
541 #endif
542
543 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
544 /* Swaps red and blue bytes within a pixel */
545 void /* PRIVATE */
546 png_do_bgr(png_row_infop row_info, png_bytep row)
547 {
548 png_debug(1, "in png_do_bgr");
549
550 if ((row_info->color_type & PNG_COLOR_MASK_COLOR))
551 {
552 png_uint_32 row_width = row_info->width;
553 if (row_info->bit_depth == 8)
554 {
555 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
556 {
557 png_bytep rp;
558 png_uint_32 i;
559
560 for (i = 0, rp = row; i < row_width; i++, rp += 3)
561 {
562 png_byte save = *rp;
563 *rp = *(rp + 2);
564 *(rp + 2) = save;
565 }
566 }
567
568 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
569 {
570 png_bytep rp;
571 png_uint_32 i;
572
573 for (i = 0, rp = row; i < row_width; i++, rp += 4)
574 {
575 png_byte save = *rp;
576 *rp = *(rp + 2);
577 *(rp + 2) = save;
578 }
579 }
580 }
581
582 #ifdef PNG_16BIT_SUPPORTED
583 else if (row_info->bit_depth == 16)
584 {
585 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
586 {
587 png_bytep rp;
588 png_uint_32 i;
589
590 for (i = 0, rp = row; i < row_width; i++, rp += 6)
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 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
602 {
603 png_bytep rp;
604 png_uint_32 i;
605
606 for (i = 0, rp = row; i < row_width; i++, rp += 8)
607 {
608 png_byte save = *rp;
609 *rp = *(rp + 4);
610 *(rp + 4) = save;
611 save = *(rp + 1);
612 *(rp + 1) = *(rp + 5);
613 *(rp + 5) = save;
614 }
615 }
616 }
617 #endif
618 }
619 }
620 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
621
622 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
623 defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
624 /* Added at libpng-1.5.10 */
625 void /* PRIVATE */
626 png_do_check_palette_indexes(png_structp png_ptr, png_row_infop row_info)
627 {
628 if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
629 png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
630 {
631 /* Calculations moved outside switch in an attempt to stop different
632 * compiler warnings. 'padding' is in *bits* within the last byte, it is
633 * an 'int' because pixel_depth becomes an 'int' in the expression below,
634 * and this calculation is used because it avoids warnings that other
635 * forms produced on either GCC or MSVC.
636 */
637 int padding = (-row_info->pixel_depth * row_info->width) & 7;
638 png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
639
640 switch (row_info->bit_depth)
641 {
642 case 1:
643 {
644 /* in this case, all bytes must be 0 so we don't need
645 * to unpack the pixels except for the rightmost one.
646 */
647 for (; rp > png_ptr->row_buf; rp--)
648 {
649 if (*rp >> padding != 0)
650 png_ptr->num_palette_max = 1;
651 padding = 0;
652 }
653
654 break;
655 }
656
657 case 2:
658 {
659 for (; rp > png_ptr->row_buf; rp--)
660 {
661 int i = ((*rp >> padding) & 0x03);
662
663 if (i > png_ptr->num_palette_max)
664 png_ptr->num_palette_max = i;
665
666 i = (((*rp >> padding) >> 2) & 0x03);
667
668 if (i > png_ptr->num_palette_max)
669 png_ptr->num_palette_max = i;
670
671 i = (((*rp >> padding) >> 4) & 0x03);
672
673 if (i > png_ptr->num_palette_max)
674 png_ptr->num_palette_max = i;
675
676 i = (((*rp >> padding) >> 6) & 0x03);
677
678 if (i > png_ptr->num_palette_max)
679 png_ptr->num_palette_max = i;
680
681 padding = 0;
682 }
683
684 break;
685 }
686
687 case 4:
688 {
689 for (; rp > png_ptr->row_buf; rp--)
690 {
691 int i = ((*rp >> padding) & 0x0f);
692
693 if (i > png_ptr->num_palette_max)
694 png_ptr->num_palette_max = i;
695
696 i = (((*rp >> padding) >> 4) & 0x0f);
697
698 if (i > png_ptr->num_palette_max)
699 png_ptr->num_palette_max = i;
700
701 padding = 0;
702 }
703
704 break;
705 }
706
707 case 8:
708 {
709 for (; rp > png_ptr->row_buf; rp--)
710 {
711 if (*rp > png_ptr->num_palette_max)
712 png_ptr->num_palette_max = (int) *rp;
713 }
714
715 break;
716 }
717
718 default:
719 break;
720 }
721 }
722 }
723 #endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */
724
725 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
726 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
727 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
728 void PNGAPI
729 png_set_user_transform_info(png_structp png_ptr, png_voidp
730 user_transform_ptr, int user_transform_depth, int user_transform_channels)
731 {
732 png_debug(1, "in png_set_user_transform_info");
733
734 if (png_ptr == NULL)
735 return;
736 png_ptr->user_transform_ptr = user_transform_ptr;
737 png_ptr->user_transform_depth = (png_byte)user_transform_depth;
738 png_ptr->user_transform_channels = (png_byte)user_transform_channels;
739 }
740 #endif
741
742 /* This function returns a pointer to the user_transform_ptr associated with
743 * the user transform functions. The application should free any memory
744 * associated with this pointer before png_write_destroy and png_read_destroy
745 * are called.
746 */
747 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
748 png_voidp PNGAPI
749 png_get_user_transform_ptr(png_const_structp png_ptr)
750 {
751 if (png_ptr == NULL)
752 return (NULL);
753
754 return ((png_voidp)png_ptr->user_transform_ptr);
755 }
756 #endif
757
758 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
759 png_uint_32 PNGAPI
760 png_get_current_row_number(png_const_structp png_ptr)
761 {
762 /* See the comments in png.h - this is the sub-image row when reading and
763 * interlaced image.
764 */
765 if (png_ptr != NULL)
766 return png_ptr->row_number;
767
768 return PNG_UINT_32_MAX; /* help the app not to fail silently */
769 }
770
771 png_byte PNGAPI
772 png_get_current_pass_number(png_const_structp png_ptr)
773 {
774 if (png_ptr != NULL)
775 return png_ptr->pass;
776 return 8; /* invalid */
777 }
778 #endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */
779 #endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||
780 PNG_WRITE_USER_TRANSFORM_SUPPORTED */
781 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */