pngrtran.c
上传用户:jnfxsk
上传日期:2022-06-16
资源大小:3675k
文件大小:143k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /* pngrtran.c - transforms the data in a row for PNG readers
  2.  *
  3.  * libpng version  1.2.8 - December 3, 2004
  4.  * For conditions of distribution and use, see copyright notice in png.h
  5.  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  7.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  8.  *
  9.  * This file contains functions optionally called by an application
  10.  * in order to tell libpng how to handle data when reading a PNG.
  11.  * Transformations that are used in both reading and writing are
  12.  * in pngtrans.c.
  13.  */
  14. #define PNG_INTERNAL
  15. #include "png.h"
  16. /* Set the action on getting a CRC error for an ancillary or critical chunk. */
  17. void PNGAPI
  18. png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
  19. {
  20.    png_debug(1, "in png_set_crc_actionn");
  21.    /* Tell libpng how we react to CRC errors in critical chunks */
  22.    switch (crit_action)
  23.    {
  24.       case PNG_CRC_NO_CHANGE:                        /* leave setting as is */
  25.          break;
  26.       case PNG_CRC_WARN_USE:                               /* warn/use data */
  27.          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  28.          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
  29.          break;
  30.       case PNG_CRC_QUIET_USE:                             /* quiet/use data */
  31.          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  32.          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
  33.                            PNG_FLAG_CRC_CRITICAL_IGNORE;
  34.          break;
  35.       case PNG_CRC_WARN_DISCARD:    /* not a valid action for critical data */
  36.          png_warning(png_ptr, "Can't discard critical data on CRC error.");
  37.       case PNG_CRC_ERROR_QUIT:                                /* error/quit */
  38.       case PNG_CRC_DEFAULT:
  39.       default:
  40.          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  41.          break;
  42.    }
  43.    switch (ancil_action)
  44.    {
  45.       case PNG_CRC_NO_CHANGE:                       /* leave setting as is */
  46.          break;
  47.       case PNG_CRC_WARN_USE:                              /* warn/use data */
  48.          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  49.          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
  50.          break;
  51.       case PNG_CRC_QUIET_USE:                            /* quiet/use data */
  52.          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  53.          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
  54.                            PNG_FLAG_CRC_ANCILLARY_NOWARN;
  55.          break;
  56.       case PNG_CRC_ERROR_QUIT:                               /* error/quit */
  57.          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  58.          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
  59.          break;
  60.       case PNG_CRC_WARN_DISCARD:                      /* warn/discard data */
  61.       case PNG_CRC_DEFAULT:
  62.       default:
  63.          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  64.          break;
  65.    }
  66. }
  67. #if defined(PNG_READ_BACKGROUND_SUPPORTED) && 
  68.     defined(PNG_FLOATING_POINT_SUPPORTED)
  69. /* handle alpha and tRNS via a background color */
  70. void PNGAPI
  71. png_set_background(png_structp png_ptr,
  72.    png_color_16p background_color, int background_gamma_code,
  73.    int need_expand, double background_gamma)
  74. {
  75.    png_debug(1, "in png_set_backgroundn");
  76.    if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
  77.    {
  78.       png_warning(png_ptr, "Application must supply a known background gamma");
  79.       return;
  80.    }
  81.    png_ptr->transformations |= PNG_BACKGROUND;
  82.    png_memcpy(&(png_ptr->background), background_color,
  83.       png_sizeof(png_color_16));
  84.    png_ptr->background_gamma = (float)background_gamma;
  85.    png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
  86.    png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
  87.    /* Note:  if need_expand is set and color_type is either RGB or RGB_ALPHA
  88.     * (in which case need_expand is superfluous anyway), the background color
  89.     * might actually be gray yet not be flagged as such. This is not a problem
  90.     * for the current code, which uses PNG_BACKGROUND_IS_GRAY only to
  91.     * decide when to do the png_do_gray_to_rgb() transformation.
  92.     */
  93.    if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) ||
  94.        (!need_expand && background_color->red == background_color->green &&
  95.         background_color->red == background_color->blue))
  96.       png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
  97. }
  98. #endif
  99. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  100. /* strip 16 bit depth files to 8 bit depth */
  101. void PNGAPI
  102. png_set_strip_16(png_structp png_ptr)
  103. {
  104.    png_debug(1, "in png_set_strip_16n");
  105.    png_ptr->transformations |= PNG_16_TO_8;
  106. }
  107. #endif
  108. #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  109. void PNGAPI
  110. png_set_strip_alpha(png_structp png_ptr)
  111. {
  112.    png_debug(1, "in png_set_strip_alphan");
  113.    png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
  114. }
  115. #endif
  116. #if defined(PNG_READ_DITHER_SUPPORTED)
  117. /* Dither file to 8 bit.  Supply a palette, the current number
  118.  * of elements in the palette, the maximum number of elements
  119.  * allowed, and a histogram if possible.  If the current number
  120.  * of colors is greater then the maximum number, the palette will be
  121.  * modified to fit in the maximum number.  "full_dither" indicates
  122.  * whether we need a dithering cube set up for RGB images, or if we
  123.  * simply are reducing the number of colors in a paletted image.
  124.  */
  125. typedef struct png_dsort_struct
  126. {
  127.    struct png_dsort_struct FAR * next;
  128.    png_byte left;
  129.    png_byte right;
  130. } png_dsort;
  131. typedef png_dsort FAR *       png_dsortp;
  132. typedef png_dsort FAR * FAR * png_dsortpp;
  133. void PNGAPI
  134. png_set_dither(png_structp png_ptr, png_colorp palette,
  135.    int num_palette, int maximum_colors, png_uint_16p histogram,
  136.    int full_dither)
  137. {
  138.    png_debug(1, "in png_set_dithern");
  139.    png_ptr->transformations |= PNG_DITHER;
  140.    if (!full_dither)
  141.    {
  142.       int i;
  143.       png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
  144.          (png_uint_32)(num_palette * png_sizeof (png_byte)));
  145.       for (i = 0; i < num_palette; i++)
  146.          png_ptr->dither_index[i] = (png_byte)i;
  147.    }
  148.    if (num_palette > maximum_colors)
  149.    {
  150.       if (histogram != NULL)
  151.       {
  152.          /* This is easy enough, just throw out the least used colors.
  153.             Perhaps not the best solution, but good enough. */
  154.          int i;
  155.          /* initialize an array to sort colors */
  156.          png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
  157.             (png_uint_32)(num_palette * png_sizeof (png_byte)));
  158.          /* initialize the dither_sort array */
  159.          for (i = 0; i < num_palette; i++)
  160.             png_ptr->dither_sort[i] = (png_byte)i;
  161.          /* Find the least used palette entries by starting a
  162.             bubble sort, and running it until we have sorted
  163.             out enough colors.  Note that we don't care about
  164.             sorting all the colors, just finding which are
  165.             least used. */
  166.          for (i = num_palette - 1; i >= maximum_colors; i--)
  167.          {
  168.             int done; /* to stop early if the list is pre-sorted */
  169.             int j;
  170.             done = 1;
  171.             for (j = 0; j < i; j++)
  172.             {
  173.                if (histogram[png_ptr->dither_sort[j]]
  174.                    < histogram[png_ptr->dither_sort[j + 1]])
  175.                {
  176.                   png_byte t;
  177.                   t = png_ptr->dither_sort[j];
  178.                   png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
  179.                   png_ptr->dither_sort[j + 1] = t;
  180.                   done = 0;
  181.                }
  182.             }
  183.             if (done)
  184.                break;
  185.          }
  186.          /* swap the palette around, and set up a table, if necessary */
  187.          if (full_dither)
  188.          {
  189.             int j = num_palette;
  190.             /* put all the useful colors within the max, but don't
  191.                move the others */
  192.             for (i = 0; i < maximum_colors; i++)
  193.             {
  194.                if ((int)png_ptr->dither_sort[i] >= maximum_colors)
  195.                {
  196.                   do
  197.                      j--;
  198.                   while ((int)png_ptr->dither_sort[j] >= maximum_colors);
  199.                   palette[i] = palette[j];
  200.                }
  201.             }
  202.          }
  203.          else
  204.          {
  205.             int j = num_palette;
  206.             /* move all the used colors inside the max limit, and
  207.                develop a translation table */
  208.             for (i = 0; i < maximum_colors; i++)
  209.             {
  210.                /* only move the colors we need to */
  211.                if ((int)png_ptr->dither_sort[i] >= maximum_colors)
  212.                {
  213.                   png_color tmp_color;
  214.                   do
  215.                      j--;
  216.                   while ((int)png_ptr->dither_sort[j] >= maximum_colors);
  217.                   tmp_color = palette[j];
  218.                   palette[j] = palette[i];
  219.                   palette[i] = tmp_color;
  220.                   /* indicate where the color went */
  221.                   png_ptr->dither_index[j] = (png_byte)i;
  222.                   png_ptr->dither_index[i] = (png_byte)j;
  223.                }
  224.             }
  225.             /* find closest color for those colors we are not using */
  226.             for (i = 0; i < num_palette; i++)
  227.             {
  228.                if ((int)png_ptr->dither_index[i] >= maximum_colors)
  229.                {
  230.                   int min_d, k, min_k, d_index;
  231.                   /* find the closest color to one we threw out */
  232.                   d_index = png_ptr->dither_index[i];
  233.                   min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
  234.                   for (k = 1, min_k = 0; k < maximum_colors; k++)
  235.                   {
  236.                      int d;
  237.                      d = PNG_COLOR_DIST(palette[d_index], palette[k]);
  238.                      if (d < min_d)
  239.                      {
  240.                         min_d = d;
  241.                         min_k = k;
  242.                      }
  243.                   }
  244.                   /* point to closest color */
  245.                   png_ptr->dither_index[i] = (png_byte)min_k;
  246.                }
  247.             }
  248.          }
  249.          png_free(png_ptr, png_ptr->dither_sort);
  250.          png_ptr->dither_sort=NULL;
  251.       }
  252.       else
  253.       {
  254.          /* This is much harder to do simply (and quickly).  Perhaps
  255.             we need to go through a median cut routine, but those
  256.             don't always behave themselves with only a few colors
  257.             as input.  So we will just find the closest two colors,
  258.             and throw out one of them (chosen somewhat randomly).
  259.             [We don't understand this at all, so if someone wants to
  260.              work on improving it, be our guest - AED, GRP]
  261.             */
  262.          int i;
  263.          int max_d;
  264.          int num_new_palette;
  265.          png_dsortp t;
  266.          png_dsortpp hash;
  267.          t=NULL;
  268.          /* initialize palette index arrays */
  269.          png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
  270.             (png_uint_32)(num_palette * png_sizeof (png_byte)));
  271.          png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
  272.             (png_uint_32)(num_palette * png_sizeof (png_byte)));
  273.          /* initialize the sort array */
  274.          for (i = 0; i < num_palette; i++)
  275.          {
  276.             png_ptr->index_to_palette[i] = (png_byte)i;
  277.             png_ptr->palette_to_index[i] = (png_byte)i;
  278.          }
  279.          hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
  280.             png_sizeof (png_dsortp)));
  281.          for (i = 0; i < 769; i++)
  282.             hash[i] = NULL;
  283. /*         png_memset(hash, 0, 769 * png_sizeof (png_dsortp)); */
  284.          num_new_palette = num_palette;
  285.          /* initial wild guess at how far apart the farthest pixel
  286.             pair we will be eliminating will be.  Larger
  287.             numbers mean more areas will be allocated, Smaller
  288.             numbers run the risk of not saving enough data, and
  289.             having to do this all over again.
  290.             I have not done extensive checking on this number.
  291.             */
  292.          max_d = 96;
  293.          while (num_new_palette > maximum_colors)
  294.          {
  295.             for (i = 0; i < num_new_palette - 1; i++)
  296.             {
  297.                int j;
  298.                for (j = i + 1; j < num_new_palette; j++)
  299.                {
  300.                   int d;
  301.                   d = PNG_COLOR_DIST(palette[i], palette[j]);
  302.                   if (d <= max_d)
  303.                   {
  304.                      t = (png_dsortp)png_malloc_warn(png_ptr,
  305.                          (png_uint_32)(png_sizeof(png_dsort)));
  306.                      if (t == NULL)
  307.                          break;
  308.                      t->next = hash[d];
  309.                      t->left = (png_byte)i;
  310.                      t->right = (png_byte)j;
  311.                      hash[d] = t;
  312.                   }
  313.                }
  314.                if (t == NULL)
  315.                   break;
  316.             }
  317.             if (t != NULL)
  318.             for (i = 0; i <= max_d; i++)
  319.             {
  320.                if (hash[i] != NULL)
  321.                {
  322.                   png_dsortp p;
  323.                   for (p = hash[i]; p; p = p->next)
  324.                   {
  325.                      if ((int)png_ptr->index_to_palette[p->left]
  326.                         < num_new_palette &&
  327.                         (int)png_ptr->index_to_palette[p->right]
  328.                         < num_new_palette)
  329.                      {
  330.                         int j, next_j;
  331.                         if (num_new_palette & 0x01)
  332.                         {
  333.                            j = p->left;
  334.                            next_j = p->right;
  335.                         }
  336.                         else
  337.                         {
  338.                            j = p->right;
  339.                            next_j = p->left;
  340.                         }
  341.                         num_new_palette--;
  342.                         palette[png_ptr->index_to_palette[j]]
  343.                           = palette[num_new_palette];
  344.                         if (!full_dither)
  345.                         {
  346.                            int k;
  347.                            for (k = 0; k < num_palette; k++)
  348.                            {
  349.                               if (png_ptr->dither_index[k] ==
  350.                                  png_ptr->index_to_palette[j])
  351.                                  png_ptr->dither_index[k] =
  352.                                     png_ptr->index_to_palette[next_j];
  353.                               if ((int)png_ptr->dither_index[k] ==
  354.                                  num_new_palette)
  355.                                  png_ptr->dither_index[k] =
  356.                                     png_ptr->index_to_palette[j];
  357.                            }
  358.                         }
  359.                         png_ptr->index_to_palette[png_ptr->palette_to_index
  360.                            [num_new_palette]] = png_ptr->index_to_palette[j];
  361.                         png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
  362.                            = png_ptr->palette_to_index[num_new_palette];
  363.                         png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
  364.                         png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
  365.                      }
  366.                      if (num_new_palette <= maximum_colors)
  367.                         break;
  368.                   }
  369.                   if (num_new_palette <= maximum_colors)
  370.                      break;
  371.                }
  372.             }
  373.             for (i = 0; i < 769; i++)
  374.             {
  375.                if (hash[i] != NULL)
  376.                {
  377.                   png_dsortp p = hash[i];
  378.                   while (p)
  379.                   {
  380.                      t = p->next;
  381.                      png_free(png_ptr, p);
  382.                      p = t;
  383.                   }
  384.                }
  385.                hash[i] = 0;
  386.             }
  387.             max_d += 96;
  388.          }
  389.          png_free(png_ptr, hash);
  390.          png_free(png_ptr, png_ptr->palette_to_index);
  391.          png_free(png_ptr, png_ptr->index_to_palette);
  392.          png_ptr->palette_to_index=NULL;
  393.          png_ptr->index_to_palette=NULL;
  394.       }
  395.       num_palette = maximum_colors;
  396.    }
  397.    if (png_ptr->palette == NULL)
  398.    {
  399.       png_ptr->palette = palette;
  400.    }
  401.    png_ptr->num_palette = (png_uint_16)num_palette;
  402.    if (full_dither)
  403.    {
  404.       int i;
  405.       png_bytep distance;
  406.       int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
  407.          PNG_DITHER_BLUE_BITS;
  408.       int num_red = (1 << PNG_DITHER_RED_BITS);
  409.       int num_green = (1 << PNG_DITHER_GREEN_BITS);
  410.       int num_blue = (1 << PNG_DITHER_BLUE_BITS);
  411.       png_size_t num_entries = ((png_size_t)1 << total_bits);
  412.       png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
  413.          (png_uint_32)(num_entries * png_sizeof (png_byte)));
  414.       png_memset(png_ptr->palette_lookup, 0, num_entries *
  415.          png_sizeof (png_byte));
  416.       distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
  417.          png_sizeof(png_byte)));
  418.       png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
  419.       for (i = 0; i < num_palette; i++)
  420.       {
  421.          int ir, ig, ib;
  422.          int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
  423.          int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
  424.          int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
  425.          for (ir = 0; ir < num_red; ir++)
  426.          {
  427.             /* int dr = abs(ir - r); */
  428.             int dr = ((ir > r) ? ir - r : r - ir);
  429.             int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
  430.             for (ig = 0; ig < num_green; ig++)
  431.             {
  432.                /* int dg = abs(ig - g); */
  433.                int dg = ((ig > g) ? ig - g : g - ig);
  434.                int dt = dr + dg;
  435.                int dm = ((dr > dg) ? dr : dg);
  436.                int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
  437.                for (ib = 0; ib < num_blue; ib++)
  438.                {
  439.                   int d_index = index_g | ib;
  440.                   /* int db = abs(ib - b); */
  441.                   int db = ((ib > b) ? ib - b : b - ib);
  442.                   int dmax = ((dm > db) ? dm : db);
  443.                   int d = dmax + dt + db;
  444.                   if (d < (int)distance[d_index])
  445.                   {
  446.                      distance[d_index] = (png_byte)d;
  447.                      png_ptr->palette_lookup[d_index] = (png_byte)i;
  448.                   }
  449.                }
  450.             }
  451.          }
  452.       }
  453.       png_free(png_ptr, distance);
  454.    }
  455. }
  456. #endif
  457. #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
  458. /* Transform the image from the file_gamma to the screen_gamma.  We
  459.  * only do transformations on images where the file_gamma and screen_gamma
  460.  * are not close reciprocals, otherwise it slows things down slightly, and
  461.  * also needlessly introduces small errors.
  462.  *
  463.  * We will turn off gamma transformation later if no semitransparent entries
  464.  * are present in the tRNS array for palette images.  We can't do it here
  465.  * because we don't necessarily have the tRNS chunk yet.
  466.  */
  467. void PNGAPI
  468. png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
  469. {
  470.    png_debug(1, "in png_set_gamman");
  471.    if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
  472.        (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
  473.        (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
  474.      png_ptr->transformations |= PNG_GAMMA;
  475.    png_ptr->gamma = (float)file_gamma;
  476.    png_ptr->screen_gamma = (float)scrn_gamma;
  477. }
  478. #endif
  479. #if defined(PNG_READ_EXPAND_SUPPORTED)
  480. /* Expand paletted images to RGB, expand grayscale images of
  481.  * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
  482.  * to alpha channels.
  483.  */
  484. void PNGAPI
  485. png_set_expand(png_structp png_ptr)
  486. {
  487.    png_debug(1, "in png_set_expandn");
  488.    png_ptr->transformations |= PNG_EXPAND;
  489. }
  490. /* GRR 19990627:  the following three functions currently are identical
  491.  *  to png_set_expand().  However, it is entirely reasonable that someone
  492.  *  might wish to expand an indexed image to RGB but *not* expand a single,
  493.  *  fully transparent palette entry to a full alpha channel--perhaps instead
  494.  *  convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
  495.  *  the transparent color with a particular RGB value, or drop tRNS entirely.
  496.  *  IOW, a future version of the library may make the transformations flag
  497.  *  a bit more fine-grained, with separate bits for each of these three
  498.  *  functions.
  499.  *
  500.  *  More to the point, these functions make it obvious what libpng will be
  501.  *  doing, whereas "expand" can (and does) mean any number of things.
  502.  */
  503. /* Expand paletted images to RGB. */
  504. void PNGAPI
  505. png_set_palette_to_rgb(png_structp png_ptr)
  506. {
  507.    png_debug(1, "in png_set_expandn");
  508.    png_ptr->transformations |= PNG_EXPAND;
  509. }
  510. /* Expand grayscale images of less than 8-bit depth to 8 bits. */
  511. void PNGAPI
  512. png_set_gray_1_2_4_to_8(png_structp png_ptr)
  513. {
  514.    png_debug(1, "in png_set_expandn");
  515.    png_ptr->transformations |= PNG_EXPAND;
  516. }
  517. /* Expand tRNS chunks to alpha channels. */
  518. void PNGAPI
  519. png_set_tRNS_to_alpha(png_structp png_ptr)
  520. {
  521.    png_debug(1, "in png_set_expandn");
  522.    png_ptr->transformations |= PNG_EXPAND;
  523. }
  524. #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
  525. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  526. void PNGAPI
  527. png_set_gray_to_rgb(png_structp png_ptr)
  528. {
  529.    png_debug(1, "in png_set_gray_to_rgbn");
  530.    png_ptr->transformations |= PNG_GRAY_TO_RGB;
  531. }
  532. #endif
  533. #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  534. #if defined(PNG_FLOATING_POINT_SUPPORTED)
  535. /* Convert a RGB image to a grayscale of the same width.  This allows us,
  536.  * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
  537.  */
  538. void PNGAPI
  539. png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
  540.    double green)
  541. {
  542.       int red_fixed = (int)((float)red*100000.0 + 0.5);
  543.       int green_fixed = (int)((float)green*100000.0 + 0.5);
  544.       png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
  545. }
  546. #endif
  547. void PNGAPI
  548. png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
  549.    png_fixed_point red, png_fixed_point green)
  550. {
  551.    png_debug(1, "in png_set_rgb_to_grayn");
  552.    switch(error_action)
  553.    {
  554.       case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
  555.               break;
  556.       case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
  557.               break;
  558.       case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
  559.    }
  560.    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  561. #if defined(PNG_READ_EXPAND_SUPPORTED)
  562.       png_ptr->transformations |= PNG_EXPAND;
  563. #else
  564.    {
  565.       png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
  566.       png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
  567.    }
  568. #endif
  569.    {
  570.       png_uint_16 red_int, green_int;
  571.       if(red < 0 || green < 0)
  572.       {
  573.          red_int   =  6968; /* .212671 * 32768 + .5 */
  574.          green_int = 23434; /* .715160 * 32768 + .5 */
  575.       }
  576.       else if(red + green < 100000L)
  577.       {
  578.         red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
  579.         green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
  580.       }
  581.       else
  582.       {
  583.          png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
  584.          red_int   =  6968;
  585.          green_int = 23434;
  586.       }
  587.       png_ptr->rgb_to_gray_red_coeff   = red_int;
  588.       png_ptr->rgb_to_gray_green_coeff = green_int;
  589.       png_ptr->rgb_to_gray_blue_coeff  = (png_uint_16)(32768-red_int-green_int);
  590.    }
  591. }
  592. #endif
  593. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || 
  594.     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || 
  595.     defined(PNG_LEGACY_SUPPORTED)
  596. void PNGAPI
  597. png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
  598.    read_user_transform_fn)
  599. {
  600.    png_debug(1, "in png_set_read_user_transform_fnn");
  601. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
  602.    png_ptr->transformations |= PNG_USER_TRANSFORM;
  603.    png_ptr->read_user_transform_fn = read_user_transform_fn;
  604. #endif
  605. #ifdef PNG_LEGACY_SUPPORTED
  606.    if(read_user_transform_fn)
  607.       png_warning(png_ptr,
  608.         "This version of libpng does not support user transforms");
  609. #endif
  610. }
  611. #endif
  612. /* Initialize everything needed for the read.  This includes modifying
  613.  * the palette.
  614.  */
  615. void /* PRIVATE */
  616. png_init_read_transformations(png_structp png_ptr)
  617. {
  618.    png_debug(1, "in png_init_read_transformationsn");
  619. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  620.    if(png_ptr != NULL)
  621. #endif
  622.   {
  623. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) 
  624.  || defined(PNG_READ_GAMMA_SUPPORTED)
  625.    int color_type = png_ptr->color_type;
  626. #endif
  627. #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
  628.    if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
  629.        (png_ptr->transformations & PNG_EXPAND))
  630.    {
  631.       if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */
  632.       {
  633.          /* expand background chunk. */
  634.          switch (png_ptr->bit_depth)
  635.          {
  636.             case 1:
  637.                png_ptr->background.gray *= (png_uint_16)0xff;
  638.                png_ptr->background.red = png_ptr->background.green
  639.                  =  png_ptr->background.blue = png_ptr->background.gray;
  640.                break;
  641.             case 2:
  642.                png_ptr->background.gray *= (png_uint_16)0x55;
  643.                png_ptr->background.red = png_ptr->background.green
  644.                  = png_ptr->background.blue = png_ptr->background.gray;
  645.                break;
  646.             case 4:
  647.                png_ptr->background.gray *= (png_uint_16)0x11;
  648.                png_ptr->background.red = png_ptr->background.green
  649.                  = png_ptr->background.blue = png_ptr->background.gray;
  650.                break;
  651.             case 8:
  652.             case 16:
  653.                png_ptr->background.red = png_ptr->background.green
  654.                  = png_ptr->background.blue = png_ptr->background.gray;
  655.                break;
  656.          }
  657.       }
  658.       else if (color_type == PNG_COLOR_TYPE_PALETTE)
  659.       {
  660.          png_ptr->background.red   =
  661.             png_ptr->palette[png_ptr->background.index].red;
  662.          png_ptr->background.green =
  663.             png_ptr->palette[png_ptr->background.index].green;
  664.          png_ptr->background.blue  =
  665.             png_ptr->palette[png_ptr->background.index].blue;
  666. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
  667.         if (png_ptr->transformations & PNG_INVERT_ALPHA)
  668.         {
  669. #if defined(PNG_READ_EXPAND_SUPPORTED)
  670.            if (!(png_ptr->transformations & PNG_EXPAND))
  671. #endif
  672.            {
  673.            /* invert the alpha channel (in tRNS) unless the pixels are
  674.               going to be expanded, in which case leave it for later */
  675.               int i,istop;
  676.               istop=(int)png_ptr->num_trans;
  677.               for (i=0; i<istop; i++)
  678.                  png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
  679.            }
  680.         }
  681. #endif
  682.       }
  683.    }
  684. #endif
  685. #if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
  686.    png_ptr->background_1 = png_ptr->background;
  687. #endif
  688. #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
  689.    if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
  690.        && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
  691.          < PNG_GAMMA_THRESHOLD))
  692.    {
  693.     int i,k;
  694.     k=0;
  695.     for (i=0; i<png_ptr->num_trans; i++)
  696.     {
  697.       if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
  698.         k=1; /* partial transparency is present */
  699.     }
  700.     if (k == 0)
  701.       png_ptr->transformations &= (~PNG_GAMMA);
  702.    }
  703.    if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY))
  704.    {
  705.       png_build_gamma_table(png_ptr);
  706. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  707.       if (png_ptr->transformations & PNG_BACKGROUND)
  708.       {
  709.          if (color_type == PNG_COLOR_TYPE_PALETTE)
  710.          {
  711.            /* could skip if no transparency and 
  712.            */
  713.             png_color back, back_1;
  714.             png_colorp palette = png_ptr->palette;
  715.             int num_palette = png_ptr->num_palette;
  716.             int i;
  717.             if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
  718.             {
  719.                back.red = png_ptr->gamma_table[png_ptr->background.red];
  720.                back.green = png_ptr->gamma_table[png_ptr->background.green];
  721.                back.blue = png_ptr->gamma_table[png_ptr->background.blue];
  722.                back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
  723.                back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
  724.                back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
  725.             }
  726.             else
  727.             {
  728.                double g, gs;
  729.                switch (png_ptr->background_gamma_type)
  730.                {
  731.                   case PNG_BACKGROUND_GAMMA_SCREEN:
  732.                      g = (png_ptr->screen_gamma);
  733.                      gs = 1.0;
  734.                      break;
  735.                   case PNG_BACKGROUND_GAMMA_FILE:
  736.                      g = 1.0 / (png_ptr->gamma);
  737.                      gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
  738.                      break;
  739.                   case PNG_BACKGROUND_GAMMA_UNIQUE:
  740.                      g = 1.0 / (png_ptr->background_gamma);
  741.                      gs = 1.0 / (png_ptr->background_gamma *
  742.                                  png_ptr->screen_gamma);
  743.                      break;
  744.                   default:
  745.                      g = 1.0;    /* back_1 */
  746.                      gs = 1.0;   /* back */
  747.                }
  748.                if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
  749.                {
  750.                   back.red   = (png_byte)png_ptr->background.red;
  751.                   back.green = (png_byte)png_ptr->background.green;
  752.                   back.blue  = (png_byte)png_ptr->background.blue;
  753.                }
  754.                else
  755.                {
  756.                   back.red = (png_byte)(pow(
  757.                      (double)png_ptr->background.red/255, gs) * 255.0 + .5);
  758.                   back.green = (png_byte)(pow(
  759.                      (double)png_ptr->background.green/255, gs) * 255.0 + .5);
  760.                   back.blue = (png_byte)(pow(
  761.                      (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
  762.                }
  763.                back_1.red = (png_byte)(pow(
  764.                   (double)png_ptr->background.red/255, g) * 255.0 + .5);
  765.                back_1.green = (png_byte)(pow(
  766.                   (double)png_ptr->background.green/255, g) * 255.0 + .5);
  767.                back_1.blue = (png_byte)(pow(
  768.                   (double)png_ptr->background.blue/255, g) * 255.0 + .5);
  769.             }
  770.             for (i = 0; i < num_palette; i++)
  771.             {
  772.                if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
  773.                {
  774.                   if (png_ptr->trans[i] == 0)
  775.                   {
  776.                      palette[i] = back;
  777.                   }
  778.                   else /* if (png_ptr->trans[i] != 0xff) */
  779.                   {
  780.                      png_byte v, w;
  781.                      v = png_ptr->gamma_to_1[palette[i].red];
  782.                      png_composite(w, v, png_ptr->trans[i], back_1.red);
  783.                      palette[i].red = png_ptr->gamma_from_1[w];
  784.                      v = png_ptr->gamma_to_1[palette[i].green];
  785.                      png_composite(w, v, png_ptr->trans[i], back_1.green);
  786.                      palette[i].green = png_ptr->gamma_from_1[w];
  787.                      v = png_ptr->gamma_to_1[palette[i].blue];
  788.                      png_composite(w, v, png_ptr->trans[i], back_1.blue);
  789.                      palette[i].blue = png_ptr->gamma_from_1[w];
  790.                   }
  791.                }
  792.                else
  793.                {
  794.                   palette[i].red = png_ptr->gamma_table[palette[i].red];
  795.                   palette[i].green = png_ptr->gamma_table[palette[i].green];
  796.                   palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  797.                }
  798.             }
  799.          }
  800.          /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
  801.          else
  802.          /* color_type != PNG_COLOR_TYPE_PALETTE */
  803.          {
  804.             double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
  805.             double g = 1.0;
  806.             double gs = 1.0;
  807.             switch (png_ptr->background_gamma_type)
  808.             {
  809.                case PNG_BACKGROUND_GAMMA_SCREEN:
  810.                   g = (png_ptr->screen_gamma);
  811.                   gs = 1.0;
  812.                   break;
  813.                case PNG_BACKGROUND_GAMMA_FILE:
  814.                   g = 1.0 / (png_ptr->gamma);
  815.                   gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
  816.                   break;
  817.                case PNG_BACKGROUND_GAMMA_UNIQUE:
  818.                   g = 1.0 / (png_ptr->background_gamma);
  819.                   gs = 1.0 / (png_ptr->background_gamma *
  820.                      png_ptr->screen_gamma);
  821.                   break;
  822.             }
  823.             png_ptr->background_1.gray = (png_uint_16)(pow(
  824.                (double)png_ptr->background.gray / m, g) * m + .5);
  825.             png_ptr->background.gray = (png_uint_16)(pow(
  826.                (double)png_ptr->background.gray / m, gs) * m + .5);
  827.             if ((png_ptr->background.red != png_ptr->background.green) ||
  828.                 (png_ptr->background.red != png_ptr->background.blue) ||
  829.                 (png_ptr->background.red != png_ptr->background.gray))
  830.             {
  831.                /* RGB or RGBA with color background */
  832.                png_ptr->background_1.red = (png_uint_16)(pow(
  833.                   (double)png_ptr->background.red / m, g) * m + .5);
  834.                png_ptr->background_1.green = (png_uint_16)(pow(
  835.                   (double)png_ptr->background.green / m, g) * m + .5);
  836.                png_ptr->background_1.blue = (png_uint_16)(pow(
  837.                   (double)png_ptr->background.blue / m, g) * m + .5);
  838.                png_ptr->background.red = (png_uint_16)(pow(
  839.                   (double)png_ptr->background.red / m, gs) * m + .5);
  840.                png_ptr->background.green = (png_uint_16)(pow(
  841.                   (double)png_ptr->background.green / m, gs) * m + .5);
  842.                png_ptr->background.blue = (png_uint_16)(pow(
  843.                   (double)png_ptr->background.blue / m, gs) * m + .5);
  844.             }
  845.             else
  846.             {
  847.                /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
  848.                png_ptr->background_1.red = png_ptr->background_1.green
  849.                  = png_ptr->background_1.blue = png_ptr->background_1.gray;
  850.                png_ptr->background.red = png_ptr->background.green
  851.                  = png_ptr->background.blue = png_ptr->background.gray;
  852.             }
  853.          }
  854.       }
  855.       else
  856.       /* transformation does not include PNG_BACKGROUND */
  857. #endif /* PNG_READ_BACKGROUND_SUPPORTED */
  858.       if (color_type == PNG_COLOR_TYPE_PALETTE)
  859.       {
  860.          png_colorp palette = png_ptr->palette;
  861.          int num_palette = png_ptr->num_palette;
  862.          int i;
  863.          for (i = 0; i < num_palette; i++)
  864.          {
  865.             palette[i].red = png_ptr->gamma_table[palette[i].red];
  866.             palette[i].green = png_ptr->gamma_table[palette[i].green];
  867.             palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  868.          }
  869.       }
  870.    }
  871. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  872.    else
  873. #endif
  874. #endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
  875. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  876.    /* No GAMMA transformation */
  877.    if ((png_ptr->transformations & PNG_BACKGROUND) &&
  878.        (color_type == PNG_COLOR_TYPE_PALETTE))
  879.    {
  880.       int i;
  881.       int istop = (int)png_ptr->num_trans;
  882.       png_color back;
  883.       png_colorp palette = png_ptr->palette;
  884.       back.red   = (png_byte)png_ptr->background.red;
  885.       back.green = (png_byte)png_ptr->background.green;
  886.       back.blue  = (png_byte)png_ptr->background.blue;
  887.       for (i = 0; i < istop; i++)
  888.       {
  889.          if (png_ptr->trans[i] == 0)
  890.          {
  891.             palette[i] = back;
  892.          }
  893.          else if (png_ptr->trans[i] != 0xff)
  894.          {
  895.             /* The png_composite() macro is defined in png.h */
  896.             png_composite(palette[i].red, palette[i].red,
  897.                png_ptr->trans[i], back.red);
  898.             png_composite(palette[i].green, palette[i].green,
  899.                png_ptr->trans[i], back.green);
  900.             png_composite(palette[i].blue, palette[i].blue,
  901.                png_ptr->trans[i], back.blue);
  902.          }
  903.       }
  904.    }
  905. #endif /* PNG_READ_BACKGROUND_SUPPORTED */
  906. #if defined(PNG_READ_SHIFT_SUPPORTED)
  907.    if ((png_ptr->transformations & PNG_SHIFT) &&
  908.       (color_type == PNG_COLOR_TYPE_PALETTE))
  909.    {
  910.       png_uint_16 i;
  911.       png_uint_16 istop = png_ptr->num_palette;
  912.       int sr = 8 - png_ptr->sig_bit.red;
  913.       int sg = 8 - png_ptr->sig_bit.green;
  914.       int sb = 8 - png_ptr->sig_bit.blue;
  915.       if (sr < 0 || sr > 8)
  916.          sr = 0;
  917.       if (sg < 0 || sg > 8)
  918.          sg = 0;
  919.       if (sb < 0 || sb > 8)
  920.          sb = 0;
  921.       for (i = 0; i < istop; i++)
  922.       {
  923.          png_ptr->palette[i].red >>= sr;
  924.          png_ptr->palette[i].green >>= sg;
  925.          png_ptr->palette[i].blue >>= sb;
  926.       }
  927.    }
  928. #endif  /* PNG_READ_SHIFT_SUPPORTED */
  929.  }
  930. #if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) 
  931.  && !defined(PNG_READ_BACKGROUND_SUPPORTED)
  932.    if(png_ptr)
  933.       return;
  934. #endif
  935. }
  936. /* Modify the info structure to reflect the transformations.  The
  937.  * info should be updated so a PNG file could be written with it,
  938.  * assuming the transformations result in valid PNG data.
  939.  */
  940. void /* PRIVATE */
  941. png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
  942. {
  943.    png_debug(1, "in png_read_transform_infon");
  944. #if defined(PNG_READ_EXPAND_SUPPORTED)
  945.    if (png_ptr->transformations & PNG_EXPAND)
  946.    {
  947.       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  948.       {
  949.          if (png_ptr->num_trans)
  950.             info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
  951.          else
  952.             info_ptr->color_type = PNG_COLOR_TYPE_RGB;
  953.          info_ptr->bit_depth = 8;
  954.          info_ptr->num_trans = 0;
  955.       }
  956.       else
  957.       {
  958.          if (png_ptr->num_trans)
  959.             info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
  960.          if (info_ptr->bit_depth < 8)
  961.             info_ptr->bit_depth = 8;
  962.          info_ptr->num_trans = 0;
  963.       }
  964.    }
  965. #endif
  966. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  967.    if (png_ptr->transformations & PNG_BACKGROUND)
  968.    {
  969.       info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
  970.       info_ptr->num_trans = 0;
  971.       info_ptr->background = png_ptr->background;
  972.    }
  973. #endif
  974. #if defined(PNG_READ_GAMMA_SUPPORTED)
  975.    if (png_ptr->transformations & PNG_GAMMA)
  976.    {
  977. #ifdef PNG_FLOATING_POINT_SUPPORTED
  978.       info_ptr->gamma = png_ptr->gamma;
  979. #endif
  980. #ifdef PNG_FIXED_POINT_SUPPORTED
  981.       info_ptr->int_gamma = png_ptr->int_gamma;
  982. #endif
  983.    }
  984. #endif
  985. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  986.    if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
  987.       info_ptr->bit_depth = 8;
  988. #endif
  989. #if defined(PNG_READ_DITHER_SUPPORTED)
  990.    if (png_ptr->transformations & PNG_DITHER)
  991.    {
  992.       if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
  993.          (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
  994.          png_ptr->palette_lookup && info_ptr->bit_depth == 8)
  995.       {
  996.          info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
  997.       }
  998.    }
  999. #endif
  1000. #if defined(PNG_READ_PACK_SUPPORTED)
  1001.    if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
  1002.       info_ptr->bit_depth = 8;
  1003. #endif
  1004. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1005.    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
  1006.       info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
  1007. #endif
  1008. #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  1009.    if (png_ptr->transformations & PNG_RGB_TO_GRAY)
  1010.       info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
  1011. #endif
  1012.    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  1013.       info_ptr->channels = 1;
  1014.    else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
  1015.       info_ptr->channels = 3;
  1016.    else
  1017.       info_ptr->channels = 1;
  1018. #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  1019.    if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
  1020.       info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
  1021. #endif
  1022.    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
  1023.       info_ptr->channels++;
  1024. #if defined(PNG_READ_FILLER_SUPPORTED)
  1025.    /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
  1026.    if ((png_ptr->transformations & PNG_FILLER) &&
  1027.        ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
  1028.        (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
  1029.    {
  1030.       info_ptr->channels++;
  1031.       /* if adding a true alpha channel not just filler */
  1032. #if !defined(PNG_1_0_X)
  1033.       if (png_ptr->transformations & PNG_ADD_ALPHA)
  1034.         info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
  1035. #endif
  1036.    }
  1037. #endif
  1038. #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && 
  1039. defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
  1040.    if(png_ptr->transformations & PNG_USER_TRANSFORM)
  1041.      {
  1042.        if(info_ptr->bit_depth < png_ptr->user_transform_depth)
  1043.          info_ptr->bit_depth = png_ptr->user_transform_depth;
  1044.        if(info_ptr->channels < png_ptr->user_transform_channels)
  1045.          info_ptr->channels = png_ptr->user_transform_channels;
  1046.      }
  1047. #endif
  1048.    info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
  1049.       info_ptr->bit_depth);
  1050.    info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,info_ptr->width);
  1051. #if !defined(PNG_READ_EXPAND_SUPPORTED)
  1052.    if(png_ptr)
  1053.       return;
  1054. #endif
  1055. }
  1056. /* Transform the row.  The order of transformations is significant,
  1057.  * and is very touchy.  If you add a transformation, take care to
  1058.  * decide how it fits in with the other transformations here.
  1059.  */
  1060. void /* PRIVATE */
  1061. png_do_read_transformations(png_structp png_ptr)
  1062. {
  1063.    png_debug(1, "in png_do_read_transformationsn");
  1064. #if !defined(PNG_USELESS_TESTS_SUPPORTED)
  1065.    if (png_ptr->row_buf == NULL)
  1066.    {
  1067. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  1068.       char msg[50];
  1069.       sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number,
  1070.          png_ptr->pass);
  1071.       png_error(png_ptr, msg);
  1072. #else
  1073.       png_error(png_ptr, "NULL row buffer");
  1074. #endif
  1075.    }
  1076. #endif
  1077. #if defined(PNG_READ_EXPAND_SUPPORTED)
  1078.    if (png_ptr->transformations & PNG_EXPAND)
  1079.    {
  1080.       if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
  1081.       {
  1082.          png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1083.             png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
  1084.       }
  1085.       else
  1086.       {
  1087.          if (png_ptr->num_trans)
  1088.             png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1089.                &(png_ptr->trans_values));
  1090.          else
  1091.             png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1092.                NULL);
  1093.       }
  1094.    }
  1095. #endif
  1096. #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  1097.    if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
  1098.       png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1099.          PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
  1100. #endif
  1101. #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  1102.    if (png_ptr->transformations & PNG_RGB_TO_GRAY)
  1103.    {
  1104.       int rgb_error =
  1105.          png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
  1106.       if(rgb_error)
  1107.       {
  1108.          png_ptr->rgb_to_gray_status=1;
  1109.          if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN)
  1110.             png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
  1111.          if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR)
  1112.             png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
  1113.       }
  1114.    }
  1115. #endif
  1116. /*
  1117. From Andreas Dilger e-mail to png-implement, 26 March 1998:
  1118.   In most cases, the "simple transparency" should be done prior to doing
  1119.   gray-to-RGB, or you will have to test 3x as many bytes to check if a
  1120.   pixel is transparent.  You would also need to make sure that the
  1121.   transparency information is upgraded to RGB.
  1122.   To summarize, the current flow is:
  1123.   - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
  1124.                                   with background "in place" if transparent,
  1125.                                   convert to RGB if necessary
  1126.   - Gray + alpha -> composite with gray background and remove alpha bytes,
  1127.                                   convert to RGB if necessary
  1128.   To support RGB backgrounds for gray images we need:
  1129.   - Gray + simple transparency -> convert to RGB + simple transparency, compare
  1130.                                   3 or 6 bytes and composite with background
  1131.                                   "in place" if transparent (3x compare/pixel
  1132.                                   compared to doing composite with gray bkgrnd)
  1133.   - Gray + alpha -> convert to RGB + alpha, composite with background and
  1134.                                   remove alpha bytes (3x float operations/pixel
  1135.                                   compared with composite on gray background)
  1136.   Greg's change will do this.  The reason it wasn't done before is for
  1137.   performance, as this increases the per-pixel operations.  If we would check
  1138.   in advance if the background was gray or RGB, and position the gray-to-RGB
  1139.   transform appropriately, then it would save a lot of work/time.
  1140.  */
  1141. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1142.    /* if gray -> RGB, do so now only if background is non-gray; else do later
  1143.     * for performance reasons */
  1144.    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
  1145.        !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
  1146.       png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1147. #endif
  1148. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1149.    if ((png_ptr->transformations & PNG_BACKGROUND) &&
  1150.       ((png_ptr->num_trans != 0 ) ||
  1151.       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
  1152.       png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1153.          &(png_ptr->trans_values), &(png_ptr->background)
  1154. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1155.          , &(png_ptr->background_1),
  1156.          png_ptr->gamma_table, png_ptr->gamma_from_1,
  1157.          png_ptr->gamma_to_1, png_ptr->gamma_16_table,
  1158.          png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
  1159.          png_ptr->gamma_shift
  1160. #endif
  1161. );
  1162. #endif
  1163. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1164.    if ((png_ptr->transformations & PNG_GAMMA) &&
  1165. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1166.       !((png_ptr->transformations & PNG_BACKGROUND) &&
  1167.       ((png_ptr->num_trans != 0) ||
  1168.       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
  1169. #endif
  1170.       (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
  1171.       png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1172.          png_ptr->gamma_table, png_ptr->gamma_16_table,
  1173.          png_ptr->gamma_shift);
  1174. #endif
  1175. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  1176.    if (png_ptr->transformations & PNG_16_TO_8)
  1177.       png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1178. #endif
  1179. #if defined(PNG_READ_DITHER_SUPPORTED)
  1180.    if (png_ptr->transformations & PNG_DITHER)
  1181.    {
  1182.       png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
  1183.          png_ptr->palette_lookup, png_ptr->dither_index);
  1184.       if(png_ptr->row_info.rowbytes == (png_uint_32)0)
  1185.          png_error(png_ptr, "png_do_dither returned rowbytes=0");
  1186.    }
  1187. #endif
  1188. #if defined(PNG_READ_INVERT_SUPPORTED)
  1189.    if (png_ptr->transformations & PNG_INVERT_MONO)
  1190.       png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1191. #endif
  1192. #if defined(PNG_READ_SHIFT_SUPPORTED)
  1193.    if (png_ptr->transformations & PNG_SHIFT)
  1194.       png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1195.          &(png_ptr->shift));
  1196. #endif
  1197. #if defined(PNG_READ_PACK_SUPPORTED)
  1198.    if (png_ptr->transformations & PNG_PACK)
  1199.       png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1200. #endif
  1201. #if defined(PNG_READ_BGR_SUPPORTED)
  1202.    if (png_ptr->transformations & PNG_BGR)
  1203.       png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1204. #endif
  1205. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  1206.    if (png_ptr->transformations & PNG_PACKSWAP)
  1207.       png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1208. #endif
  1209. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1210.    /* if gray -> RGB, do so now only if we did not do so above */
  1211.    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
  1212.        (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
  1213.       png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1214. #endif
  1215. #if defined(PNG_READ_FILLER_SUPPORTED)
  1216.    if (png_ptr->transformations & PNG_FILLER)
  1217.       png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
  1218.          (png_uint_32)png_ptr->filler, png_ptr->flags);
  1219. #endif
  1220. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
  1221.    if (png_ptr->transformations & PNG_INVERT_ALPHA)
  1222.       png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1223. #endif
  1224. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
  1225.    if (png_ptr->transformations & PNG_SWAP_ALPHA)
  1226.       png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1227. #endif
  1228. #if defined(PNG_READ_SWAP_SUPPORTED)
  1229.    if (png_ptr->transformations & PNG_SWAP_BYTES)
  1230.       png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
  1231. #endif
  1232. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
  1233.    if (png_ptr->transformations & PNG_USER_TRANSFORM)
  1234.     {
  1235.       if(png_ptr->read_user_transform_fn != NULL)
  1236.         (*(png_ptr->read_user_transform_fn)) /* user read transform function */
  1237.           (png_ptr,                    /* png_ptr */
  1238.            &(png_ptr->row_info),       /* row_info:     */
  1239.              /*  png_uint_32 width;          width of row */
  1240.              /*  png_uint_32 rowbytes;       number of bytes in row */
  1241.              /*  png_byte color_type;        color type of pixels */
  1242.              /*  png_byte bit_depth;         bit depth of samples */
  1243.              /*  png_byte channels;          number of channels (1-4) */
  1244.              /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
  1245.            png_ptr->row_buf + 1);      /* start of pixel data for row */
  1246. #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
  1247.       if(png_ptr->user_transform_depth)
  1248.          png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
  1249.       if(png_ptr->user_transform_channels)
  1250.          png_ptr->row_info.channels = png_ptr->user_transform_channels;
  1251. #endif
  1252.       png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
  1253.          png_ptr->row_info.channels);
  1254.       png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
  1255.          png_ptr->row_info.width);
  1256.    }
  1257. #endif
  1258. }
  1259. #if defined(PNG_READ_PACK_SUPPORTED)
  1260. /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
  1261.  * without changing the actual values.  Thus, if you had a row with
  1262.  * a bit depth of 1, you would end up with bytes that only contained
  1263.  * the numbers 0 or 1.  If you would rather they contain 0 and 255, use
  1264.  * png_do_shift() after this.
  1265.  */
  1266. void /* PRIVATE */
  1267. png_do_unpack(png_row_infop row_info, png_bytep row)
  1268. {
  1269.    png_debug(1, "in png_do_unpackn");
  1270. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1271.    if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
  1272. #else
  1273.    if (row_info->bit_depth < 8)
  1274. #endif
  1275.    {
  1276.       png_uint_32 i;
  1277.       png_uint_32 row_width=row_info->width;
  1278.       switch (row_info->bit_depth)
  1279.       {
  1280.          case 1:
  1281.          {
  1282.             png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
  1283.             png_bytep dp = row + (png_size_t)row_width - 1;
  1284.             png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
  1285.             for (i = 0; i < row_width; i++)
  1286.             {
  1287.                *dp = (png_byte)((*sp >> shift) & 0x01);
  1288.                if (shift == 7)
  1289.                {
  1290.                   shift = 0;
  1291.                   sp--;
  1292.                }
  1293.                else
  1294.                   shift++;
  1295.                dp--;
  1296.             }
  1297.             break;
  1298.          }
  1299.          case 2:
  1300.          {
  1301.             png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
  1302.             png_bytep dp = row + (png_size_t)row_width - 1;
  1303.             png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
  1304.             for (i = 0; i < row_width; i++)
  1305.             {
  1306.                *dp = (png_byte)((*sp >> shift) & 0x03);
  1307.                if (shift == 6)
  1308.                {
  1309.                   shift = 0;
  1310.                   sp--;
  1311.                }
  1312.                else
  1313.                   shift += 2;
  1314.                dp--;
  1315.             }
  1316.             break;
  1317.          }
  1318.          case 4:
  1319.          {
  1320.             png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
  1321.             png_bytep dp = row + (png_size_t)row_width - 1;
  1322.             png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
  1323.             for (i = 0; i < row_width; i++)
  1324.             {
  1325.                *dp = (png_byte)((*sp >> shift) & 0x0f);
  1326.                if (shift == 4)
  1327.                {
  1328.                   shift = 0;
  1329.                   sp--;
  1330.                }
  1331.                else
  1332.                   shift = 4;
  1333.                dp--;
  1334.             }
  1335.             break;
  1336.          }
  1337.       }
  1338.       row_info->bit_depth = 8;
  1339.       row_info->pixel_depth = (png_byte)(8 * row_info->channels);
  1340.       row_info->rowbytes = row_width * row_info->channels;
  1341.    }
  1342. }
  1343. #endif
  1344. #if defined(PNG_READ_SHIFT_SUPPORTED)
  1345. /* Reverse the effects of png_do_shift.  This routine merely shifts the
  1346.  * pixels back to their significant bits values.  Thus, if you have
  1347.  * a row of bit depth 8, but only 5 are significant, this will shift
  1348.  * the values back to 0 through 31.
  1349.  */
  1350. void /* PRIVATE */
  1351. png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
  1352. {
  1353.    png_debug(1, "in png_do_unshiftn");
  1354.    if (
  1355. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1356.        row != NULL && row_info != NULL && sig_bits != NULL &&
  1357. #endif
  1358.        row_info->color_type != PNG_COLOR_TYPE_PALETTE)
  1359.    {
  1360.       int shift[4];
  1361.       int channels = 0;
  1362.       int c;
  1363.       png_uint_16 value = 0;
  1364.       png_uint_32 row_width = row_info->width;
  1365.       if (row_info->color_type & PNG_COLOR_MASK_COLOR)
  1366.       {
  1367.          shift[channels++] = row_info->bit_depth - sig_bits->red;
  1368.          shift[channels++] = row_info->bit_depth - sig_bits->green;
  1369.          shift[channels++] = row_info->bit_depth - sig_bits->blue;
  1370.       }
  1371.       else
  1372.       {
  1373.          shift[channels++] = row_info->bit_depth - sig_bits->gray;
  1374.       }
  1375.       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
  1376.       {
  1377.          shift[channels++] = row_info->bit_depth - sig_bits->alpha;
  1378.       }
  1379.       for (c = 0; c < channels; c++)
  1380.       {
  1381.          if (shift[c] <= 0)
  1382.             shift[c] = 0;
  1383.          else
  1384.             value = 1;
  1385.       }
  1386.       if (!value)
  1387.          return;
  1388.       switch (row_info->bit_depth)
  1389.       {
  1390.          case 2:
  1391.          {
  1392.             png_bytep bp;
  1393.             png_uint_32 i;
  1394.             png_uint_32 istop = row_info->rowbytes;
  1395.             for (bp = row, i = 0; i < istop; i++)
  1396.             {
  1397.                *bp >>= 1;
  1398.                *bp++ &= 0x55;
  1399.             }
  1400.             break;
  1401.          }
  1402.          case 4:
  1403.          {
  1404.             png_bytep bp = row;
  1405.             png_uint_32 i;
  1406.             png_uint_32 istop = row_info->rowbytes;
  1407.             png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
  1408.                (png_byte)((int)0xf >> shift[0]));
  1409.             for (i = 0; i < istop; i++)
  1410.             {
  1411.                *bp >>= shift[0];
  1412.                *bp++ &= mask;
  1413.             }
  1414.             break;
  1415.          }
  1416.          case 8:
  1417.          {
  1418.             png_bytep bp = row;
  1419.             png_uint_32 i;
  1420.             png_uint_32 istop = row_width * channels;
  1421.             for (i = 0; i < istop; i++)
  1422.             {
  1423.                *bp++ >>= shift[i%channels];
  1424.             }
  1425.             break;
  1426.          }
  1427.          case 16:
  1428.          {
  1429.             png_bytep bp = row;
  1430.             png_uint_32 i;
  1431.             png_uint_32 istop = channels * row_width;
  1432.             for (i = 0; i < istop; i++)
  1433.             {
  1434.                value = (png_uint_16)((*bp << 8) + *(bp + 1));
  1435.                value >>= shift[i%channels];
  1436.                *bp++ = (png_byte)(value >> 8);
  1437.                *bp++ = (png_byte)(value & 0xff);
  1438.             }
  1439.             break;
  1440.          }
  1441.       }
  1442.    }
  1443. }
  1444. #endif
  1445. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  1446. /* chop rows of bit depth 16 down to 8 */
  1447. void /* PRIVATE */
  1448. png_do_chop(png_row_infop row_info, png_bytep row)
  1449. {
  1450.    png_debug(1, "in png_do_chopn");
  1451. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1452.    if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
  1453. #else
  1454.    if (row_info->bit_depth == 16)
  1455. #endif
  1456.    {
  1457.       png_bytep sp = row;
  1458.       png_bytep dp = row;
  1459.       png_uint_32 i;
  1460.       png_uint_32 istop = row_info->width * row_info->channels;
  1461.       for (i = 0; i<istop; i++, sp += 2, dp++)
  1462.       {
  1463. #if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
  1464.       /* This does a more accurate scaling of the 16-bit color
  1465.        * value, rather than a simple low-byte truncation.
  1466.        *
  1467.        * What the ideal calculation should be:
  1468.        *   *dp = (((((png_uint_32)(*sp) << 8) |
  1469.        *          (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
  1470.        *
  1471.        * GRR: no, I think this is what it really should be:
  1472.        *   *dp = (((((png_uint_32)(*sp) << 8) |
  1473.        *           (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
  1474.        *
  1475.        * GRR: here's the exact calculation with shifts:
  1476.        *   temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;
  1477.        *   *dp = (temp - (temp >> 8)) >> 8;
  1478.        *
  1479.        * Approximate calculation with shift/add instead of multiply/divide:
  1480.        *   *dp = ((((png_uint_32)(*sp) << 8) |
  1481.        *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;
  1482.        *
  1483.        * What we actually do to avoid extra shifting and conversion:
  1484.        */
  1485.          *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);
  1486. #else
  1487.        /* Simply discard the low order byte */
  1488.          *dp = *sp;
  1489. #endif
  1490.       }
  1491.       row_info->bit_depth = 8;
  1492.       row_info->pixel_depth = (png_byte)(8 * row_info->channels);
  1493.       row_info->rowbytes = row_info->width * row_info->channels;
  1494.    }
  1495. }
  1496. #endif
  1497. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
  1498. void /* PRIVATE */
  1499. png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
  1500. {
  1501.    png_debug(1, "in png_do_read_swap_alphan");
  1502. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1503.    if (row != NULL && row_info != NULL)
  1504. #endif
  1505.    {
  1506.       png_uint_32 row_width = row_info->width;
  1507.       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  1508.       {
  1509.          /* This converts from RGBA to ARGB */
  1510.          if (row_info->bit_depth == 8)
  1511.          {
  1512.             png_bytep sp = row + row_info->rowbytes;
  1513.             png_bytep dp = sp;
  1514.             png_byte save;
  1515.             png_uint_32 i;
  1516.             for (i = 0; i < row_width; i++)
  1517.             {
  1518.                save = *(--sp);
  1519.                *(--dp) = *(--sp);
  1520.                *(--dp) = *(--sp);
  1521.                *(--dp) = *(--sp);
  1522.                *(--dp) = save;
  1523.             }
  1524.          }
  1525.          /* This converts from RRGGBBAA to AARRGGBB */
  1526.          else
  1527.          {
  1528.             png_bytep sp = row + row_info->rowbytes;
  1529.             png_bytep dp = sp;
  1530.             png_byte save[2];
  1531.             png_uint_32 i;
  1532.             for (i = 0; i < row_width; i++)
  1533.             {
  1534.                save[0] = *(--sp);
  1535.                save[1] = *(--sp);
  1536.                *(--dp) = *(--sp);
  1537.                *(--dp) = *(--sp);
  1538.                *(--dp) = *(--sp);
  1539.                *(--dp) = *(--sp);
  1540.                *(--dp) = *(--sp);
  1541.                *(--dp) = *(--sp);
  1542.                *(--dp) = save[0];
  1543.                *(--dp) = save[1];
  1544.             }
  1545.          }
  1546.       }
  1547.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  1548.       {
  1549.          /* This converts from GA to AG */
  1550.          if (row_info->bit_depth == 8)
  1551.          {
  1552.             png_bytep sp = row + row_info->rowbytes;
  1553.             png_bytep dp = sp;
  1554.             png_byte save;
  1555.             png_uint_32 i;
  1556.             for (i = 0; i < row_width; i++)
  1557.             {
  1558.                save = *(--sp);
  1559.                *(--dp) = *(--sp);
  1560.                *(--dp) = save;
  1561.             }
  1562.          }
  1563.          /* This converts from GGAA to AAGG */
  1564.          else
  1565.          {
  1566.             png_bytep sp = row + row_info->rowbytes;
  1567.             png_bytep dp = sp;
  1568.             png_byte save[2];
  1569.             png_uint_32 i;
  1570.             for (i = 0; i < row_width; i++)
  1571.             {
  1572.                save[0] = *(--sp);
  1573.                save[1] = *(--sp);
  1574.                *(--dp) = *(--sp);
  1575.                *(--dp) = *(--sp);
  1576.                *(--dp) = save[0];
  1577.                *(--dp) = save[1];
  1578.             }
  1579.          }
  1580.       }
  1581.    }
  1582. }
  1583. #endif
  1584. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
  1585. void /* PRIVATE */
  1586. png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
  1587. {
  1588.    png_debug(1, "in png_do_read_invert_alphan");
  1589. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1590.    if (row != NULL && row_info != NULL)
  1591. #endif
  1592.    {
  1593.       png_uint_32 row_width = row_info->width;
  1594.       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  1595.       {
  1596.          /* This inverts the alpha channel in RGBA */
  1597.          if (row_info->bit_depth == 8)
  1598.          {
  1599.             png_bytep sp = row + row_info->rowbytes;
  1600.             png_bytep dp = sp;
  1601.             png_uint_32 i;
  1602.             for (i = 0; i < row_width; i++)
  1603.             {
  1604.                *(--dp) = (png_byte)(255 - *(--sp));
  1605. /*             This does nothing:
  1606.                *(--dp) = *(--sp);
  1607.                *(--dp) = *(--sp);
  1608.                *(--dp) = *(--sp);
  1609.                We can replace it with:
  1610. */
  1611.                sp-=3;
  1612.                dp=sp;
  1613.             }
  1614.          }
  1615.          /* This inverts the alpha channel in RRGGBBAA */
  1616.          else
  1617.          {
  1618.             png_bytep sp = row + row_info->rowbytes;
  1619.             png_bytep dp = sp;
  1620.             png_uint_32 i;
  1621.             for (i = 0; i < row_width; i++)
  1622.             {
  1623.                *(--dp) = (png_byte)(255 - *(--sp));
  1624.                *(--dp) = (png_byte)(255 - *(--sp));
  1625. /*             This does nothing:
  1626.                *(--dp) = *(--sp);
  1627.                *(--dp) = *(--sp);
  1628.                *(--dp) = *(--sp);
  1629.                *(--dp) = *(--sp);
  1630.                *(--dp) = *(--sp);
  1631.                *(--dp) = *(--sp);
  1632.                We can replace it with:
  1633. */
  1634.                sp-=6;
  1635.                dp=sp;
  1636.             }
  1637.          }
  1638.       }
  1639.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  1640.       {
  1641.          /* This inverts the alpha channel in GA */
  1642.          if (row_info->bit_depth == 8)
  1643.          {
  1644.             png_bytep sp = row + row_info->rowbytes;
  1645.             png_bytep dp = sp;
  1646.             png_uint_32 i;
  1647.             for (i = 0; i < row_width; i++)
  1648.             {
  1649.                *(--dp) = (png_byte)(255 - *(--sp));
  1650.                *(--dp) = *(--sp);
  1651.             }
  1652.          }
  1653.          /* This inverts the alpha channel in GGAA */
  1654.          else
  1655.          {
  1656.             png_bytep sp  = row + row_info->rowbytes;
  1657.             png_bytep dp = sp;
  1658.             png_uint_32 i;
  1659.             for (i = 0; i < row_width; i++)
  1660.             {
  1661.                *(--dp) = (png_byte)(255 - *(--sp));
  1662.                *(--dp) = (png_byte)(255 - *(--sp));
  1663. /*
  1664.                *(--dp) = *(--sp);
  1665.                *(--dp) = *(--sp);
  1666. */
  1667.                sp-=2;
  1668.                dp=sp;
  1669.             }
  1670.          }
  1671.       }
  1672.    }
  1673. }
  1674. #endif
  1675. #if defined(PNG_READ_FILLER_SUPPORTED)
  1676. /* Add filler channel if we have RGB color */
  1677. void /* PRIVATE */
  1678. png_do_read_filler(png_row_infop row_info, png_bytep row,
  1679.    png_uint_32 filler, png_uint_32 flags)
  1680. {
  1681.    png_uint_32 i;
  1682.    png_uint_32 row_width = row_info->width;
  1683.    png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
  1684.    png_byte lo_filler = (png_byte)(filler & 0xff);
  1685.    png_debug(1, "in png_do_read_fillern");
  1686.    if (
  1687. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1688.        row != NULL  && row_info != NULL &&
  1689. #endif
  1690.        row_info->color_type == PNG_COLOR_TYPE_GRAY)
  1691.    {
  1692.       if(row_info->bit_depth == 8)
  1693.       {
  1694.          /* This changes the data from G to GX */
  1695.          if (flags & PNG_FLAG_FILLER_AFTER)
  1696.          {
  1697.             png_bytep sp = row + (png_size_t)row_width;
  1698.             png_bytep dp =  sp + (png_size_t)row_width;
  1699.             for (i = 1; i < row_width; i++)
  1700.             {
  1701.                *(--dp) = lo_filler;
  1702.                *(--dp) = *(--sp);
  1703.             }
  1704.             *(--dp) = lo_filler;
  1705.             row_info->channels = 2;
  1706.             row_info->pixel_depth = 16;
  1707.             row_info->rowbytes = row_width * 2;
  1708.          }
  1709.       /* This changes the data from G to XG */
  1710.          else
  1711.          {
  1712.             png_bytep sp = row + (png_size_t)row_width;
  1713.             png_bytep dp = sp  + (png_size_t)row_width;
  1714.             for (i = 0; i < row_width; i++)
  1715.             {
  1716.                *(--dp) = *(--sp);
  1717.                *(--dp) = lo_filler;
  1718.             }
  1719.             row_info->channels = 2;
  1720.             row_info->pixel_depth = 16;
  1721.             row_info->rowbytes = row_width * 2;
  1722.          }
  1723.       }
  1724.       else if(row_info->bit_depth == 16)
  1725.       {
  1726.          /* This changes the data from GG to GGXX */
  1727.          if (flags & PNG_FLAG_FILLER_AFTER)
  1728.          {
  1729.             png_bytep sp = row + (png_size_t)row_width * 2;
  1730.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1731.             for (i = 1; i < row_width; i++)
  1732.             {
  1733.                *(--dp) = hi_filler;
  1734.                *(--dp) = lo_filler;
  1735.                *(--dp) = *(--sp);
  1736.                *(--dp) = *(--sp);
  1737.             }
  1738.             *(--dp) = hi_filler;
  1739.             *(--dp) = lo_filler;
  1740.             row_info->channels = 2;
  1741.             row_info->pixel_depth = 32;
  1742.             row_info->rowbytes = row_width * 4;
  1743.          }
  1744.          /* This changes the data from GG to XXGG */
  1745.          else
  1746.          {
  1747.             png_bytep sp = row + (png_size_t)row_width * 2;
  1748.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1749.             for (i = 0; i < row_width; i++)
  1750.             {
  1751.                *(--dp) = *(--sp);
  1752.                *(--dp) = *(--sp);
  1753.                *(--dp) = hi_filler;
  1754.                *(--dp) = lo_filler;
  1755.             }
  1756.             row_info->channels = 2;
  1757.             row_info->pixel_depth = 32;
  1758.             row_info->rowbytes = row_width * 4;
  1759.          }
  1760.       }
  1761.    } /* COLOR_TYPE == GRAY */
  1762.    else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  1763.    {
  1764.       if(row_info->bit_depth == 8)
  1765.       {
  1766.          /* This changes the data from RGB to RGBX */
  1767.          if (flags & PNG_FLAG_FILLER_AFTER)
  1768.          {
  1769.             png_bytep sp = row + (png_size_t)row_width * 3;
  1770.             png_bytep dp = sp  + (png_size_t)row_width;
  1771.             for (i = 1; i < row_width; i++)
  1772.             {
  1773.                *(--dp) = lo_filler;
  1774.                *(--dp) = *(--sp);
  1775.                *(--dp) = *(--sp);
  1776.                *(--dp) = *(--sp);
  1777.             }
  1778.             *(--dp) = lo_filler;
  1779.             row_info->channels = 4;
  1780.             row_info->pixel_depth = 32;
  1781.             row_info->rowbytes = row_width * 4;
  1782.          }
  1783.       /* This changes the data from RGB to XRGB */
  1784.          else
  1785.          {
  1786.             png_bytep sp = row + (png_size_t)row_width * 3;
  1787.             png_bytep dp = sp + (png_size_t)row_width;
  1788.             for (i = 0; i < row_width; i++)
  1789.             {
  1790.                *(--dp) = *(--sp);
  1791.                *(--dp) = *(--sp);
  1792.                *(--dp) = *(--sp);
  1793.                *(--dp) = lo_filler;
  1794.             }
  1795.             row_info->channels = 4;
  1796.             row_info->pixel_depth = 32;
  1797.             row_info->rowbytes = row_width * 4;
  1798.          }
  1799.       }
  1800.       else if(row_info->bit_depth == 16)
  1801.       {
  1802.          /* This changes the data from RRGGBB to RRGGBBXX */
  1803.          if (flags & PNG_FLAG_FILLER_AFTER)
  1804.          {
  1805.             png_bytep sp = row + (png_size_t)row_width * 6;
  1806.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1807.             for (i = 1; i < row_width; i++)
  1808.             {
  1809.                *(--dp) = hi_filler;
  1810.                *(--dp) = lo_filler;
  1811.                *(--dp) = *(--sp);
  1812.                *(--dp) = *(--sp);
  1813.                *(--dp) = *(--sp);
  1814.                *(--dp) = *(--sp);
  1815.                *(--dp) = *(--sp);
  1816.                *(--dp) = *(--sp);
  1817.             }
  1818.             *(--dp) = hi_filler;
  1819.             *(--dp) = lo_filler;
  1820.             row_info->channels = 4;
  1821.             row_info->pixel_depth = 64;
  1822.             row_info->rowbytes = row_width * 8;
  1823.          }
  1824.          /* This changes the data from RRGGBB to XXRRGGBB */
  1825.          else
  1826.          {
  1827.             png_bytep sp = row + (png_size_t)row_width * 6;
  1828.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1829.             for (i = 0; i < row_width; i++)
  1830.             {
  1831.                *(--dp) = *(--sp);
  1832.                *(--dp) = *(--sp);
  1833.                *(--dp) = *(--sp);
  1834.                *(--dp) = *(--sp);
  1835.                *(--dp) = *(--sp);
  1836.                *(--dp) = *(--sp);
  1837.                *(--dp) = hi_filler;
  1838.                *(--dp) = lo_filler;
  1839.             }
  1840.             row_info->channels = 4;
  1841.             row_info->pixel_depth = 64;
  1842.             row_info->rowbytes = row_width * 8;
  1843.          }
  1844.       }
  1845.    } /* COLOR_TYPE == RGB */
  1846. }
  1847. #endif
  1848. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1849. /* expand grayscale files to RGB, with or without alpha */
  1850. void /* PRIVATE */
  1851. png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
  1852. {
  1853.    png_uint_32 i;
  1854.    png_uint_32 row_width = row_info->width;
  1855.    png_debug(1, "in png_do_gray_to_rgbn");
  1856.    if (row_info->bit_depth >= 8 &&
  1857. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1858.        row != NULL && row_info != NULL &&
  1859. #endif
  1860.       !(row_info->color_type & PNG_COLOR_MASK_COLOR))
  1861.    {
  1862.       if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
  1863.       {
  1864.          if (row_info->bit_depth == 8)
  1865.          {
  1866.             png_bytep sp = row + (png_size_t)row_width - 1;
  1867.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1868.             for (i = 0; i < row_width; i++)
  1869.             {
  1870.                *(dp--) = *sp;
  1871.                *(dp--) = *sp;
  1872.                *(dp--) = *(sp--);
  1873.             }
  1874.          }
  1875.          else
  1876.          {
  1877.             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
  1878.             png_bytep dp = sp  + (png_size_t)row_width * 4;
  1879.             for (i = 0; i < row_width; i++)
  1880.             {
  1881.                *(dp--) = *sp;
  1882.                *(dp--) = *(sp - 1);
  1883.                *(dp--) = *sp;
  1884.                *(dp--) = *(sp - 1);
  1885.                *(dp--) = *(sp--);
  1886.                *(dp--) = *(sp--);
  1887.             }
  1888.          }
  1889.       }
  1890.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  1891.       {
  1892.          if (row_info->bit_depth == 8)
  1893.          {
  1894.             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
  1895.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  1896.             for (i = 0; i < row_width; i++)
  1897.             {
  1898.                *(dp--) = *(sp--);
  1899.                *(dp--) = *sp;
  1900.                *(dp--) = *sp;
  1901.                *(dp--) = *(sp--);
  1902.             }
  1903.          }
  1904.          else
  1905.          {
  1906.             png_bytep sp = row + (png_size_t)row_width * 4 - 1;
  1907.             png_bytep dp = sp  + (png_size_t)row_width * 4;
  1908.             for (i = 0; i < row_width; i++)
  1909.             {
  1910.                *(dp--) = *(sp--);
  1911.                *(dp--) = *(sp--);
  1912.                *(dp--) = *sp;
  1913.                *(dp--) = *(sp - 1);
  1914.                *(dp--) = *sp;
  1915.                *(dp--) = *(sp - 1);
  1916.                *(dp--) = *(sp--);