src/png/pngwtran.c


/* pngwtran.c - transforms the data in a row for PNG writers
 *
 * libpng version 1.2.7 - September 12, 2004
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2004 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
 */

#define PNG_INTERNAL
#include "png.h"
#ifdef PNG_WRITE_SUPPORTED

/* Transform the data according to the user's wishes.  The order of
 * transformations is significant.
 */
void /* PRIVATE */
png_do_write_transformations(png_structp png_ptr)
{
   png_debug(1, "in png_do_write_transformations\n");

   if (png_ptr == NULL)
      return;

#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
   if (png_ptr->transformations & PNG_USER_TRANSFORM)
      if(png_ptr->write_user_transform_fn != NULL)
        (*(png_ptr->write_user_transform_fn)) /* user write transform function */
          (png_ptr,                    /* png_ptr */
           &(png_ptr->row_info),       /* row_info:     */
             /*  png_uint_32 width;          width of row */
             /*  png_uint_32 rowbytes;       number of bytes in row */
             /*  png_byte color_type;        color type of pixels */
             /*  png_byte bit_depth;         bit depth of samples */
             /*  png_byte channels;          number of channels (1-4) */
             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
           png_ptr->row_buf + 1);      /* start of pixel data for row */
#endif
#if defined(PNG_WRITE_FILLER_SUPPORTED)
   if (png_ptr->transformations & PNG_FILLER)
      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
         png_ptr->flags);
#endif
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
   if (png_ptr->transformations & PNG_PACKSWAP)
      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
#if defined(PNG_WRITE_PACK_SUPPORTED)
   if (png_ptr->transformations & PNG_PACK)
      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
         (png_uint_32)png_ptr->bit_depth);
#endif
#if defined(PNG_WRITE_SWAP_SUPPORTED)
   if (png_ptr->transformations & PNG_SWAP_BYTES)
      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
#if defined(PNG_WRITE_SHIFT_SUPPORTED)
   if (png_ptr->transformations & PNG_SHIFT)
      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
         &(png_ptr->shift));
#endif
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
   if (png_ptr->transformations & PNG_INVERT_ALPHA)
      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
   if (png_ptr->transformations & PNG_SWAP_ALPHA)
      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
#if defined(PNG_WRITE_BGR_SUPPORTED)
   if (png_ptr->transformations & PNG_BGR)
      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
#if defined(PNG_WRITE_INVERT_SUPPORTED)
   if (png_ptr->transformations & PNG_INVERT_MONO)
      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif
}

#if defined(PNG_WRITE_PACK_SUPPORTED)
/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
 * row_info bit depth should be 8 (one pixel per byte).  The channels
 * should be 1 (this only happens on grayscale and paletted images).
 */
void /* PRIVATE */
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
{
   png_debug(1, "in png_do_pack\n");
   if (row_info->bit_depth == 8 &&
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
      row_info->channels == 1)
   {
      switch ((int)bit_depth)
      {
         case 1:
         {
            png_bytep sp, dp;
            int mask, v;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            sp = row;
            dp = row;
            mask = 0x80;
            v = 0;

            for (i = 0; i < row_width; i++)
            {
               if (*sp != 0)
                  v |= mask;
               sp++;
               if (mask > 1)
                  mask >>= 1;
               else
               {
                  mask = 0x80;
                  *dp = (png_byte)v;
                  dp++;
                  v = 0;
               }
            }
            if (mask != 0x80)
               *dp = (png_byte)v;
            break;
         }
         case 2:
         {
            png_bytep sp, dp;
            int shift, v;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            sp = row;
            dp = row;
            shift = 6;
            v = 0;
            for (i = 0; i < row_width; i++)
            {
               png_byte value;

               value = (png_byte)(*sp & 0x03);
               v |= (value << shift);
               if (shift == 0)
               {
                  shift = 6;
                  *dp = (png_byte)v;
                  dp++;
                  v = 0;
               }
               else
                  shift -= 2;
               sp++;
            }
            if (shift != 6)
               *dp = (png_byte)v;
            break;
         }
         case 4:
         {
            png_bytep sp, dp;
            int shift, v;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            sp = row;
            dp = row;
            shift = 4;
            v = 0;
            for (i = 0; i < row_width; i++)
            {
               png_byte value;

               value = (png_byte)(*sp & 0x0f);
               v |= (value << shift);

               if (shift == 0)
               {
                  shift = 4;
                  *dp = (png_byte)v;
                  dp++;
                  v = 0;
               }
               else
                  shift -= 4;

               sp++;
            }
            if (shift != 4)
               *dp = (png_byte)v;
            break;
         }
      }
      row_info->bit_depth = (png_byte)bit_depth;
      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
         row_info->width);
   }
}
#endif

#if defined(PNG_WRITE_SHIFT_SUPPORTED)
/* Shift pixel values to take advantage of whole range.  Pass the
 * true number of bits in bit_depth.  The row should be packed
 * according to row_info->bit_depth.  Thus, if you had a row of
 * bit depth 4, but the pixels only had values from 0 to 7, you
 * would pass 3 as bit_depth, and this routine would translate the
 * data to 0 to 15.
 */
void /* PRIVATE */
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
{
   png_debug(1, "in png_do_shift\n");
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row != NULL && row_info != NULL &&
#else
   if (
#endif
      row_info->color_type != PNG_COLOR_TYPE_PALETTE)
   {
      int shift_start[4], shift_dec[4];
      int channels = 0;

      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
      {
         shift_start[channels] = row_info->bit_depth - bit_depth->red;
         shift_dec[channels] = bit_depth->red;
         channels++;
         shift_start[channels] = row_info->bit_depth - bit_depth->green;
         shift_dec[channels] = bit_depth->green;
         channels++;
         shift_start[channels] = row_info->bit_depth - bit_depth->blue;
         shift_dec[channels] = bit_depth->blue;
         channels++;
      }
      else
      {
         shift_start[channels] = row_info->bit_depth - bit_depth->gray;
         shift_dec[channels] = bit_depth->gray;
         channels++;
      }
      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
      {
         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
         shift_dec[channels] = bit_depth->alpha;
         channels++;
      }

      /* with low row depths, could only be grayscale, so one channel */
      if (row_info->bit_depth < 8)
      {
         png_bytep bp = row;
         png_uint_32 i;
         png_byte mask;
         png_uint_32 row_bytes = row_info->rowbytes;

         if (bit_depth->gray == 1 && row_info->bit_depth == 2)
            mask = 0x55;
         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
            mask = 0x11;
         else
            mask = 0xff;

         for (i = 0; i < row_bytes; i++, bp++)
         {
            png_uint_16 v;
            int j;

            v = *bp;
            *bp = 0;
            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
            {
               if (j > 0)
                  *bp |= (png_byte)((v << j) & 0xff);
               else
                  *bp |= (png_byte)((v >> (-j)) & mask);
            }
         }
      }
      else if (row_info->bit_depth == 8)
      {
         png_bytep bp = row;
         png_uint_32 i;
         png_uint_32 istop = channels * row_info->width;

         for (i = 0; i < istop; i++, bp++)
         {

            png_uint_16 v;
            int j;
            int c = (int)(i%channels);

            v = *bp;
            *bp = 0;
            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
            {
               if (j > 0)
                  *bp |= (png_byte)((v << j) & 0xff);
               else
                  *bp |= (png_byte)((v >> (-j)) & 0xff);
            }
         }
      }
      else
      {
         png_bytep bp;
         png_uint_32 i;
         png_uint_32 istop = channels * row_info->width;

         for (bp = row, i = 0; i < istop; i++)
         {
            int c = (int)(i%channels);
            png_uint_16 value, v;
            int j;

            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
            value = 0;
            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
            {
               if (j > 0)
                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
               else
                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
            }
            *bp++ = (png_byte)(value >> 8);
            *bp++ = (png_byte)(value & 0xff);
         }
      }
   }
}
#endif

#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void /* PRIVATE */
png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_write_swap_alpha\n");
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row != NULL && row_info != NULL)
#endif
   {
      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
      {
         /* This converts from ARGB to RGBA */
         if (row_info->bit_depth == 8)
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;
            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               png_byte save = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = save;
            }
         }
         /* This converts from AARRGGBB to RRGGBBAA */
         else
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               png_byte save[2];
               save[0] = *(sp++);
               save[1] = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = save[0];
               *(dp++) = save[1];
            }
         }
      }
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
      {
         /* This converts from AG to GA */
         if (row_info->bit_depth == 8)
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               png_byte save = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = save;
            }
         }
         /* This converts from AAGG to GGAA */
         else
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               png_byte save[2];
               save[0] = *(sp++);
               save[1] = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = save[0];
               *(dp++) = save[1];
            }
         }
      }
   }
}
#endif

#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
void /* PRIVATE */
png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_write_invert_alpha\n");
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row != NULL && row_info != NULL)
#endif
   {
      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
      {
         /* This inverts the alpha channel in RGBA */
         if (row_info->bit_depth == 8)
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;
            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = (png_byte)(255 - *(sp++));
            }
         }
         /* This inverts the alpha channel in RRGGBBAA */
         else
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = (png_byte)(255 - *(sp++));
               *(dp++) = (png_byte)(255 - *(sp++));
            }
         }
      }
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
      {
         /* This inverts the alpha channel in GA */
         if (row_info->bit_depth == 8)
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = (png_byte)(255 - *(sp++));
            }
         }
         /* This inverts the alpha channel in GGAA */
         else
         {
            png_bytep sp, dp;
            png_uint_32 i;
            png_uint_32 row_width = row_info->width;

            for (i = 0, sp = dp = row; i < row_width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = (png_byte)(255 - *(sp++));
               *(dp++) = (png_byte)(255 - *(sp++));
            }
         }
      }
   }
}
#endif

#if defined(PNG_MNG_FEATURES_SUPPORTED)
/* undoes intrapixel differencing  */
void /* PRIVATE */
png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_write_intrapixel\n");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       (row_info->color_type & PNG_COLOR_MASK_COLOR))
   {
      int bytes_per_pixel;
      png_uint_32 row_width = row_info->width;
      if (row_info->bit_depth == 8)
      {
         png_bytep rp;
         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
            bytes_per_pixel = 3;
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
            bytes_per_pixel = 4;
         else
            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
         {
            *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);
            *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
         }
      }
      else if (row_info->bit_depth == 16)
      {
         png_bytep rp;
         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
            bytes_per_pixel = 6;
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
            bytes_per_pixel = 8;
         else
            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
         {
            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);
            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);
            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);
            png_uint_32 red  = (png_uint_32)((s0-s1) & 0xffffL);
            png_uint_32 blue = (png_uint_32)((s2-s1) & 0xffffL);
            *(rp  ) = (png_byte)((red >> 8) & 0xff);
            *(rp+1) = (png_byte)(red & 0xff);
            *(rp+4) = (png_byte)((blue >> 8) & 0xff);
            *(rp+5) = (png_byte)(blue & 0xff);
         }
      }
   }
}
#endif /* PNG_MNG_FEATURES_SUPPORTED */
#endif /* PNG_WRITE_SUPPORTED */
Commit	Line	Data
	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 (depthchannels) /
	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 */