source: liacs/MIR2010/SourceCode/cximage/png/pngwtran.c@ 134

Last change on this file since 134 was 95, checked in by Rick van der Zwet, 15 years ago

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