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