src/png/pngwtran.c


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

#define PNG_INTERNAL
#include "../png/png.h"

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

#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_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_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_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
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;

            sp = row;
            dp = row;
            mask = 0x80;
            v = 0;
            for (i = 0; i < row_info->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;

            sp = row;
            dp = row;
            shift = 6;
            v = 0;
            for (i = 0; i < row_info->width; i++)
            {
               png_byte value;

               value = (png_byte)(*sp & 0x3);
               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;

            sp = row;
            dp = row;
            shift = 4;
            v = 0;
            for (i = 0; i < row_info->width; i++)
            {
               png_byte value;

               value = (png_byte)(*sp & 0xf);
               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 =
         ((row_info->width * row_info->pixel_depth + 7) >> 3);
   }
}
#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
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];
      png_uint_32 channels;

      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;
         png_uint_32 i;
         png_byte mask;

         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 (bp = row, i = 0; i < row_info->rowbytes; 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;
         png_uint_32 i;

         for (bp = row, i = 0; i < row_info->width; i++)
         {
            png_uint_32 c;

            for (c = 0; c < channels; c++, bp++)
            {
               png_uint_16 v;
               int j;

               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;

         for (bp = row, i = 0; i < row_info->width * row_info->channels; i++)
         {
            png_uint_32 c;

            for (c = 0; c < channels; c++, bp += 2)
            {
               png_uint_16 value, v;
               int j;

               v = ((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 + 1) = (png_byte)(value & 0xff);
            }
         }
      }
   }
}
#endif

#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void
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_byte save;
            png_uint_32 i;

            for (i = 0, sp = dp = row; i < row_info->width; i++)
            {
               save = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = save;
            }
         }
         /* This converts from AARRGGBB to RRGGBBAA */
         else
         {
            png_bytep sp, dp;
            png_byte save[2];
            png_uint_32 i;

            for (i = 0, sp = dp = row; i < row_info->width; i++)
            {
               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_byte save;
            png_uint_32 i;

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

            for (i = 0, sp = dp = row; i < row_info->width; i++)
            {
               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
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;

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

            for (i = 0, sp = dp = row; i < row_info->width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = 255 - *(sp++);
               *(dp++) = 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;

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

            for (i = 0, sp = dp = row; i < row_info->width; i++)
            {
               *(dp++) = *(sp++);
               *(dp++) = *(sp++);
               *(dp++) = 255 - *(sp++);
               *(dp++) = 255 - *(sp++);
            }
         }
      }
   }
}
#endif
Commit	Line	Data
	1
	2	/* pngwtran.c - transforms the data in a row for PNG writers
	3	*
	4	* libpng 1.0.1
	5	* For conditions of distribution and use, see copyright notice in png.h
	6	* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
	7	* Copyright (c) 1996, 1997 Andreas Dilger
	8	* Copyright (c) 1998, Glenn Randers-Pehrson
	9	* March 15, 1998
	10	*/
	11
	12	#define PNG_INTERNAL
	13	#include "../png/png.h"
	14
	15	/* Transform the data according to the users wishes. The order of
	16	* transformations is significant.
	17	*/
	18	void
	19	png_do_write_transformations(png_structp png_ptr)
	20	{
	21	png_debug(1, "in png_do_write_transformations\n");
	22
	23	#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
	24	if (png_ptr->transformations & PNG_USER_TRANSFORM)
	25	if(png_ptr->write_user_transform_fn != NULL)
	26	((png_ptr->write_user_transform_fn)) / user write transform function */
	27	(png_ptr, /* png_ptr */
	28	&(png_ptr->row_info), /* row_info: */
	29	/* png_uint_32 width; width of row */
	30	/* png_uint_32 rowbytes; number of bytes in row */
	31	/* png_byte color_type; color type of pixels */
	32	/* png_byte bit_depth; bit depth of samples */
	33	/* png_byte channels; number of channels (1-4) */
	34	/* png_byte pixel_depth; bits per pixel (depthchannels) /
	35	png_ptr->row_buf + 1); /* start of pixel data for row */
	36	#endif
	37	#if defined(PNG_WRITE_FILLER_SUPPORTED)
	38	if (png_ptr->transformations & PNG_FILLER)
	39	png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
	40	png_ptr->flags);
	41	#endif
	42	#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
	43	if (png_ptr->transformations & PNG_PACKSWAP)
	44	png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
	45	#endif
	46	#if defined(PNG_WRITE_PACK_SUPPORTED)
	47	if (png_ptr->transformations & PNG_PACK)
	48	png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
	49	(png_uint_32)png_ptr->bit_depth);
	50	#endif
	51	#if defined(PNG_WRITE_SHIFT_SUPPORTED)
	52	if (png_ptr->transformations & PNG_SHIFT)
	53	png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
	54	&(png_ptr->shift));
	55	#endif
	56	#if defined(PNG_WRITE_SWAP_SUPPORTED)
	57	if (png_ptr->transformations & PNG_SWAP_BYTES)
	58	png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
	59	#endif
	60	#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
	61	if (png_ptr->transformations & PNG_INVERT_ALPHA)
	62	png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
	63	#endif
	64	#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
	65	if (png_ptr->transformations & PNG_SWAP_ALPHA)
	66	png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
	67	#endif
	68	#if defined(PNG_WRITE_BGR_SUPPORTED)
	69	if (png_ptr->transformations & PNG_BGR)
	70	png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
	71	#endif
	72	#if defined(PNG_WRITE_INVERT_SUPPORTED)
	73	if (png_ptr->transformations & PNG_INVERT_MONO)
	74	png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
	75	#endif
	76	}
	77
	78	#if defined(PNG_WRITE_PACK_SUPPORTED)
	79	/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The
	80	* row_info bit depth should be 8 (one pixel per byte). The channels
	81	* should be 1 (this only happens on grayscale and paletted images).
	82	*/
	83	void
	84	png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
	85	{
	86	png_debug(1, "in png_do_pack\n");
	87	if (row_info->bit_depth == 8 &&
	88	#if defined(PNG_USELESS_TESTS_SUPPORTED)
	89	row != NULL && row_info != NULL &&
	90	#endif
	91	row_info->channels == 1)
	92	{
	93	switch ((int)bit_depth)
	94	{
	95	case 1:
	96	{
	97	png_bytep sp, dp;
	98	int mask, v;
	99	png_uint_32 i;
	100
	101	sp = row;
	102	dp = row;
	103	mask = 0x80;
	104	v = 0;
	105	for (i = 0; i < row_info->width; i++)
	106	{
	107	if (*sp != 0)
	108	v \|= mask;
	109	sp++;
	110	if (mask > 1)
	111	mask >>= 1;
	112	else
	113	{
	114	mask = 0x80;
	115	*dp = (png_byte)v;
	116	dp++;
	117	v = 0;
	118	}
	119	}
	120	if (mask != 0x80)
	121	*dp = (png_byte)v;
	122	break;
	123	}
	124	case 2:
	125	{
	126	png_bytep sp, dp;
	127	int shift, v;
	128	png_uint_32 i;
	129
	130	sp = row;
	131	dp = row;
	132	shift = 6;
	133	v = 0;
	134	for (i = 0; i < row_info->width; i++)
	135	{
	136	png_byte value;
	137
	138	value = (png_byte)(*sp & 0x3);
	139	v \|= (value << shift);
	140	if (shift == 0)
	141	{
	142	shift = 6;
	143	*dp = (png_byte)v;
	144	dp++;
	145	v = 0;
	146	}
	147	else
	148	shift -= 2;
	149	sp++;
	150	}
	151	if (shift != 6)
	152	*dp = (png_byte)v;
	153	break;
	154	}
	155	case 4:
	156	{
	157	png_bytep sp, dp;
	158	int shift, v;
	159	png_uint_32 i;
	160
	161	sp = row;
	162	dp = row;
	163	shift = 4;
	164	v = 0;
	165	for (i = 0; i < row_info->width; i++)
	166	{
	167	png_byte value;
	168
	169	value = (png_byte)(*sp & 0xf);
	170	v \|= (value << shift);
	171
	172	if (shift == 0)
	173	{
	174	shift = 4;
	175	*dp = (png_byte)v;
	176	dp++;
	177	v = 0;
	178	}
	179	else
	180	shift -= 4;
	181
	182	sp++;
	183	}
	184	if (shift != 4)
	185	*dp = (png_byte)v;
	186	break;
	187	}
	188	}
	189	row_info->bit_depth = (png_byte)bit_depth;
	190	row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
	191	row_info->rowbytes =
	192	((row_info->width * row_info->pixel_depth + 7) >> 3);
	193	}
	194	}
	195	#endif
	196
	197	#if defined(PNG_WRITE_SHIFT_SUPPORTED)
	198	/* Shift pixel values to take advantage of whole range. Pass the
	199	* true number of bits in bit_depth. The row should be packed
	200	* according to row_info->bit_depth. Thus, if you had a row of
	201	* bit depth 4, but the pixels only had values from 0 to 7, you
	202	* would pass 3 as bit_depth, and this routine would translate the
	203	* data to 0 to 15.
	204	*/
	205	void
	206	png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
	207	{
	208	png_debug(1, "in png_do_shift\n");
	209	#if defined(PNG_USELESS_TESTS_SUPPORTED)
	210	if (row != NULL && row_info != NULL &&
	211	#else
	212	if (
	213	#endif
	214	row_info->color_type != PNG_COLOR_TYPE_PALETTE)
	215	{
	216	int shift_start[4], shift_dec[4];
	217	png_uint_32 channels;
	218
	219	channels = 0;
	220	if (row_info->color_type & PNG_COLOR_MASK_COLOR)
	221	{
	222	shift_start[channels] = row_info->bit_depth - bit_depth->red;
	223	shift_dec[channels] = bit_depth->red;
	224	channels++;
	225	shift_start[channels] = row_info->bit_depth - bit_depth->green;
	226	shift_dec[channels] = bit_depth->green;
	227	channels++;
	228	shift_start[channels] = row_info->bit_depth - bit_depth->blue;
	229	shift_dec[channels] = bit_depth->blue;
	230	channels++;
	231	}
	232	else
	233	{
	234	shift_start[channels] = row_info->bit_depth - bit_depth->gray;
	235	shift_dec[channels] = bit_depth->gray;
	236	channels++;
	237	}
	238	if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
	239	{
	240	shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
	241	shift_dec[channels] = bit_depth->alpha;
	242	channels++;
	243	}
	244
	245	/* with low row depths, could only be grayscale, so one channel */
	246	if (row_info->bit_depth < 8)
	247	{
	248	png_bytep bp;
	249	png_uint_32 i;
	250	png_byte mask;
	251
	252	if (bit_depth->gray == 1 && row_info->bit_depth == 2)
	253	mask = 0x55;
	254	else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
	255	mask = 0x11;
	256	else
	257	mask = 0xff;
	258
	259	for (bp = row, i = 0; i < row_info->rowbytes; i++, bp++)
	260	{
	261	png_uint_16 v;
	262	int j;
	263
	264	v = *bp;
	265	*bp = 0;
	266	for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
	267	{
	268	if (j > 0)
	269	*bp \|= (png_byte)((v << j) & 0xff);
	270	else
	271	*bp \|= (png_byte)((v >> (-j)) & mask);
	272	}
	273	}
	274	}
	275	else if (row_info->bit_depth == 8)
	276	{
	277	png_bytep bp;
	278	png_uint_32 i;
	279
	280	for (bp = row, i = 0; i < row_info->width; i++)
	281	{
	282	png_uint_32 c;
	283
	284	for (c = 0; c < channels; c++, bp++)
	285	{
	286	png_uint_16 v;
	287	int j;
	288
	289	v = *bp;
	290	*bp = 0;
	291	for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
	292	{
	293	if (j > 0)
	294	*bp \|= (png_byte)((v << j) & 0xff);
	295	else
	296	*bp \|= (png_byte)((v >> (-j)) & 0xff);
	297	}
	298	}
	299	}
	300	}
	301	else
	302	{
	303	png_bytep bp;
	304	png_uint_32 i;
	305
	306	for (bp = row, i = 0; i < row_info->width * row_info->channels; i++)
	307	{
	308	png_uint_32 c;
	309
	310	for (c = 0; c < channels; c++, bp += 2)
	311	{
	312	png_uint_16 value, v;
	313	int j;
	314
	315	v = ((png_uint_16)(bp) << 8) + (bp + 1);
	316	value = 0;
	317	for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
	318	{
	319	if (j > 0)
	320	value \|= (png_uint_16)((v << j) & (png_uint_16)0xffff);
	321	else
	322	value \|= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
	323	}
	324	*bp = (png_byte)(value >> 8);
	325	*(bp + 1) = (png_byte)(value & 0xff);
	326	}
	327	}
	328	}
	329	}
	330	}
	331	#endif
	332
	333	#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
	334	void
	335	png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
	336	{
	337	png_debug(1, "in png_do_write_swap_alpha\n");
	338	#if defined(PNG_USELESS_TESTS_SUPPORTED)
	339	if (row != NULL && row_info != NULL)
	340	#endif
	341	{
	342	if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
	343	{
	344	/* This converts from ARGB to RGBA */
	345	if (row_info->bit_depth == 8)
	346	{
	347	png_bytep sp, dp;
	348	png_byte save;
	349	png_uint_32 i;
	350
	351	for (i = 0, sp = dp = row; i < row_info->width; i++)
	352	{
	353	save = *(sp++);
	354	(dp++) = (sp++);
	355	(dp++) = (sp++);
	356	(dp++) = (sp++);
	357	*(dp++) = save;
	358	}
	359	}
	360	/* This converts from AARRGGBB to RRGGBBAA */
	361	else
	362	{
	363	png_bytep sp, dp;
	364	png_byte save[2];
	365	png_uint_32 i;
	366
	367	for (i = 0, sp = dp = row; i < row_info->width; i++)
	368	{
	369	save[0] = *(sp++);
	370	save[1] = *(sp++);
	371	(dp++) = (sp++);
	372	(dp++) = (sp++);
	373	(dp++) = (sp++);
	374	(dp++) = (sp++);
	375	(dp++) = (sp++);
	376	(dp++) = (sp++);
	377	*(dp++) = save[0];
	378	*(dp++) = save[1];
	379	}
	380	}
	381	}
	382	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
	383	{
	384	/* This converts from AG to GA */
	385	if (row_info->bit_depth == 8)
	386	{
	387	png_bytep sp, dp;
	388	png_byte save;
	389	png_uint_32 i;
	390
	391	for (i = 0, sp = dp = row; i < row_info->width; i++)
	392	{
	393	save = *(sp++);
	394	(dp++) = (sp++);
	395	*(dp++) = save;
	396	}
	397	}
	398	/* This converts from AAGG to GGAA */
	399	else
	400	{
	401	png_bytep sp, dp;
	402	png_byte save[2];
	403	png_uint_32 i;
	404
	405	for (i = 0, sp = dp = row; i < row_info->width; i++)
	406	{
	407	save[0] = *(sp++);
	408	save[1] = *(sp++);
	409	(dp++) = (sp++);
	410	(dp++) = (sp++);
	411	*(dp++) = save[0];
	412	*(dp++) = save[1];
	413	}
	414	}
	415	}
	416	}
	417	}
	418	#endif
	419
	420	#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
	421	void
	422	png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
	423	{
	424	png_debug(1, "in png_do_write_invert_alpha\n");
	425	#if defined(PNG_USELESS_TESTS_SUPPORTED)
	426	if (row != NULL && row_info != NULL)
	427	#endif
	428	{
	429	if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
	430	{
	431	/* This inverts the alpha channel in RGBA */
	432	if (row_info->bit_depth == 8)
	433	{
	434	png_bytep sp, dp;
	435	png_uint_32 i;
	436
	437	for (i = 0, sp = dp = row; i < row_info->width; i++)
	438	{
	439	(dp++) = (sp++);
	440	(dp++) = (sp++);
	441	(dp++) = (sp++);
	442	(dp++) = 255 - (sp++);
	443	}
	444	}
	445	/* This inverts the alpha channel in RRGGBBAA */
	446	else
	447	{
	448	png_bytep sp, dp;
	449	png_uint_32 i;
	450
	451	for (i = 0, sp = dp = row; i < row_info->width; i++)
	452	{
	453	(dp++) = (sp++);
	454	(dp++) = (sp++);
	455	(dp++) = (sp++);
	456	(dp++) = (sp++);
	457	(dp++) = (sp++);
	458	(dp++) = (sp++);
	459	(dp++) = 255 - (sp++);
	460	(dp++) = 255 - (sp++);
	461	}
	462	}
	463	}
	464	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
	465	{
	466	/* This inverts the alpha channel in GA */
	467	if (row_info->bit_depth == 8)
	468	{
	469	png_bytep sp, dp;
	470	png_uint_32 i;
	471
	472	for (i = 0, sp = dp = row; i < row_info->width; i++)
	473	{
	474	(dp++) = (sp++);
	475	(dp++) = 255 - (sp++);
	476	}
	477	}
	478	/* This inverts the alpha channel in GGAA */
	479	else
	480	{
	481	png_bytep sp, dp;
	482	png_uint_32 i;
	483
	484	for (i = 0, sp = dp = row; i < row_info->width; i++)
	485	{
	486	(dp++) = (sp++);
	487	(dp++) = (sp++);
	488	(dp++) = 255 - (sp++);
	489	(dp++) = 255 - (sp++);
	490	}
	491	}
	492	}
	493	}
	494	}
	495	#endif