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