[wxWidgets.git] / src / png / pngtrans.c


/* pngtrans.c - transforms the data in a row (used by both readers and 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"

#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* turn on bgr to rgb mapping */
void
png_set_bgr(png_structp png_ptr)
{
   png_debug(1, "in png_set_bgr\n");
   png_ptr->transformations |= PNG_BGR;
}
#endif

#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* turn on 16 bit byte swapping */
void
png_set_swap(png_structp png_ptr)
{
   png_debug(1, "in png_set_swap\n");
   if (png_ptr->bit_depth == 16)
      png_ptr->transformations |= PNG_SWAP_BYTES;
}
#endif

#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
/* turn on pixel packing */
void
png_set_packing(png_structp png_ptr)
{
   png_debug(1, "in png_set_packing\n");
   if (png_ptr->bit_depth < 8)
   {
      png_ptr->transformations |= PNG_PACK;
      png_ptr->usr_bit_depth = 8;
   }
}
#endif

#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* turn on packed pixel swapping */
void
png_set_packswap(png_structp png_ptr)
{
   png_debug(1, "in png_set_packswap\n");
   if (png_ptr->bit_depth < 8)
      png_ptr->transformations |= PNG_PACKSWAP;
}
#endif

#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
void
png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{
   png_debug(1, "in png_set_shift\n");
   png_ptr->transformations |= PNG_SHIFT;
   png_ptr->shift = *true_bits;
}
#endif

#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
    defined(PNG_WRITE_INTERLACING_SUPPORTED)
int
png_set_interlace_handling(png_structp png_ptr)
{
   png_debug(1, "in png_set_interlace handling\n");
   if (png_ptr->interlaced)
   {
      png_ptr->transformations |= PNG_INTERLACE;
      return (7);
   }

   return (1);
}
#endif

#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
/* Add a filler byte on read, or remove a filler or alpha byte on write.
 * The filler type has changed in v0.95 to allow future 2-byte fillers
 * for 48-bit input data, as well as avoiding problems with some compilers
 * which don't like bytes as parameters.
 */
void
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
   png_debug(1, "in png_set_filler\n");
   png_ptr->transformations |= PNG_FILLER;
   png_ptr->filler = (png_byte)filler;
   if (filler_loc == PNG_FILLER_AFTER)
      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
   else
      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

   /* This should probably go in the "do_filler" routine */
   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB && png_ptr->bit_depth == 8)
   {
      png_ptr->usr_channels = 4;
   }
}
#endif

#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void
png_set_swap_alpha(png_structp png_ptr)
{
   png_debug(1, "in png_set_swap_alpha\n");
   png_ptr->transformations |= PNG_SWAP_ALPHA;
}
#endif

#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
void
png_set_invert_alpha(png_structp png_ptr)
{
   png_debug(1, "in png_set_invert_alpha\n");
   png_ptr->transformations |= PNG_INVERT_ALPHA;
}
#endif

#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
void
png_set_invert_mono(png_structp png_ptr)
{
   png_debug(1, "in png_set_invert_mono\n");
   png_ptr->transformations |= PNG_INVERT_MONO;
}

/* invert monocrome grayscale data */
void
png_do_invert(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_invert\n");
   if (row_info->bit_depth == 1 &&
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       row_info->color_type == PNG_COLOR_TYPE_GRAY)
   {
      png_bytep rp;
      png_uint_32 i;

      for (i = 0, rp = row; i < row_info->rowbytes; i++, rp++)
      {
         *rp = (png_byte)(~(*rp));
      }
   }
}
#endif

#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* swaps byte order on 16 bit depth images */
void
png_do_swap(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_swap\n");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       row_info->bit_depth == 16)
   {
      png_bytep rp;
      png_byte t;
      png_uint_32 i;

      for (i = 0, rp = row;
         i < row_info->width * row_info->channels;
         i++, rp += 2)
      {
         t = *rp;
         *rp = *(rp + 1);
         *(rp + 1) = t;
      }
   }
}
#endif

#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
static png_byte onebppswaptable[256] = {
   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};

static png_byte twobppswaptable[256] = {
   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
};

static png_byte fourbppswaptable[256] = {
   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
};

/* swaps pixel packing order within bytes */
void
png_do_packswap(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_packswap\n");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       row_info->bit_depth < 8)
   {
      png_bytep rp, end, table;

      end = row + row_info->rowbytes;

      if (row_info->bit_depth == 1)
         table = onebppswaptable;
      else if (row_info->bit_depth == 2)
         table = twobppswaptable;
      else if (row_info->bit_depth == 4)
         table = fourbppswaptable;
      else
         return;

      for (rp = row; rp < end; rp++)
         *rp = table[*rp];
   }
}
#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */

#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
/* remove filler or alpha byte(s) */
void
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{
   png_debug(1, "in png_do_strip_filler\n");
#if defined(PNG_USELESS_TESTS_SUPPORTED)
   if (row != NULL && row_info != NULL)
#endif
   {
/*
      if (row_info->color_type == PNG_COLOR_TYPE_RGB ||
          row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
*/
      if (row_info->channels == 4)
      {
         if (row_info->bit_depth == 8)
         {
            /* This converts from RGBX or RGBA to RGB */
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               png_bytep sp, dp;
               png_uint_32 i;

               for (i = 1, sp = row + 4, dp = row + 3; i < row_info->width; i++)
               {
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp++;
               }
            }
            /* This converts from XRGB or ARGB to RGB */
            else
            {
               png_bytep sp, dp;
               png_uint_32 i;

               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
               {
                  sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 24;
            row_info->rowbytes = row_info->width * 3;
         }
         else /* if (row_info->bit_depth == 16) */
         {
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               png_bytep sp, dp;
               png_uint_32 i;

               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
               for (i = 1, sp = row + 8, dp = row + 6; i < row_info->width; i++)
               {
                  /* This could be (although memcpy is probably slower):
                  png_memcpy(dp, sp, 6);
                  sp += 8;
                  dp += 6;
                  */
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp += 2;
               }
            }
            else
            {
               png_bytep sp, dp;
               png_uint_32 i;

               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
               for (i = 0, sp = row + 2, dp = row; i < row_info->width; i++)
               {
                  /* This could be (although memcpy is probably slower):
                  png_memcpy(dp, sp, 6);
                  sp += 8;
                  dp += 6;
                  */
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 48;
            row_info->rowbytes = row_info->width * 6;
         }
         row_info->channels = 3;
      }
/*
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY ||
               row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
*/
      else if (row_info->channels == 2)
      {
         if (row_info->bit_depth == 8)
         {
            /* This converts from GX or GA to G */
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               png_bytep sp, dp;
               png_uint_32 i;

               for (i = 1, sp = row + 2, dp = row + 1; i < row_info->width; i++)
               {
                  *dp++ = *sp++;
                  sp++;
               }
            }
            /* This converts from XG or AG to G */
            else
            {
               png_bytep sp, dp;
               png_uint_32 i;

               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
               {
                  sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 8;
            row_info->rowbytes = row_info->width;
         }
         else /* if (row_info->bit_depth == 16) */
         {
            if (flags & PNG_FLAG_FILLER_AFTER)
            {
               png_bytep sp, dp;
               png_uint_32 i;

               /* This converts from GGXX or GGAA to GG */
               for (i = 1, sp = row + 4, dp = row + 2; i < row_info->width; i++)
               {
                  *dp++ = *sp++;
                  *dp++ = *sp++;
                  sp += 2;
               }
            }
            else
            {
               png_bytep sp, dp;
               png_uint_32 i;

               /* This converts from XXGG or AAGG to GG */
               for (i = 0, sp = row, dp = row; i < row_info->width; i++)
               {
                  sp += 2;
                  *dp++ = *sp++;
                  *dp++ = *sp++;
               }
            }
            row_info->pixel_depth = 16;
            row_info->rowbytes = row_info->width * 2;
         }
         row_info->channels = 1;
      }
   }
}
#endif

#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* swaps red and blue bytes within a pixel */
void
png_do_bgr(png_row_infop row_info, png_bytep row)
{
   png_debug(1, "in png_do_bgr\n");
   if (
#if defined(PNG_USELESS_TESTS_SUPPORTED)
       row != NULL && row_info != NULL &&
#endif
       (row_info->color_type & PNG_COLOR_MASK_COLOR))
   {
      if (row_info->bit_depth == 8)
      {
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
         {
            png_bytep rp;
            png_byte save;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_info->width; i++, rp += 3)
            {
               save = *rp;
               *rp = *(rp + 2);
               *(rp + 2) = save;
            }
         }
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
         {
            png_bytep rp;
            png_byte save;
            png_uint_32 i;

            for (i = 0, rp = row; i < row_info->width; i++, rp += 4)
            {
               save = *rp;
               *rp = *(rp + 2);
               *(rp + 2) = save;
            }
         }
      }
      else if (row_info->bit_depth == 16)
      {
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
         {
            png_bytep rp;
            png_byte save[2];
            png_uint_32 i;

            for (i = 0, rp = row; i < row_info->width; i++, rp += 6)
            {
               save[0] = *rp;
               save[1] = *(rp + 1);
               *rp = *(rp + 4);
               *(rp + 1) = *(rp + 5);
               *(rp + 4) = save[0];
               *(rp + 5) = save[1];
            }
         }
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
         {
            png_bytep rp;
            png_byte save[2];
            png_uint_32 i;

            for (i = 0, rp = row; i < row_info->width; i++, rp += 8)
            {
               save[0] = *rp;
               save[1] = *(rp + 1);
               *rp = *(rp + 4);
               *(rp + 1) = *(rp + 5);
               *(rp + 4) = save[0];
               *(rp + 5) = save[1];
            }
         }
      }
   }
}
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
Commit	Line	Data
c801d85f KB	1
	2	/* pngtrans.c - transforms the data in a row (used by both readers and 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
1f0299c1	13	#include "../png/png.h"
c801d85f KB	14
	15	#if defined(PNG_READ_BGR_SUPPORTED) \|\| defined(PNG_WRITE_BGR_SUPPORTED)
	16	/* turn on bgr to rgb mapping */
	17	void
	18	png_set_bgr(png_structp png_ptr)
	19	{
	20	png_debug(1, "in png_set_bgr\n");
	21	png_ptr->transformations \|= PNG_BGR;
	22	}
	23	#endif
	24
	25	#if defined(PNG_READ_SWAP_SUPPORTED) \|\| defined(PNG_WRITE_SWAP_SUPPORTED)
	26	/* turn on 16 bit byte swapping */
	27	void
	28	png_set_swap(png_structp png_ptr)
	29	{
	30	png_debug(1, "in png_set_swap\n");
	31	if (png_ptr->bit_depth == 16)
	32	png_ptr->transformations \|= PNG_SWAP_BYTES;
	33	}
	34	#endif
	35
	36	#if defined(PNG_READ_PACK_SUPPORTED) \|\| defined(PNG_WRITE_PACK_SUPPORTED)
	37	/* turn on pixel packing */
	38	void
	39	png_set_packing(png_structp png_ptr)
	40	{
	41	png_debug(1, "in png_set_packing\n");
	42	if (png_ptr->bit_depth < 8)
	43	{
	44	png_ptr->transformations \|= PNG_PACK;
	45	png_ptr->usr_bit_depth = 8;
	46	}
	47	}
	48	#endif
	49
	50	#if defined(PNG_READ_PACKSWAP_SUPPORTED)\|\|defined(PNG_WRITE_PACKSWAP_SUPPORTED)
	51	/* turn on packed pixel swapping */
	52	void
	53	png_set_packswap(png_structp png_ptr)
	54	{
	55	png_debug(1, "in png_set_packswap\n");
	56	if (png_ptr->bit_depth < 8)
	57	png_ptr->transformations \|= PNG_PACKSWAP;
	58	}
	59	#endif
	60
	61	#if defined(PNG_READ_SHIFT_SUPPORTED) \|\| defined(PNG_WRITE_SHIFT_SUPPORTED)
	62	void
	63	png_set_shift(png_structp png_ptr, png_color_8p true_bits)
	64	{
	65	png_debug(1, "in png_set_shift\n");
	66	png_ptr->transformations \|= PNG_SHIFT;
	67	png_ptr->shift = *true_bits;
	68	}
	69	#endif
	70
	71	#if defined(PNG_READ_INTERLACING_SUPPORTED) \|\| \
	72	defined(PNG_WRITE_INTERLACING_SUPPORTED)
	73	int
	74	png_set_interlace_handling(png_structp png_ptr)
	75	{
	76	png_debug(1, "in png_set_interlace handling\n");
	77	if (png_ptr->interlaced)
78	{
79	png_ptr->transformations \|= PNG_INTERLACE;
80	return (7);
81	}
82
83	return (1);
84	}
85	#endif
86
87	#if defined(PNG_READ_FILLER_SUPPORTED) \|\| defined(PNG_WRITE_FILLER_SUPPORTED)
88	/* Add a filler byte on read, or remove a filler or alpha byte on write.
89	* The filler type has changed in v0.95 to allow future 2-byte fillers
90	* for 48-bit input data, as well as avoiding problems with some compilers
91	* which don't like bytes as parameters.
92	*/
93	void
94	png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
95	{
96	png_debug(1, "in png_set_filler\n");
97	png_ptr->transformations \|= PNG_FILLER;
98	png_ptr->filler = (png_byte)filler;
99	if (filler_loc == PNG_FILLER_AFTER)
100	png_ptr->flags \|= PNG_FLAG_FILLER_AFTER;
101	else
102	png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
103
104	/* This should probably go in the "do_filler" routine */
105	if (png_ptr->color_type == PNG_COLOR_TYPE_RGB && png_ptr->bit_depth == 8)
106	{
107	png_ptr->usr_channels = 4;
108	}
109	}
110	#endif
111
112	#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) \|\| \
113	defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
114	void
115	png_set_swap_alpha(png_structp png_ptr)
116	{
117	png_debug(1, "in png_set_swap_alpha\n");
118	png_ptr->transformations \|= PNG_SWAP_ALPHA;
119	}
120	#endif
121
122	#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) \|\| \
123	defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
124	void
125	png_set_invert_alpha(png_structp png_ptr)
126	{
127	png_debug(1, "in png_set_invert_alpha\n");
128	png_ptr->transformations \|= PNG_INVERT_ALPHA;
129	}
130	#endif
131
132	#if defined(PNG_READ_INVERT_SUPPORTED) \|\| defined(PNG_WRITE_INVERT_SUPPORTED)
133	void
134	png_set_invert_mono(png_structp png_ptr)
135	{
136	png_debug(1, "in png_set_invert_mono\n");
137	png_ptr->transformations \|= PNG_INVERT_MONO;
138	}
139
140	/* invert monocrome grayscale data */
141	void
142	png_do_invert(png_row_infop row_info, png_bytep row)
143	{
144	png_debug(1, "in png_do_invert\n");
145	if (row_info->bit_depth == 1 &&
146	#if defined(PNG_USELESS_TESTS_SUPPORTED)
147	row != NULL && row_info != NULL &&
148	#endif
149	row_info->color_type == PNG_COLOR_TYPE_GRAY)
150	{
151	png_bytep rp;
152	png_uint_32 i;
153
154	for (i = 0, rp = row; i < row_info->rowbytes; i++, rp++)
155	{
156	rp = (png_byte)(~(rp));
157	}
158	}
159	}
160	#endif
161
162	#if defined(PNG_READ_SWAP_SUPPORTED) \|\| defined(PNG_WRITE_SWAP_SUPPORTED)
163	/* swaps byte order on 16 bit depth images */
164	void
165	png_do_swap(png_row_infop row_info, png_bytep row)
166	{
167	png_debug(1, "in png_do_swap\n");
168	if (
169	#if defined(PNG_USELESS_TESTS_SUPPORTED)
170	row != NULL && row_info != NULL &&
171	#endif
172	row_info->bit_depth == 16)
173	{
174	png_bytep rp;
175	png_byte t;
176	png_uint_32 i;
177
178	for (i = 0, rp = row;
179	i < row_info->width * row_info->channels;
180	i++, rp += 2)
181	{
182	t = *rp;
183	rp = (rp + 1);
184	*(rp + 1) = t;
185	}
186	}
187	}
188	#endif
189
190	#if defined(PNG_READ_PACKSWAP_SUPPORTED)\|\|defined(PNG_WRITE_PACKSWAP_SUPPORTED)
191	static png_byte onebppswaptable[256] = {
192	0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
193	0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
194	0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
195	0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
196	0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
197	0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
198	0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
199	0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
200	0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
201	0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
202	0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
203	0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
204	0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
205	0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
206	0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
207	0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
208	0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
209	0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
210	0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
211	0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
212	0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
213	0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
214	0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
215	0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
216	0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
217	0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
218	0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
219	0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
220	0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
221	0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
222	0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
223	0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
224	};
225
226	static png_byte twobppswaptable[256] = {
227	0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
228	0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
229	0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
230	0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
231	0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
232	0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
233	0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
234	0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
235	0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
236	0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
237	0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
238	0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
239	0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
240	0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
241	0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
242	0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
243	0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
244	0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
245	0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
246	0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
247	0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
248	0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
249	0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
250	0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
251	0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
252	0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
253	0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
254	0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
255	0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
256	0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
257	0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
258	0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
259	};
260
261	static png_byte fourbppswaptable[256] = {
262	0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
263	0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
264	0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
265	0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
266	0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
267	0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
268	0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
269	0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
270	0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
271	0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
272	0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
273	0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
274	0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
275	0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
276	0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
277	0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
278	0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
279	0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
280	0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
281	0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
282	0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
283	0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
284	0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
285	0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
286	0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
287	0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
288	0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
289	0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
290	0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
291	0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
292	0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
293	0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
294	};
295
296	/* swaps pixel packing order within bytes */
297	void
298	png_do_packswap(png_row_infop row_info, png_bytep row)
299	{
300	png_debug(1, "in png_do_packswap\n");
301	if (
302	#if defined(PNG_USELESS_TESTS_SUPPORTED)
303	row != NULL && row_info != NULL &&
304	#endif
305	row_info->bit_depth < 8)
306	{
307	png_bytep rp, end, table;
308
309	end = row + row_info->rowbytes;
310
311	if (row_info->bit_depth == 1)
312	table = onebppswaptable;
313	else if (row_info->bit_depth == 2)
314	table = twobppswaptable;
315	else if (row_info->bit_depth == 4)
316	table = fourbppswaptable;
317	else
318	return;
319
320	for (rp = row; rp < end; rp++)
321	rp = table[rp];
322	}
323	}
324	#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
325
326	#if defined(PNG_WRITE_FILLER_SUPPORTED) \|\| \
327	defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
328	/* remove filler or alpha byte(s) */
329	void
330	png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
331	{
332	png_debug(1, "in png_do_strip_filler\n");
333	#if defined(PNG_USELESS_TESTS_SUPPORTED)
334	if (row != NULL && row_info != NULL)
335	#endif
336	{
337	/*
338	if (row_info->color_type == PNG_COLOR_TYPE_RGB \|\|
339	row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
340	*/
341	if (row_info->channels == 4)
342	{
343	if (row_info->bit_depth == 8)
344	{
345	/* This converts from RGBX or RGBA to RGB */
346	if (flags & PNG_FLAG_FILLER_AFTER)
347	{
348	png_bytep sp, dp;
349	png_uint_32 i;
350
351	for (i = 1, sp = row + 4, dp = row + 3; i < row_info->width; i++)
352	{
353	dp++ = sp++;
354	dp++ = sp++;
355	dp++ = sp++;
356	sp++;
357	}
358	}
359	/* This converts from XRGB or ARGB to RGB */
360	else
361	{
362	png_bytep sp, dp;
363	png_uint_32 i;
364
365	for (i = 0, sp = row, dp = row; i < row_info->width; i++)
366	{
367	sp++;
368	dp++ = sp++;
369	dp++ = sp++;
370	dp++ = sp++;
371	}
372	}
373	row_info->pixel_depth = 24;
374	row_info->rowbytes = row_info->width * 3;
375	}
376	else /* if (row_info->bit_depth == 16) */
377	{
378	if (flags & PNG_FLAG_FILLER_AFTER)
379	{
380	png_bytep sp, dp;
381	png_uint_32 i;
382
383	/* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
384	for (i = 1, sp = row + 8, dp = row + 6; i < row_info->width; i++)
385	{
386	/* This could be (although memcpy is probably slower):
387	png_memcpy(dp, sp, 6);
388	sp += 8;
389	dp += 6;
390	*/
391	dp++ = sp++;
392	dp++ = sp++;
393	dp++ = sp++;
394	dp++ = sp++;
395	dp++ = sp++;
396	dp++ = sp++;
397	sp += 2;
398	}
399	}
400	else
401	{
402	png_bytep sp, dp;
403	png_uint_32 i;
404
405	/* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
406	for (i = 0, sp = row + 2, dp = row; i < row_info->width; i++)
407	{
408	/* This could be (although memcpy is probably slower):
409	png_memcpy(dp, sp, 6);
410	sp += 8;
411	dp += 6;
412	*/
413	dp++ = sp++;
414	dp++ = sp++;
415	dp++ = sp++;
416	dp++ = sp++;
417	dp++ = sp++;
418	dp++ = sp++;
419	}
420	}
421	row_info->pixel_depth = 48;
422	row_info->rowbytes = row_info->width * 6;
423	}
424	row_info->channels = 3;
425	}
426	/*
427	else if (row_info->color_type == PNG_COLOR_TYPE_GRAY \|\|
428	row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
429	*/
430	else if (row_info->channels == 2)
431	{
432	if (row_info->bit_depth == 8)
433	{
434	/* This converts from GX or GA to G */
435	if (flags & PNG_FLAG_FILLER_AFTER)
436	{
437	png_bytep sp, dp;
438	png_uint_32 i;
439
440	for (i = 1, sp = row + 2, dp = row + 1; i < row_info->width; i++)
441	{
442	dp++ = sp++;
443	sp++;
444	}
445	}
446	/* This converts from XG or AG to G */
447	else
448	{
449	png_bytep sp, dp;
450	png_uint_32 i;
451
452	for (i = 0, sp = row, dp = row; i < row_info->width; i++)
453	{
454	sp++;
455	dp++ = sp++;
456	}
457	}
458	row_info->pixel_depth = 8;
459	row_info->rowbytes = row_info->width;
460	}
461	else /* if (row_info->bit_depth == 16) */
462	{
463	if (flags & PNG_FLAG_FILLER_AFTER)
464	{
465	png_bytep sp, dp;
466	png_uint_32 i;
467
468	/* This converts from GGXX or GGAA to GG */
469	for (i = 1, sp = row + 4, dp = row + 2; i < row_info->width; i++)
470	{
471	dp++ = sp++;
472	dp++ = sp++;
473	sp += 2;
474	}
475	}
476	else
477	{
478	png_bytep sp, dp;
479	png_uint_32 i;
480
481	/* This converts from XXGG or AAGG to GG */
482	for (i = 0, sp = row, dp = row; i < row_info->width; i++)
483	{
484	sp += 2;
485	dp++ = sp++;
486	dp++ = sp++;
487	}
488	}
489	row_info->pixel_depth = 16;
490	row_info->rowbytes = row_info->width * 2;
491	}
492	row_info->channels = 1;
493	}
494	}
495	}
496	#endif
497
498	#if defined(PNG_READ_BGR_SUPPORTED) \|\| defined(PNG_WRITE_BGR_SUPPORTED)
499	/* swaps red and blue bytes within a pixel */
500	void
501	png_do_bgr(png_row_infop row_info, png_bytep row)
502	{
503	png_debug(1, "in png_do_bgr\n");
504	if (
505	#if defined(PNG_USELESS_TESTS_SUPPORTED)
506	row != NULL && row_info != NULL &&
507	#endif
508	(row_info->color_type & PNG_COLOR_MASK_COLOR))
509	{
510	if (row_info->bit_depth == 8)
511	{
512	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
513	{
514	png_bytep rp;
515	png_byte save;
516	png_uint_32 i;
517
518	for (i = 0, rp = row; i < row_info->width; i++, rp += 3)
519	{
520	save = *rp;
521	rp = (rp + 2);
522	*(rp + 2) = save;
523	}
524	}
525	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
526	{
527	png_bytep rp;
528	png_byte save;
529	png_uint_32 i;
530
531	for (i = 0, rp = row; i < row_info->width; i++, rp += 4)
532	{
533	save = *rp;
534	rp = (rp + 2);
535	*(rp + 2) = save;
536	}
537	}
538	}
539	else if (row_info->bit_depth == 16)
540	{
541	if (row_info->color_type == PNG_COLOR_TYPE_RGB)
542	{
543	png_bytep rp;
544	png_byte save[2];
545	png_uint_32 i;
546
547	for (i = 0, rp = row; i < row_info->width; i++, rp += 6)
548	{
549	save[0] = *rp;
550	save[1] = *(rp + 1);
551	rp = (rp + 4);
552	(rp + 1) = (rp + 5);
553	*(rp + 4) = save[0];
554	*(rp + 5) = save[1];
555	}
556	}
557	else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
558	{
559	png_bytep rp;
560	png_byte save[2];
561	png_uint_32 i;
562
563	for (i = 0, rp = row; i < row_info->width; i++, rp += 8)
564	{
565	save[0] = *rp;
566	save[1] = *(rp + 1);
567	rp = (rp + 4);
568	(rp + 1) = (rp + 5);
569	*(rp + 4) = save[0];
570	*(rp + 5) = save[1];
571	}
572	}
573	}
574	}
575	}
576	#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
577