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