Change license from Zlib to Libpng
[platform/upstream/libpng.git] / pngwtran.c
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-2002,2004,2006-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 */