The Tor Browser / file comparison

comparison: media/libpng/pngwtran.c

media/libpng/pngwtran.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:be0f49de31e7
1
2 /* pngwtran.c - transforms the data in a row for PNG 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 #ifdef PNG_WRITE_SUPPORTED
17 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
18
19 #ifdef PNG_WRITE_PACK_SUPPORTED
20 /* Pack pixels into bytes. Pass the true bit depth in bit_depth. The
21 * row_info bit depth should be 8 (one pixel per byte). The channels
22 * should be 1 (this only happens on grayscale and paletted images).
23 */
24 static void
25 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
26 {
27 png_debug(1, "in png_do_pack");
28
29 if (row_info->bit_depth == 8 &&
30 row_info->channels == 1)
31 {
32 switch ((int)bit_depth)
33 {
34 case 1:
35 {
36 png_bytep sp, dp;
37 int mask, v;
38 png_uint_32 i;
39 png_uint_32 row_width = row_info->width;
40
41 sp = row;
42 dp = row;
43 mask = 0x80;
44 v = 0;
45
46 for (i = 0; i < row_width; i++)
47 {
48 if (*sp != 0)
49 v |= mask;
50
51 sp++;
52
53 if (mask > 1)
54 mask >>= 1;
55
56 else
57 {
58 mask = 0x80;
59 *dp = (png_byte)v;
60 dp++;
61 v = 0;
62 }
63 }
64
65 if (mask != 0x80)
66 *dp = (png_byte)v;
67
68 break;
69 }
70
71 case 2:
72 {
73 png_bytep sp, dp;
74 int shift, v;
75 png_uint_32 i;
76 png_uint_32 row_width = row_info->width;
77
78 sp = row;
79 dp = row;
80 shift = 6;
81 v = 0;
82
83 for (i = 0; i < row_width; i++)
84 {
85 png_byte value;
86
87 value = (png_byte)(*sp & 0x03);
88 v |= (value << shift);
89
90 if (shift == 0)
91 {
92 shift = 6;
93 *dp = (png_byte)v;
94 dp++;
95 v = 0;
96 }
97
98 else
99 shift -= 2;
100
101 sp++;
102 }
103
104 if (shift != 6)
105 *dp = (png_byte)v;
106
107 break;
108 }
109
110 case 4:
111 {
112 png_bytep sp, dp;
113 int shift, v;
114 png_uint_32 i;
115 png_uint_32 row_width = row_info->width;
116
117 sp = row;
118 dp = row;
119 shift = 4;
120 v = 0;
121
122 for (i = 0; i < row_width; i++)
123 {
124 png_byte value;
125
126 value = (png_byte)(*sp & 0x0f);
127 v |= (value << shift);
128
129 if (shift == 0)
130 {
131 shift = 4;
132 *dp = (png_byte)v;
133 dp++;
134 v = 0;
135 }
136
137 else
138 shift -= 4;
139
140 sp++;
141 }
142
143 if (shift != 4)
144 *dp = (png_byte)v;
145
146 break;
147 }
148
149 default:
150 break;
151 }
152
153 row_info->bit_depth = (png_byte)bit_depth;
154 row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
155 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
156 row_info->width);
157 }
158 }
159 #endif
160
161 #ifdef PNG_WRITE_SHIFT_SUPPORTED
162 /* Shift pixel values to take advantage of whole range. Pass the
163 * true number of bits in bit_depth. The row should be packed
164 * according to row_info->bit_depth. Thus, if you had a row of
165 * bit depth 4, but the pixels only had values from 0 to 7, you
166 * would pass 3 as bit_depth, and this routine would translate the
167 * data to 0 to 15.
168 */
169 static void
170 png_do_shift(png_row_infop row_info, png_bytep row,
171 png_const_color_8p bit_depth)
172 {
173 png_debug(1, "in png_do_shift");
174
175 if (row_info->color_type != PNG_COLOR_TYPE_PALETTE)
176 {
177 int shift_start[4], shift_dec[4];
178 int channels = 0;
179
180 if (row_info->color_type & PNG_COLOR_MASK_COLOR)
181 {
182 shift_start[channels] = row_info->bit_depth - bit_depth->red;
183 shift_dec[channels] = bit_depth->red;
184 channels++;
185
186 shift_start[channels] = row_info->bit_depth - bit_depth->green;
187 shift_dec[channels] = bit_depth->green;
188 channels++;
189
190 shift_start[channels] = row_info->bit_depth - bit_depth->blue;
191 shift_dec[channels] = bit_depth->blue;
192 channels++;
193 }
194
195 else
196 {
197 shift_start[channels] = row_info->bit_depth - bit_depth->gray;
198 shift_dec[channels] = bit_depth->gray;
199 channels++;
200 }
201
202 if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
203 {
204 shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
205 shift_dec[channels] = bit_depth->alpha;
206 channels++;
207 }
208
209 /* With low row depths, could only be grayscale, so one channel */
210 if (row_info->bit_depth < 8)
211 {
212 png_bytep bp = row;
213 png_size_t i;
214 unsigned int mask;
215 png_size_t row_bytes = row_info->rowbytes;
216
217 if (bit_depth->gray == 1 && row_info->bit_depth == 2)
218 mask = 0x55;
219
220 else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
221 mask = 0x11;
222
223 else
224 mask = 0xff;
225
226 for (i = 0; i < row_bytes; i++, bp++)
227 {
228 int j;
229 unsigned int v, out;
230
231 v = *bp;
232 out = 0;
233
234 for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
235 {
236 if (j > 0)
237 out |= v << j;
238
239 else
240 out |= (v >> (-j)) & mask;
241 }
242
243 *bp = (png_byte)(out & 0xff);
244 }
245 }
246
247 else if (row_info->bit_depth == 8)
248 {
249 png_bytep bp = row;
250 png_uint_32 i;
251 png_uint_32 istop = channels * row_info->width;
252
253 for (i = 0; i < istop; i++, bp++)
254 {
255
256 const unsigned int c = i%channels;
257 int j;
258 unsigned int v, out;
259
260 v = *bp;
261 out = 0;
262
263 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
264 {
265 if (j > 0)
266 out |= v << j;
267
268 else
269 out |= v >> (-j);
270 }
271
272 *bp = (png_byte)(out & 0xff);
273 }
274 }
275
276 else
277 {
278 png_bytep bp;
279 png_uint_32 i;
280 png_uint_32 istop = channels * row_info->width;
281
282 for (bp = row, i = 0; i < istop; i++)
283 {
284 const unsigned int c = i%channels;
285 int j;
286 unsigned int value, v;
287
288 v = png_get_uint_16(bp);
289 value = 0;
290
291 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
292 {
293 if (j > 0)
294 value |= v << j;
295
296 else
297 value |= v >> (-j);
298 }
299 *bp++ = (png_byte)((value >> 8) & 0xff);
300 *bp++ = (png_byte)(value & 0xff);
301 }
302 }
303 }
304 }
305 #endif
306
307 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
308 static void
309 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
310 {
311 png_debug(1, "in png_do_write_swap_alpha");
312
313 {
314 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
315 {
316 if (row_info->bit_depth == 8)
317 {
318 /* This converts from ARGB to RGBA */
319 png_bytep sp, dp;
320 png_uint_32 i;
321 png_uint_32 row_width = row_info->width;
322
323 for (i = 0, sp = dp = row; i < row_width; i++)
324 {
325 png_byte save = *(sp++);
326 *(dp++) = *(sp++);
327 *(dp++) = *(sp++);
328 *(dp++) = *(sp++);
329 *(dp++) = save;
330 }
331 }
332
333 #ifdef PNG_WRITE_16BIT_SUPPORTED
334 else
335 {
336 /* This converts from AARRGGBB to RRGGBBAA */
337 png_bytep sp, dp;
338 png_uint_32 i;
339 png_uint_32 row_width = row_info->width;
340
341 for (i = 0, sp = dp = row; i < row_width; i++)
342 {
343 png_byte save[2];
344 save[0] = *(sp++);
345 save[1] = *(sp++);
346 *(dp++) = *(sp++);
347 *(dp++) = *(sp++);
348 *(dp++) = *(sp++);
349 *(dp++) = *(sp++);
350 *(dp++) = *(sp++);
351 *(dp++) = *(sp++);
352 *(dp++) = save[0];
353 *(dp++) = save[1];
354 }
355 }
356 #endif /* PNG_WRITE_16BIT_SUPPORTED */
357 }
358
359 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
360 {
361 if (row_info->bit_depth == 8)
362 {
363 /* This converts from AG to GA */
364 png_bytep sp, dp;
365 png_uint_32 i;
366 png_uint_32 row_width = row_info->width;
367
368 for (i = 0, sp = dp = row; i < row_width; i++)
369 {
370 png_byte save = *(sp++);
371 *(dp++) = *(sp++);
372 *(dp++) = save;
373 }
374 }
375
376 #ifdef PNG_WRITE_16BIT_SUPPORTED
377 else
378 {
379 /* This converts from AAGG to GGAA */
380 png_bytep sp, dp;
381 png_uint_32 i;
382 png_uint_32 row_width = row_info->width;
383
384 for (i = 0, sp = dp = row; i < row_width; i++)
385 {
386 png_byte save[2];
387 save[0] = *(sp++);
388 save[1] = *(sp++);
389 *(dp++) = *(sp++);
390 *(dp++) = *(sp++);
391 *(dp++) = save[0];
392 *(dp++) = save[1];
393 }
394 }
395 #endif /* PNG_WRITE_16BIT_SUPPORTED */
396 }
397 }
398 }
399 #endif
400
401 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
402 static void
403 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
404 {
405 png_debug(1, "in png_do_write_invert_alpha");
406
407 {
408 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
409 {
410 if (row_info->bit_depth == 8)
411 {
412 /* This inverts the alpha channel in RGBA */
413 png_bytep sp, dp;
414 png_uint_32 i;
415 png_uint_32 row_width = row_info->width;
416
417 for (i = 0, sp = dp = row; i < row_width; i++)
418 {
419 /* Does nothing
420 *(dp++) = *(sp++);
421 *(dp++) = *(sp++);
422 *(dp++) = *(sp++);
423 */
424 sp+=3; dp = sp;
425 *(dp++) = (png_byte)(255 - *(sp++));
426 }
427 }
428
429 #ifdef PNG_WRITE_16BIT_SUPPORTED
430 else
431 {
432 /* This inverts the alpha channel in RRGGBBAA */
433 png_bytep sp, dp;
434 png_uint_32 i;
435 png_uint_32 row_width = row_info->width;
436
437 for (i = 0, sp = dp = row; i < row_width; i++)
438 {
439 /* Does nothing
440 *(dp++) = *(sp++);
441 *(dp++) = *(sp++);
442 *(dp++) = *(sp++);
443 *(dp++) = *(sp++);
444 *(dp++) = *(sp++);
445 *(dp++) = *(sp++);
446 */
447 sp+=6; dp = sp;
448 *(dp++) = (png_byte)(255 - *(sp++));
449 *(dp++) = (png_byte)(255 - *(sp++));
450 }
451 }
452 #endif /* PNG_WRITE_16BIT_SUPPORTED */
453 }
454
455 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
456 {
457 if (row_info->bit_depth == 8)
458 {
459 /* This inverts the alpha channel in GA */
460 png_bytep sp, dp;
461 png_uint_32 i;
462 png_uint_32 row_width = row_info->width;
463
464 for (i = 0, sp = dp = row; i < row_width; i++)
465 {
466 *(dp++) = *(sp++);
467 *(dp++) = (png_byte)(255 - *(sp++));
468 }
469 }
470
471 #ifdef PNG_WRITE_16BIT_SUPPORTED
472 else
473 {
474 /* This inverts the alpha channel in GGAA */
475 png_bytep sp, dp;
476 png_uint_32 i;
477 png_uint_32 row_width = row_info->width;
478
479 for (i = 0, sp = dp = row; i < row_width; i++)
480 {
481 /* Does nothing
482 *(dp++) = *(sp++);
483 *(dp++) = *(sp++);
484 */
485 sp+=2; dp = sp;
486 *(dp++) = (png_byte)(255 - *(sp++));
487 *(dp++) = (png_byte)(255 - *(sp++));
488 }
489 }
490 #endif /* PNG_WRITE_16BIT_SUPPORTED */
491 }
492 }
493 }
494 #endif
495
496 /* Transform the data according to the user's wishes. The order of
497 * transformations is significant.
498 */
499 void /* PRIVATE */
500 png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
501 {
502 png_debug(1, "in png_do_write_transformations");
503
504 if (png_ptr == NULL)
505 return;
506
507 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
508 if (png_ptr->transformations & PNG_USER_TRANSFORM)
509 if (png_ptr->write_user_transform_fn != NULL)
510 (*(png_ptr->write_user_transform_fn)) /* User write transform
511 function */
512 (png_ptr, /* png_ptr */
513 row_info, /* row_info: */
514 /* png_uint_32 width; width of row */
515 /* png_size_t rowbytes; number of bytes in row */
516 /* png_byte color_type; color type of pixels */
517 /* png_byte bit_depth; bit depth of samples */
518 /* png_byte channels; number of channels (1-4) */
519 /* png_byte pixel_depth; bits per pixel (depth*channels) */
520 png_ptr->row_buf + 1); /* start of pixel data for row */
521 #endif
522
523 #ifdef PNG_WRITE_FILLER_SUPPORTED
524 if (png_ptr->transformations & PNG_FILLER)
525 png_do_strip_channel(row_info, png_ptr->row_buf + 1,
526 !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
527 #endif
528
529 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
530 if (png_ptr->transformations & PNG_PACKSWAP)
531 png_do_packswap(row_info, png_ptr->row_buf + 1);
532 #endif
533
534 #ifdef PNG_WRITE_PACK_SUPPORTED
535 if (png_ptr->transformations & PNG_PACK)
536 png_do_pack(row_info, png_ptr->row_buf + 1,
537 (png_uint_32)png_ptr->bit_depth);
538 #endif
539
540 #ifdef PNG_WRITE_SWAP_SUPPORTED
541 if (png_ptr->transformations & PNG_SWAP_BYTES)
542 png_do_swap(row_info, png_ptr->row_buf + 1);
543 #endif
544
545 #ifdef PNG_WRITE_SHIFT_SUPPORTED
546 if (png_ptr->transformations & PNG_SHIFT)
547 png_do_shift(row_info, png_ptr->row_buf + 1,
548 &(png_ptr->shift));
549 #endif
550
551 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
552 if (png_ptr->transformations & PNG_SWAP_ALPHA)
553 png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
554 #endif
555
556 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
557 if (png_ptr->transformations & PNG_INVERT_ALPHA)
558 png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
559 #endif
560
561 #ifdef PNG_WRITE_BGR_SUPPORTED
562 if (png_ptr->transformations & PNG_BGR)
563 png_do_bgr(row_info, png_ptr->row_buf + 1);
564 #endif
565
566 #ifdef PNG_WRITE_INVERT_SUPPORTED
567 if (png_ptr->transformations & PNG_INVERT_MONO)
568 png_do_invert(row_info, png_ptr->row_buf + 1);
569 #endif
570 }
571 #endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
572 #endif /* PNG_WRITE_SUPPORTED */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial