PageRenderTime 88ms CodeModel.GetById 19ms app.highlight 65ms RepoModel.GetById 1ms app.codeStats 0ms

/src/FreeImage/Source/LibPNG/pngwtran.c

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