The Tor Browser / file comparison

comparison: media/libpng/pngtrans.c

media/libpng/pngtrans.c

branch
TOR_BUG_9701
changeset 8
97036ab72558
equal deleted inserted replaced
-1:000000000000 0:745271c035dc
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 */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial