VirtualBox

source: vbox/trunk/src/libs/libpng-1.2.54/pngwtran.c@ 64055

Last change on this file since 64055 was 58796, checked in by vboxsync, 9 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette