1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
26 *
27 * This file is available under and governed by the GNU General Public
28 * License version 2 only, as published by the Free Software Foundation.
29 * However, the following notice accompanied the original version of this
30 * file and, per its terms, should not be removed:
31 *
32 * Last changed in libpng 1.6.18 [July 23, 2015]
33 * Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
34 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
35 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
36 *
37 * This code is released under the libpng license.
38 * For conditions of distribution and use, see the disclaimer
39 * and license in png.h
40 */
41
42 #include "pngpriv.h"
43
44 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
45
46 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
47 /* Turn on BGR-to-RGB mapping */
48 void PNGAPI
49 png_set_bgr(png_structrp png_ptr)
50 {
51 png_debug(1, "in png_set_bgr");
52
53 if (png_ptr == NULL)
54 return;
55
56 png_ptr->transformations |= PNG_BGR;
57 }
58 #endif
59
60 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
61 /* Turn on 16-bit byte swapping */
62 void PNGAPI
63 png_set_swap(png_structrp png_ptr)
64 {
65 png_debug(1, "in png_set_swap");
66
67 if (png_ptr == NULL)
68 return;
69
70 if (png_ptr->bit_depth == 16)
71 png_ptr->transformations |= PNG_SWAP_BYTES;
72 }
73 #endif
74
75 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
76 /* Turn on pixel packing */
77 void PNGAPI
78 png_set_packing(png_structrp png_ptr)
79 {
80 png_debug(1, "in png_set_packing");
81
82 if (png_ptr == NULL)
83 return;
84
85 if (png_ptr->bit_depth < 8)
86 {
87 png_ptr->transformations |= PNG_PACK;
88 # ifdef PNG_WRITE_SUPPORTED
89 png_ptr->usr_bit_depth = 8;
90 # endif
91 }
92 }
93 #endif
94
95 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
96 /* Turn on packed pixel swapping */
97 void PNGAPI
98 png_set_packswap(png_structrp png_ptr)
99 {
100 png_debug(1, "in png_set_packswap");
101
102 if (png_ptr == NULL)
103 return;
104
105 if (png_ptr->bit_depth < 8)
106 png_ptr->transformations |= PNG_PACKSWAP;
107 }
108 #endif
109
110 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
111 void PNGAPI
112 png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
113 {
114 png_debug(1, "in png_set_shift");
115
116 if (png_ptr == NULL)
117 return;
118
119 png_ptr->transformations |= PNG_SHIFT;
120 png_ptr->shift = *true_bits;
121 }
122 #endif
123
124 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
125 defined(PNG_WRITE_INTERLACING_SUPPORTED)
126 int PNGAPI
127 png_set_interlace_handling(png_structrp png_ptr)
128 {
129 png_debug(1, "in png_set_interlace handling");
130
131 if (png_ptr != 0 && png_ptr->interlaced != 0)
132 {
133 png_ptr->transformations |= PNG_INTERLACE;
134 return (7);
135 }
136
137 return (1);
138 }
139 #endif
140
141 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
142 /* Add a filler byte on read, or remove a filler or alpha byte on write.
143 * The filler type has changed in v0.95 to allow future 2-byte fillers
144 * for 48-bit input data, as well as to avoid problems with some compilers
145 * that don't like bytes as parameters.
146 */
147 void PNGAPI
148 png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
149 {
150 png_debug(1, "in png_set_filler");
151
152 if (png_ptr == NULL)
153 return;
154
155 /* In libpng 1.6 it is possible to determine whether this is a read or write
156 * operation and therefore to do more checking here for a valid call.
157 */
158 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
159 {
160 # ifdef PNG_READ_FILLER_SUPPORTED
161 /* On read png_set_filler is always valid, regardless of the base PNG
162 * format, because other transformations can give a format where the
163 * filler code can execute (basically an 8 or 16-bit component RGB or G
164 * format.)
165 *
166 * NOTE: usr_channels is not used by the read code! (This has led to
167 * confusion in the past.) The filler is only used in the read code.
168 */
169 png_ptr->filler = (png_uint_16)filler;
170 # else
171 png_app_error(png_ptr, "png_set_filler not supported on read");
172 PNG_UNUSED(filler) /* not used in the write case */
173 return;
174 # endif
175 }
176
177 else /* write */
178 {
179 # ifdef PNG_WRITE_FILLER_SUPPORTED
180 /* On write the usr_channels parameter must be set correctly at the
181 * start to record the number of channels in the app-supplied data.
182 */
183 switch (png_ptr->color_type)
184 {
185 case PNG_COLOR_TYPE_RGB:
186 png_ptr->usr_channels = 4;
187 break;
188
189 case PNG_COLOR_TYPE_GRAY:
190 if (png_ptr->bit_depth >= 8)
191 {
192 png_ptr->usr_channels = 2;
193 break;
194 }
195
196 else
197 {
198 /* There simply isn't any code in libpng to strip out bits
199 * from bytes when the components are less than a byte in
200 * size!
201 */
202 png_app_error(png_ptr,
203 "png_set_filler is invalid for low bit depth gray output");
204 return;
205 }
206
207 default:
208 png_app_error(png_ptr,
209 "png_set_filler: inappropriate color type");
210 return;
211 }
212 # else
213 png_app_error(png_ptr, "png_set_filler not supported on write");
214 return;
215 # endif
216 }
217
218 /* Here on success - libpng supports the operation, set the transformation
219 * and the flag to say where the filler channel is.
220 */
221 png_ptr->transformations |= PNG_FILLER;
222
223 if (filler_loc == PNG_FILLER_AFTER)
224 png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
225
226 else
227 png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
228 }
229
230 /* Added to libpng-1.2.7 */
231 void PNGAPI
232 png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
233 {
234 png_debug(1, "in png_set_add_alpha");
235
236 if (png_ptr == NULL)
237 return;
238
239 png_set_filler(png_ptr, filler, filler_loc);
240 /* The above may fail to do anything. */
241 if ((png_ptr->transformations & PNG_FILLER) != 0)
242 png_ptr->transformations |= PNG_ADD_ALPHA;
243 }
244
245 #endif
246
247 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
248 defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
249 void PNGAPI
250 png_set_swap_alpha(png_structrp png_ptr)
251 {
252 png_debug(1, "in png_set_swap_alpha");
253
254 if (png_ptr == NULL)
255 return;
256
257 png_ptr->transformations |= PNG_SWAP_ALPHA;
258 }
259 #endif
260
261 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
262 defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
263 void PNGAPI
264 png_set_invert_alpha(png_structrp png_ptr)
265 {
266 png_debug(1, "in png_set_invert_alpha");
267
268 if (png_ptr == NULL)
269 return;
270
271 png_ptr->transformations |= PNG_INVERT_ALPHA;
272 }
273 #endif
274
275 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
276 void PNGAPI
277 png_set_invert_mono(png_structrp png_ptr)
278 {
279 png_debug(1, "in png_set_invert_mono");
280
281 if (png_ptr == NULL)
282 return;
283
284 png_ptr->transformations |= PNG_INVERT_MONO;
285 }
286
287 /* Invert monochrome grayscale data */
288 void /* PRIVATE */
289 png_do_invert(png_row_infop row_info, png_bytep row)
290 {
291 png_debug(1, "in png_do_invert");
292
293 /* This test removed from libpng version 1.0.13 and 1.2.0:
294 * if (row_info->bit_depth == 1 &&
295 */
296 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
297 {
298 png_bytep rp = row;
299 png_size_t i;
300 png_size_t istop = row_info->rowbytes;
301
302 for (i = 0; i < istop; i++)
303 {
304 *rp = (png_byte)(~(*rp));
305 rp++;
306 }
307 }
308
309 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
310 row_info->bit_depth == 8)
311 {
312 png_bytep rp = row;
313 png_size_t i;
314 png_size_t istop = row_info->rowbytes;
315
316 for (i = 0; i < istop; i += 2)
317 {
318 *rp = (png_byte)(~(*rp));
319 rp += 2;
320 }
321 }
322
323 #ifdef PNG_16BIT_SUPPORTED
324 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
325 row_info->bit_depth == 16)
326 {
327 png_bytep rp = row;
328 png_size_t i;
329 png_size_t istop = row_info->rowbytes;
330
331 for (i = 0; i < istop; i += 4)
332 {
333 *rp = (png_byte)(~(*rp));
334 *(rp + 1) = (png_byte)(~(*(rp + 1)));
335 rp += 4;
336 }
337 }
338 #endif
339 }
340 #endif
341
342 #ifdef PNG_16BIT_SUPPORTED
343 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
344 /* Swaps byte order on 16-bit depth images */
345 void /* PRIVATE */
346 png_do_swap(png_row_infop row_info, png_bytep row)
347 {
348 png_debug(1, "in png_do_swap");
349
350 if (row_info->bit_depth == 16)
351 {
352 png_bytep rp = row;
353 png_uint_32 i;
354 png_uint_32 istop= row_info->width * row_info->channels;
355
356 for (i = 0; i < istop; i++, rp += 2)
357 {
358 #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
359 /* Feature added to libpng-1.6.11 for testing purposes, not
360 * enabled by default.
361 */
362 *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
363 #else
364 png_byte t = *rp;
365 *rp = *(rp + 1);
366 *(rp + 1) = t;
367 #endif
368 }
369 }
370 }
371 #endif
372 #endif
373
374 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
375 static PNG_CONST png_byte onebppswaptable[256] = {
376 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
377 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
378 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
379 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
380 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
381 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
382 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
383 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
384 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
385 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
386 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
387 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
388 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
389 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
390 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
391 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
392 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
393 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
394 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
395 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
396 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
397 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
398 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
399 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
400 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
401 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
402 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
403 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
404 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
405 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
406 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
407 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
408 };
409
410 static PNG_CONST png_byte twobppswaptable[256] = {
411 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
412 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
413 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
414 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
415 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
416 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
417 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
418 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
419 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
420 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
421 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
422 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
423 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
424 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
425 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
426 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
427 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
428 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
429 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
430 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
431 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
432 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
433 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
434 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
435 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
436 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
437 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
438 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
439 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
440 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
441 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
442 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
443 };
444
445 static PNG_CONST png_byte fourbppswaptable[256] = {
446 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
447 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
448 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
449 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
450 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
451 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
452 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
453 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
454 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
455 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
456 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
457 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
458 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
459 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
460 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
461 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
462 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
463 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
464 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
465 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
466 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
467 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
468 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
469 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
470 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
471 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
472 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
473 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
474 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
475 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
476 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
477 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
478 };
479
480 /* Swaps pixel packing order within bytes */
481 void /* PRIVATE */
482 png_do_packswap(png_row_infop row_info, png_bytep row)
483 {
484 png_debug(1, "in png_do_packswap");
485
486 if (row_info->bit_depth < 8)
487 {
488 png_bytep rp;
489 png_const_bytep end, table;
490
491 end = row + row_info->rowbytes;
492
493 if (row_info->bit_depth == 1)
494 table = onebppswaptable;
495
496 else if (row_info->bit_depth == 2)
497 table = twobppswaptable;
498
499 else if (row_info->bit_depth == 4)
500 table = fourbppswaptable;
501
502 else
503 return;
504
505 for (rp = row; rp < end; rp++)
506 *rp = table[*rp];
507 }
508 }
509 #endif /* PACKSWAP || WRITE_PACKSWAP */
510
511 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
512 defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
513 /* Remove a channel - this used to be 'png_do_strip_filler' but it used a
514 * somewhat weird combination of flags to determine what to do. All the calls
515 * to png_do_strip_filler are changed in 1.5.2 to call this instead with the
516 * correct arguments.
517 *
518 * The routine isn't general - the channel must be the channel at the start or
519 * end (not in the middle) of each pixel.
520 */
521 void /* PRIVATE */
522 png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
523 {
524 png_bytep sp = row; /* source pointer */
525 png_bytep dp = row; /* destination pointer */
526 png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
527
528 /* At the start sp will point to the first byte to copy and dp to where
529 * it is copied to. ep always points just beyond the end of the row, so
530 * the loop simply copies (channels-1) channels until sp reaches ep.
531 *
532 * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
533 * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
534 */
535
536 /* GA, GX, XG cases */
537 if (row_info->channels == 2)
538 {
539 if (row_info->bit_depth == 8)
540 {
541 if (at_start != 0) /* Skip initial filler */
542 ++sp;
543 else /* Skip initial channel and, for sp, the filler */
544 sp += 2, ++dp;
545
546 /* For a 1 pixel wide image there is nothing to do */
547 while (sp < ep)
548 *dp++ = *sp, sp += 2;
549
550 row_info->pixel_depth = 8;
551 }
552
553 else if (row_info->bit_depth == 16)
554 {
555 if (at_start != 0) /* Skip initial filler */
556 sp += 2;
557 else /* Skip initial channel and, for sp, the filler */
558 sp += 4, dp += 2;
559
560 while (sp < ep)
561 *dp++ = *sp++, *dp++ = *sp, sp += 3;
562
563 row_info->pixel_depth = 16;
564 }
565
566 else
567 return; /* bad bit depth */
568
569 row_info->channels = 1;
570
571 /* Finally fix the color type if it records an alpha channel */
572 if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
573 row_info->color_type = PNG_COLOR_TYPE_GRAY;
574 }
575
576 /* RGBA, RGBX, XRGB cases */
577 else if (row_info->channels == 4)
578 {
579 if (row_info->bit_depth == 8)
580 {
581 if (at_start != 0) /* Skip initial filler */
582 ++sp;
583 else /* Skip initial channels and, for sp, the filler */
584 sp += 4, dp += 3;
585
586 /* Note that the loop adds 3 to dp and 4 to sp each time. */
587 while (sp < ep)
588 *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
589
590 row_info->pixel_depth = 24;
591 }
592
593 else if (row_info->bit_depth == 16)
594 {
595 if (at_start != 0) /* Skip initial filler */
596 sp += 2;
597 else /* Skip initial channels and, for sp, the filler */
598 sp += 8, dp += 6;
599
600 while (sp < ep)
601 {
602 /* Copy 6 bytes, skip 2 */
603 *dp++ = *sp++, *dp++ = *sp++;
604 *dp++ = *sp++, *dp++ = *sp++;
605 *dp++ = *sp++, *dp++ = *sp, sp += 3;
606 }
607
608 row_info->pixel_depth = 48;
609 }
610
611 else
612 return; /* bad bit depth */
613
614 row_info->channels = 3;
615
616 /* Finally fix the color type if it records an alpha channel */
617 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
618 row_info->color_type = PNG_COLOR_TYPE_RGB;
619 }
620
621 else
622 return; /* The filler channel has gone already */
623
624 /* Fix the rowbytes value. */
625 row_info->rowbytes = dp-row;
626 }
627 #endif
628
629 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
630 /* Swaps red and blue bytes within a pixel */
631 void /* PRIVATE */
632 png_do_bgr(png_row_infop row_info, png_bytep row)
633 {
634 png_debug(1, "in png_do_bgr");
635
636 if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
637 {
638 png_uint_32 row_width = row_info->width;
639 if (row_info->bit_depth == 8)
640 {
641 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
642 {
643 png_bytep rp;
644 png_uint_32 i;
645
646 for (i = 0, rp = row; i < row_width; i++, rp += 3)
647 {
648 png_byte save = *rp;
649 *rp = *(rp + 2);
650 *(rp + 2) = save;
651 }
652 }
653
654 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
655 {
656 png_bytep rp;
657 png_uint_32 i;
658
659 for (i = 0, rp = row; i < row_width; i++, rp += 4)
660 {
661 png_byte save = *rp;
662 *rp = *(rp + 2);
663 *(rp + 2) = save;
664 }
665 }
666 }
667
668 #ifdef PNG_16BIT_SUPPORTED
669 else if (row_info->bit_depth == 16)
670 {
671 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
672 {
673 png_bytep rp;
674 png_uint_32 i;
675
676 for (i = 0, rp = row; i < row_width; i++, rp += 6)
677 {
678 png_byte save = *rp;
679 *rp = *(rp + 4);
680 *(rp + 4) = save;
681 save = *(rp + 1);
682 *(rp + 1) = *(rp + 5);
683 *(rp + 5) = save;
684 }
685 }
686
687 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
688 {
689 png_bytep rp;
690 png_uint_32 i;
691
692 for (i = 0, rp = row; i < row_width; i++, rp += 8)
693 {
694 png_byte save = *rp;
695 *rp = *(rp + 4);
696 *(rp + 4) = save;
697 save = *(rp + 1);
698 *(rp + 1) = *(rp + 5);
699 *(rp + 5) = save;
700 }
701 }
702 }
703 #endif
704 }
705 }
706 #endif /* READ_BGR || WRITE_BGR */
707
708 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
709 defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
710 /* Added at libpng-1.5.10 */
711 void /* PRIVATE */
712 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
713 {
714 if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
715 png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
716 {
717 /* Calculations moved outside switch in an attempt to stop different
718 * compiler warnings. 'padding' is in *bits* within the last byte, it is
719 * an 'int' because pixel_depth becomes an 'int' in the expression below,
720 * and this calculation is used because it avoids warnings that other
721 * forms produced on either GCC or MSVC.
722 */
723 int padding = (-row_info->pixel_depth * row_info->width) & 7;
724 png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
725
726 switch (row_info->bit_depth)
727 {
728 case 1:
729 {
730 /* in this case, all bytes must be 0 so we don't need
731 * to unpack the pixels except for the rightmost one.
732 */
733 for (; rp > png_ptr->row_buf; rp--)
734 {
735 if ((*rp >> padding) != 0)
736 png_ptr->num_palette_max = 1;
737 padding = 0;
738 }
739
740 break;
741 }
742
743 case 2:
744 {
745 for (; rp > png_ptr->row_buf; rp--)
746 {
747 int i = ((*rp >> padding) & 0x03);
748
749 if (i > png_ptr->num_palette_max)
750 png_ptr->num_palette_max = i;
751
752 i = (((*rp >> padding) >> 2) & 0x03);
753
754 if (i > png_ptr->num_palette_max)
755 png_ptr->num_palette_max = i;
756
757 i = (((*rp >> padding) >> 4) & 0x03);
758
759 if (i > png_ptr->num_palette_max)
760 png_ptr->num_palette_max = i;
761
762 i = (((*rp >> padding) >> 6) & 0x03);
763
764 if (i > png_ptr->num_palette_max)
765 png_ptr->num_palette_max = i;
766
767 padding = 0;
768 }
769
770 break;
771 }
772
773 case 4:
774 {
775 for (; rp > png_ptr->row_buf; rp--)
776 {
777 int i = ((*rp >> padding) & 0x0f);
778
779 if (i > png_ptr->num_palette_max)
780 png_ptr->num_palette_max = i;
781
782 i = (((*rp >> padding) >> 4) & 0x0f);
783
784 if (i > png_ptr->num_palette_max)
785 png_ptr->num_palette_max = i;
786
787 padding = 0;
788 }
789
790 break;
791 }
792
793 case 8:
794 {
795 for (; rp > png_ptr->row_buf; rp--)
796 {
797 if (*rp > png_ptr->num_palette_max)
798 png_ptr->num_palette_max = (int) *rp;
799 }
800
801 break;
802 }
803
804 default:
805 break;
806 }
807 }
808 }
809 #endif /* CHECK_FOR_INVALID_INDEX */
810
811 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
812 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
813 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
814 void PNGAPI
815 png_set_user_transform_info(png_structrp png_ptr, png_voidp
816 user_transform_ptr, int user_transform_depth, int user_transform_channels)
817 {
818 png_debug(1, "in png_set_user_transform_info");
819
820 if (png_ptr == NULL)
821 return;
822
823 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
824 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
825 (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
826 {
827 png_app_error(png_ptr,
828 "info change after png_start_read_image or png_read_update_info");
829 return;
830 }
831 #endif
832
833 png_ptr->user_transform_ptr = user_transform_ptr;
834 png_ptr->user_transform_depth = (png_byte)user_transform_depth;
835 png_ptr->user_transform_channels = (png_byte)user_transform_channels;
836 }
837 #endif
838
839 /* This function returns a pointer to the user_transform_ptr associated with
840 * the user transform functions. The application should free any memory
841 * associated with this pointer before png_write_destroy and png_read_destroy
842 * are called.
843 */
844 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
845 png_voidp PNGAPI
846 png_get_user_transform_ptr(png_const_structrp png_ptr)
847 {
848 if (png_ptr == NULL)
849 return (NULL);
850
851 return png_ptr->user_transform_ptr;
852 }
853 #endif
854
855 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
856 png_uint_32 PNGAPI
857 png_get_current_row_number(png_const_structrp png_ptr)
858 {
859 /* See the comments in png.h - this is the sub-image row when reading an
860 * interlaced image.
861 */
862 if (png_ptr != NULL)
863 return png_ptr->row_number;
864
865 return PNG_UINT_32_MAX; /* help the app not to fail silently */
866 }
867
868 png_byte PNGAPI
869 png_get_current_pass_number(png_const_structrp png_ptr)
870 {
871 if (png_ptr != NULL)
872 return png_ptr->pass;
873 return 8; /* invalid */
874 }
875 #endif /* USER_TRANSFORM_INFO */
876 #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
877 #endif /* READ || WRITE */