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