]> git.saurik.com Git - wxWidgets.git/blob - src/png/pngwtran.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Reduced deprecation warning frequency
[wxWidgets.git] / src / png / pngwtran.c
1
2 /* pngwtran.c - transforms the data in a row for PNG writers
3 *
4 * libpng version 1.2.7 - September 12, 2004
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2004 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 */
18 void /* PRIVATE */
19 png_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_INVERT_ALPHA_SUPPORTED)
64 if (png_ptr->transformations & PNG_INVERT_ALPHA)
65 png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
66 #endif
67 #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
68 if (png_ptr->transformations & PNG_SWAP_ALPHA)
69 png_do_write_swap_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 */
86 void /* PRIVATE */
87 png_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 */
212 void /* PRIVATE */
213 png_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)
336 void /* PRIVATE */
337 png_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)
424 void /* PRIVATE */
425 png_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 *(dp++) = *(sp++);
443 *(dp++) = *(sp++);
444 *(dp++) = *(sp++);
445 *(dp++) = (png_byte)(255 - *(sp++));
446 }
447 }
448 /* This inverts the alpha channel in RRGGBBAA */
449 else
450 {
451 png_bytep sp, dp;
452 png_uint_32 i;
453 png_uint_32 row_width = row_info->width;
454
455 for (i = 0, sp = dp = row; i < row_width; i++)
456 {
457 *(dp++) = *(sp++);
458 *(dp++) = *(sp++);
459 *(dp++) = *(sp++);
460 *(dp++) = *(sp++);
461 *(dp++) = *(sp++);
462 *(dp++) = *(sp++);
463 *(dp++) = (png_byte)(255 - *(sp++));
464 *(dp++) = (png_byte)(255 - *(sp++));
465 }
466 }
467 }
468 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
469 {
470 /* This inverts the alpha channel in GA */
471 if (row_info->bit_depth == 8)
472 {
473 png_bytep sp, dp;
474 png_uint_32 i;
475 png_uint_32 row_width = row_info->width;
476
477 for (i = 0, sp = dp = row; i < row_width; i++)
478 {
479 *(dp++) = *(sp++);
480 *(dp++) = (png_byte)(255 - *(sp++));
481 }
482 }
483 /* This inverts the alpha channel in GGAA */
484 else
485 {
486 png_bytep sp, dp;
487 png_uint_32 i;
488 png_uint_32 row_width = row_info->width;
489
490 for (i = 0, sp = dp = row; i < row_width; i++)
491 {
492 *(dp++) = *(sp++);
493 *(dp++) = *(sp++);
494 *(dp++) = (png_byte)(255 - *(sp++));
495 *(dp++) = (png_byte)(255 - *(sp++));
496 }
497 }
498 }
499 }
500 }
501 #endif
502
503 #if defined(PNG_MNG_FEATURES_SUPPORTED)
504 /* undoes intrapixel differencing */
505 void /* PRIVATE */
506 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
507 {
508 png_debug(1, "in png_do_write_intrapixel\n");
509 if (
510 #if defined(PNG_USELESS_TESTS_SUPPORTED)
511 row != NULL && row_info != NULL &&
512 #endif
513 (row_info->color_type & PNG_COLOR_MASK_COLOR))
514 {
515 int bytes_per_pixel;
516 png_uint_32 row_width = row_info->width;
517 if (row_info->bit_depth == 8)
518 {
519 png_bytep rp;
520 png_uint_32 i;
521
522 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
523 bytes_per_pixel = 3;
524 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
525 bytes_per_pixel = 4;
526 else
527 return;
528
529 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
530 {
531 *(rp) = (png_byte)((*rp - *(rp+1))&0xff);
532 *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
533 }
534 }
535 else if (row_info->bit_depth == 16)
536 {
537 png_bytep rp;
538 png_uint_32 i;
539
540 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
541 bytes_per_pixel = 6;
542 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
543 bytes_per_pixel = 8;
544 else
545 return;
546
547 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
548 {
549 png_uint_32 s0 = (*(rp ) << 8) | *(rp+1);
550 png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3);
551 png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5);
552 png_uint_32 red = (png_uint_32)((s0-s1) & 0xffffL);
553 png_uint_32 blue = (png_uint_32)((s2-s1) & 0xffffL);
554 *(rp ) = (png_byte)((red >> 8) & 0xff);
555 *(rp+1) = (png_byte)(red & 0xff);
556 *(rp+4) = (png_byte)((blue >> 8) & 0xff);
557 *(rp+5) = (png_byte)(blue & 0xff);
558 }
559 }
560 }
561 }
562 #endif /* PNG_MNG_FEATURES_SUPPORTED */
563 #endif /* PNG_WRITE_SUPPORTED */
wxWidgets (Impactor)