Ignore:
Timestamp:
May 5, 2011, 5:36:53 AM (14 years ago)
Author:
Dmitry A. Kuminov
Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/src/3rdparty/libpng/pngrtran.c

    r561 r846  
    22/* pngrtran.c - transforms the data in a row for PNG readers
    33 *
    4  * Last changed in libpng 1.2.38 [July 16, 2009]
    5  * Copyright (c) 1998-2009 Glenn Randers-Pehrson
     4 * Last changed in libpng 1.4.0 [January 3, 2010]
     5 * Copyright (c) 1998-2010 Glenn Randers-Pehrson
    66 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    77 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    … …  
    1717 */
    1818
    19 #define PNG_INTERNAL
     19#define PNG_NO_PEDANTIC_WARNINGS
    2020#include "png.h"
    21 #if defined(PNG_READ_SUPPORTED)
     21#ifdef PNG_READ_SUPPORTED
     22#include "pngpriv.h"
    2223
    2324/* Set the action on getting a CRC error for an ancillary or critical chunk. */
    … …  
    2627{
    2728   png_debug(1, "in png_set_crc_action");
    28    /* Tell libpng how we react to CRC errors in critical chunks */
     29 
    2930   if (png_ptr == NULL)
    3031      return;
     32
     33   /* Tell libpng how we react to CRC errors in critical chunks */
    3134   switch (crit_action)
    3235   {
    … …  
    4750      case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */
    4851         png_warning(png_ptr,
    49             "Can't discard critical data on CRC error.");
     52            "Can't discard critical data on CRC error");
    5053      case PNG_CRC_ERROR_QUIT:                                /* Error/quit */
    5154
    … …  
    5659   }
    5760
     61   /* Tell libpng how we react to CRC errors in ancillary chunks */
    5862   switch (ancil_action)
    5963   {
    … …  
    9599{
    96100   png_debug(1, "in png_set_background");
     101 
    97102   if (png_ptr == NULL)
    98103      return;
    … …  
    112117#endif
    113118
    114 #if defined(PNG_READ_16_TO_8_SUPPORTED)
     119#ifdef PNG_READ_16_TO_8_SUPPORTED
    115120/* Strip 16 bit depth files to 8 bit depth */
    116121void PNGAPI
    … …  
    118123{
    119124   png_debug(1, "in png_set_strip_16");
     125
    120126   if (png_ptr == NULL)
    121127      return;
    … …  
    124130#endif
    125131
    126 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
     132#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    127133void PNGAPI
    128134png_set_strip_alpha(png_structp png_ptr)
    129135{
    130136   png_debug(1, "in png_set_strip_alpha");
     137
    131138   if (png_ptr == NULL)
    132139      return;
    … …  
    135142#endif
    136143
    137 #if defined(PNG_READ_DITHER_SUPPORTED)
     144#ifdef PNG_READ_DITHER_SUPPORTED
    138145/* Dither file to 8 bit.  Supply a palette, the current number
    139146 * of elements in the palette, the maximum number of elements
    … …  
    160167{
    161168   png_debug(1, "in png_set_dither");
     169
    162170   if (png_ptr == NULL)
    163171      return;
    … …  
    329337         }
    330338
    331          hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
     339         hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
    332340            png_sizeof(png_dsortp)));
    333          png_memset(hash, 0, 769 * png_sizeof(png_dsortp));
    334341
    335342         num_new_palette = num_palette;
    … …  
    477484      int num_blue = (1 << PNG_DITHER_BLUE_BITS);
    478485      png_size_t num_entries = ((png_size_t)1 << total_bits);
    479       png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
     486
     487      png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,
    480488         (png_uint_32)(num_entries * png_sizeof(png_byte)));
    481       png_memset(png_ptr->palette_lookup, 0, num_entries *
    482          png_sizeof(png_byte));
    483489
    484490      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
    485491         png_sizeof(png_byte)));
    486 
    487492      png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
    488493
    … …  
    545550{
    546551   png_debug(1, "in png_set_gamma");
     552
    547553   if (png_ptr == NULL)
    548554      return;
     555
    549556   if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
    550557       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
    … …  
    556563#endif
    557564
    558 #if defined(PNG_READ_EXPAND_SUPPORTED)
     565#ifdef PNG_READ_EXPAND_SUPPORTED
    559566/* Expand paletted images to RGB, expand grayscale images of
    560567 * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
    … …  
    565572{
    566573   png_debug(1, "in png_set_expand");
     574
    567575   if (png_ptr == NULL)
    568576      return;
     577
    569578   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
    570579   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
    … …  
    584593 *  doing, whereas "expand" can (and does) mean any number of things.
    585594 *
    586  *  GRP 20060307: In libpng-1.4.0, png_set_gray_1_2_4_to_8() was modified
    587  *  to expand only the sample depth but not to expand the tRNS to alpha.
     595 *  GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified
     596 *  to expand only the sample depth but not to expand the tRNS to alpha
     597 *  and its name was changed to png_set_expand_gray_1_2_4_to_8().
    588598 */
    589599
    … …  
    593603{
    594604   png_debug(1, "in png_set_palette_to_rgb");
     605
    595606   if (png_ptr == NULL)
    596607      return;
     608
    597609   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
    598610   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
    599611}
    600612
    601 #if !defined(PNG_1_0_X)
    602613/* Expand grayscale images of less than 8-bit depth to 8 bits. */
    603614void PNGAPI
    … …  
    605616{
    606617   png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
     618
    607619   if (png_ptr == NULL)
    608620      return;
     621
    609622   png_ptr->transformations |= PNG_EXPAND;
    610623   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
    611624}
    612 #endif
    613 
    614 #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
    615 /* Expand grayscale images of less than 8-bit depth to 8 bits. */
    616 /* Deprecated as of libpng-1.2.9 */
    617 void PNGAPI
    618 png_set_gray_1_2_4_to_8(png_structp png_ptr)
    619 {
    620    png_debug(1, "in png_set_gray_1_2_4_to_8");
    621    if (png_ptr == NULL)
    622       return;
    623    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
    624 }
    625 #endif
     625
    626626
    627627
    … …  
    631631{
    632632   png_debug(1, "in png_set_tRNS_to_alpha");
     633
    633634   png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
    634635   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
    … …  
    636637#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
    637638
    638 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     639#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    639640void PNGAPI
    640641png_set_gray_to_rgb(png_structp png_ptr)
    641642{
    642643   png_debug(1, "in png_set_gray_to_rgb");
     644
    643645   png_ptr->transformations |= PNG_GRAY_TO_RGB;
    644646   png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
    … …  
    646648#endif
    647649
    648 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
    649 #if defined(PNG_FLOATING_POINT_SUPPORTED)
     650#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
     651#ifdef PNG_FLOATING_POINT_SUPPORTED
    650652/* Convert a RGB image to a grayscale of the same width.  This allows us,
    651653 * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
    … …  
    669671{
    670672   png_debug(1, "in png_set_rgb_to_gray");
     673
    671674   if (png_ptr == NULL)
    672675      return;
     676
    673677   switch(error_action)
    674678   {
    … …  
    682686   }
    683687   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    684 #if defined(PNG_READ_EXPAND_SUPPORTED)
     688#ifdef PNG_READ_EXPAND_SUPPORTED
    685689      png_ptr->transformations |= PNG_EXPAND;
    686690#else
    687691   {
    688692      png_warning(png_ptr,
    689         "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
     693        "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
    690694      png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
    691695   }
    … …  
    718722
    719723#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
    720     defined(PNG_LEGACY_SUPPORTED) || \
    721724    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
    722725void PNGAPI
    … …  
    725728{
    726729   png_debug(1, "in png_set_read_user_transform_fn");
     730
    727731   if (png_ptr == NULL)
    728732      return;
    729 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
     733
     734#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
    730735   png_ptr->transformations |= PNG_USER_TRANSFORM;
    731736   png_ptr->read_user_transform_fn = read_user_transform_fn;
    732 #endif
    733 #ifdef PNG_LEGACY_SUPPORTED
    734    if (read_user_transform_fn)
    735       png_warning(png_ptr,
    736         "This version of libpng does not support user transforms");
    737737#endif
    738738}
    … …  
    746746{
    747747   png_debug(1, "in png_init_read_transformations");
    748 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    749    if (png_ptr != NULL)
    750 #endif
     748
    751749  {
    752750#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
    … …  
    757755#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
    758756
    759 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     757#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    760758   /* Detect gray background and attempt to enable optimization
    761759    * for gray --> RGB case
    … …  
    797795               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
    798796               {
    799                  png_ptr->trans_values.gray *= (png_uint_16)0xff;
    800                  png_ptr->trans_values.red = png_ptr->trans_values.green
    801                    = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
     797                 png_ptr->trans_color.gray *= (png_uint_16)0xff;
     798                 png_ptr->trans_color.red = png_ptr->trans_color.green
     799                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
    802800               }
    803801               break;
    … …  
    809807               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
    810808               {
    811                  png_ptr->trans_values.gray *= (png_uint_16)0x55;
    812                  png_ptr->trans_values.red = png_ptr->trans_values.green
    813                    = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
     809                 png_ptr->trans_color.gray *= (png_uint_16)0x55;
     810                 png_ptr->trans_color.red = png_ptr->trans_color.green
     811                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
    814812               }
    815813               break;
    … …  
    821819               if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
    822820               {
    823                  png_ptr->trans_values.gray *= (png_uint_16)0x11;
    824                  png_ptr->trans_values.red = png_ptr->trans_values.green
    825                    = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
     821                 png_ptr->trans_color.gray *= (png_uint_16)0x11;
     822                 png_ptr->trans_color.red = png_ptr->trans_color.green
     823                   = png_ptr->trans_color.blue = png_ptr->trans_color.gray;
    826824               }
    827825               break;
    … …  
    844842            png_ptr->palette[png_ptr->background.index].blue;
    845843
    846 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
     844#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
    847845        if (png_ptr->transformations & PNG_INVERT_ALPHA)
    848846        {
    849 #if defined(PNG_READ_EXPAND_SUPPORTED)
     847#ifdef PNG_READ_EXPAND_SUPPORTED
    850848           if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
    851849#endif
    … …  
    857855              istop=(int)png_ptr->num_trans;
    858856              for (i=0; i<istop; i++)
    859                  png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
     857                 png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i]);
    860858           }
    861859        }
    … …  
    879877    for (i=0; i<png_ptr->num_trans; i++)
    880878    {
    881       if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
     879      if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff)
    882880        k=1; /* Partial transparency is present */
    883881    }
    … …  
    889887        png_ptr->gamma != 0.0)
    890888   {
    891       png_build_gamma_table(png_ptr);
    892 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     889      png_build_gamma_table(png_ptr, png_ptr->bit_depth);
     890
     891#ifdef PNG_READ_BACKGROUND_SUPPORTED
    893892      if (png_ptr->transformations & PNG_BACKGROUND)
    894893      {
    … …  
    945944               {
    946945                  back.red = (png_byte)(pow(
    947                      (double)png_ptr->background.red/255, gs) * 255.0 + .5);
     946                     (double)png_ptr->background.red/255.0, gs) * 255.0 + .5);
    948947                  back.green = (png_byte)(pow(
    949                      (double)png_ptr->background.green/255, gs) * 255.0 + .5);
     948                     (double)png_ptr->background.green/255.0, gs) * 255.0 + .5);
    950949                  back.blue = (png_byte)(pow(
    951                      (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
     950                     (double)png_ptr->background.blue/255.0, gs) * 255.0 + .5);
    952951               }
    953952
    954953               back_1.red = (png_byte)(pow(
    955                   (double)png_ptr->background.red/255, g) * 255.0 + .5);
     954                  (double)png_ptr->background.red/255.0, g) * 255.0 + .5);
    956955               back_1.green = (png_byte)(pow(
    957                   (double)png_ptr->background.green/255, g) * 255.0 + .5);
     956                  (double)png_ptr->background.green/255.0, g) * 255.0 + .5);
    958957               back_1.blue = (png_byte)(pow(
    959                   (double)png_ptr->background.blue/255, g) * 255.0 + .5);
     958                  (double)png_ptr->background.blue/255.0, g) * 255.0 + .5);
    960959            }
    961960            for (i = 0; i < num_palette; i++)
    962961            {
    963                if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
    964                {
    965                   if (png_ptr->trans[i] == 0)
     962               if (i < (int)png_ptr->num_trans && png_ptr->trans_alpha[i] != 0xff)
     963               {
     964                  if (png_ptr->trans_alpha[i] == 0)
    966965                  {
    967966                     palette[i] = back;
    968967                  }
    969                   else /* if (png_ptr->trans[i] != 0xff) */
     968                  else /* if (png_ptr->trans_alpha[i] != 0xff) */
    970969                  {
    971970                     png_byte v, w;
    972971
    973972                     v = png_ptr->gamma_to_1[palette[i].red];
    974                      png_composite(w, v, png_ptr->trans[i], back_1.red);
     973                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
    975974                     palette[i].red = png_ptr->gamma_from_1[w];
    976975
    977976                     v = png_ptr->gamma_to_1[palette[i].green];
    978                      png_composite(w, v, png_ptr->trans[i], back_1.green);
     977                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
    979978                     palette[i].green = png_ptr->gamma_from_1[w];
    980979
    981980                     v = png_ptr->gamma_to_1[palette[i].blue];
    982                      png_composite(w, v, png_ptr->trans[i], back_1.blue);
     981                     png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
    983982                     palette[i].blue = png_ptr->gamma_from_1[w];
    984983                  }
    … …  
    991990               }
    992991            }
    993             /* Prevent the transformations being done again, and make sure
    994              * that the now spurious alpha channel is stripped - the code
    995              * has just reduced background composition and gamma correction
    996              * to a simple alpha channel strip.
    997              */
    998             png_ptr->transformations &= ~PNG_BACKGROUND;
    999             png_ptr->transformations &= ~PNG_GAMMA;
    1000             png_ptr->transformations |= PNG_STRIP_ALPHA;
     992            /* Prevent the transformations being done again, and make sure
     993             * that the now spurious alpha channel is stripped - the code
     994             * has just reduced background composition and gamma correction
     995             * to a simple alpha channel strip.
     996             */
     997            png_ptr->transformations &= ~PNG_BACKGROUND;
     998            png_ptr->transformations &= ~PNG_GAMMA;
     999            png_ptr->transformations |= PNG_STRIP_ALPHA;
    10011000         }
    10021001         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
    … …  
    10761075         }
    10771076
    1078         /* Done the gamma correction. */
    1079         png_ptr->transformations &= ~PNG_GAMMA;
     1077        /* Done the gamma correction. */
     1078        png_ptr->transformations &= ~PNG_GAMMA;
    10801079      }
    10811080   }
    1082 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     1081#ifdef PNG_READ_BACKGROUND_SUPPORTED
    10831082   else
    10841083#endif
    10851084#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
    1086 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     1085#ifdef PNG_READ_BACKGROUND_SUPPORTED
    10871086   /* No GAMMA transformation */
    10881087   if ((png_ptr->transformations & PNG_BACKGROUND) &&
    … …  
    11001099      for (i = 0; i < istop; i++)
    11011100      {
    1102          if (png_ptr->trans[i] == 0)
     1101         if (png_ptr->trans_alpha[i] == 0)
    11031102         {
    11041103            palette[i] = back;
    11051104         }
    1106          else if (png_ptr->trans[i] != 0xff)
     1105         else if (png_ptr->trans_alpha[i] != 0xff)
    11071106         {
    11081107            /* The png_composite() macro is defined in png.h */
    11091108            png_composite(palette[i].red, palette[i].red,
    1110                png_ptr->trans[i], back.red);
     1109               png_ptr->trans_alpha[i], back.red);
    11111110            png_composite(palette[i].green, palette[i].green,
    1112                png_ptr->trans[i], back.green);
     1111               png_ptr->trans_alpha[i], back.green);
    11131112            png_composite(palette[i].blue, palette[i].blue,
    1114                png_ptr->trans[i], back.blue);
     1113               png_ptr->trans_alpha[i], back.blue);
    11151114         }
    11161115      }
    … …  
    11221121#endif /* PNG_READ_BACKGROUND_SUPPORTED */
    11231122
    1124 #if defined(PNG_READ_SHIFT_SUPPORTED)
     1123#ifdef PNG_READ_SHIFT_SUPPORTED
    11251124   if ((png_ptr->transformations & PNG_SHIFT) &&
    11261125      (color_type == PNG_COLOR_TYPE_PALETTE))
    … …  
    11621161{
    11631162   png_debug(1, "in png_read_transform_info");
    1164 #if defined(PNG_READ_EXPAND_SUPPORTED)
     1163
     1164#ifdef PNG_READ_EXPAND_SUPPORTED
    11651165   if (png_ptr->transformations & PNG_EXPAND)
    11661166   {
    … …  
    11891189#endif
    11901190
    1191 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     1191#ifdef PNG_READ_BACKGROUND_SUPPORTED
    11921192   if (png_ptr->transformations & PNG_BACKGROUND)
    11931193   {
    … …  
    11981198#endif
    11991199
    1200 #if defined(PNG_READ_GAMMA_SUPPORTED)
     1200#ifdef PNG_READ_GAMMA_SUPPORTED
    12011201   if (png_ptr->transformations & PNG_GAMMA)
    12021202   {
    … …  
    12101210#endif
    12111211
    1212 #if defined(PNG_READ_16_TO_8_SUPPORTED)
     1212#ifdef PNG_READ_16_TO_8_SUPPORTED
    12131213   if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
    12141214      info_ptr->bit_depth = 8;
    12151215#endif
    12161216
    1217 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     1217#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    12181218   if (png_ptr->transformations & PNG_GRAY_TO_RGB)
    12191219      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
    12201220#endif
    12211221
    1222 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
     1222#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    12231223   if (png_ptr->transformations & PNG_RGB_TO_GRAY)
    12241224      info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
    12251225#endif
    12261226
    1227 #if defined(PNG_READ_DITHER_SUPPORTED)
     1227#ifdef PNG_READ_DITHER_SUPPORTED
    12281228   if (png_ptr->transformations & PNG_DITHER)
    12291229   {
    … …  
    12371237#endif
    12381238
    1239 #if defined(PNG_READ_PACK_SUPPORTED)
     1239#ifdef PNG_READ_PACK_SUPPORTED
    12401240   if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
    12411241      info_ptr->bit_depth = 8;
    … …  
    12491249      info_ptr->channels = 1;
    12501250
    1251 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
     1251#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    12521252   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
    12531253      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
    … …  
    12571257      info_ptr->channels++;
    12581258
    1259 #if defined(PNG_READ_FILLER_SUPPORTED)
     1259#ifdef PNG_READ_FILLER_SUPPORTED
    12601260   /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
    12611261   if ((png_ptr->transformations & PNG_FILLER) &&
    … …  
    12651265      info_ptr->channels++;
    12661266      /* If adding a true alpha channel not just filler */
    1267 #if !defined(PNG_1_0_X)
    12681267      if (png_ptr->transformations & PNG_ADD_ALPHA)
    12691268        info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
    1270 #endif
    12711269   }
    12721270#endif
    … …  
    12881286   info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
    12891287
    1290 #if !defined(PNG_READ_EXPAND_SUPPORTED)
     1288#ifndef PNG_READ_EXPAND_SUPPORTED
    12911289   if (png_ptr)
    12921290      return;
    … …  
    13021300{
    13031301   png_debug(1, "in png_do_read_transformations");
     1302
    13041303   if (png_ptr->row_buf == NULL)
    13051304   {
    1306 #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
     1305#ifdef PNG_STDIO_SUPPORTED
    13071306      char msg[50];
    13081307
    … …  
    13281327#endif
    13291328
    1330 #if defined(PNG_READ_EXPAND_SUPPORTED)
     1329#ifdef PNG_READ_EXPAND_SUPPORTED
    13311330   if (png_ptr->transformations & PNG_EXPAND)
    13321331   {
    … …  
    13341333      {
    13351334         png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
    1336             png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
     1335            png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
    13371336      }
    13381337      else
    … …  
    13411340             (png_ptr->transformations & PNG_EXPAND_tRNS))
    13421341            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
    1343                &(png_ptr->trans_values));
     1342               &(png_ptr->trans_color));
    13441343         else
    13451344            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
    … …  
    13491348#endif
    13501349
    1351 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
     1350#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    13521351   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
    13531352      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
    … …  
    13551354#endif
    13561355
    1357 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
     1356#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    13581357   if (png_ptr->transformations & PNG_RGB_TO_GRAY)
    13591358   {
    … …  
    14041403 */
    14051404
    1406 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     1405#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    14071406   /* If gray -> RGB, do so now only if background is non-gray; else do later
    14081407    * for performance reasons
    … …  
    14131412#endif
    14141413
    1415 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     1414#ifdef PNG_READ_BACKGROUND_SUPPORTED
    14161415   if ((png_ptr->transformations & PNG_BACKGROUND) &&
    14171416      ((png_ptr->num_trans != 0 ) ||
    14181417      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
    14191418      png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
    1420          &(png_ptr->trans_values), &(png_ptr->background)
    1421 #if defined(PNG_READ_GAMMA_SUPPORTED)
     1419         &(png_ptr->trans_color), &(png_ptr->background)
     1420#ifdef PNG_READ_GAMMA_SUPPORTED
    14221421         , &(png_ptr->background_1),
    14231422         png_ptr->gamma_table, png_ptr->gamma_from_1,
    … …  
    14291428#endif
    14301429
    1431 #if defined(PNG_READ_GAMMA_SUPPORTED)
     1430#ifdef PNG_READ_GAMMA_SUPPORTED
    14321431   if ((png_ptr->transformations & PNG_GAMMA) &&
    1433 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     1432#ifdef PNG_READ_BACKGROUND_SUPPORTED
    14341433       !((png_ptr->transformations & PNG_BACKGROUND) &&
    14351434       ((png_ptr->num_trans != 0) ||
    … …  
    14421441#endif
    14431442
    1444 #if defined(PNG_READ_16_TO_8_SUPPORTED)
     1443#ifdef PNG_READ_16_TO_8_SUPPORTED
    14451444   if (png_ptr->transformations & PNG_16_TO_8)
    14461445      png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
    14471446#endif
    14481447
    1449 #if defined(PNG_READ_DITHER_SUPPORTED)
     1448#ifdef PNG_READ_DITHER_SUPPORTED
    14501449   if (png_ptr->transformations & PNG_DITHER)
    14511450   {
    … …  
    14571456#endif
    14581457
    1459 #if defined(PNG_READ_INVERT_SUPPORTED)
     1458#ifdef PNG_READ_INVERT_SUPPORTED
    14601459   if (png_ptr->transformations & PNG_INVERT_MONO)
    14611460      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
    14621461#endif
    14631462
    1464 #if defined(PNG_READ_SHIFT_SUPPORTED)
     1463#ifdef PNG_READ_SHIFT_SUPPORTED
    14651464   if (png_ptr->transformations & PNG_SHIFT)
    14661465      png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
    … …  
    14681467#endif
    14691468
    1470 #if defined(PNG_READ_PACK_SUPPORTED)
     1469#ifdef PNG_READ_PACK_SUPPORTED
    14711470   if (png_ptr->transformations & PNG_PACK)
    14721471      png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
    14731472#endif
    14741473
    1475 #if defined(PNG_READ_BGR_SUPPORTED)
     1474#ifdef PNG_READ_BGR_SUPPORTED
    14761475   if (png_ptr->transformations & PNG_BGR)
    14771476      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
    14781477#endif
    14791478
    1480 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
     1479#ifdef PNG_READ_PACKSWAP_SUPPORTED
    14811480   if (png_ptr->transformations & PNG_PACKSWAP)
    14821481      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
    14831482#endif
    14841483
    1485 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     1484#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    14861485   /* If gray -> RGB, do so now only if we did not do so above */
    14871486   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
    … …  
    14901489#endif
    14911490
    1492 #if defined(PNG_READ_FILLER_SUPPORTED)
     1491#ifdef PNG_READ_FILLER_SUPPORTED
    14931492   if (png_ptr->transformations & PNG_FILLER)
    14941493      png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
    … …  
    14961495#endif
    14971496
    1498 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
     1497#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
    14991498   if (png_ptr->transformations & PNG_INVERT_ALPHA)
    15001499      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
    15011500#endif
    15021501
    1503 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
     1502#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
    15041503   if (png_ptr->transformations & PNG_SWAP_ALPHA)
    15051504      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
    15061505#endif
    15071506
    1508 #if defined(PNG_READ_SWAP_SUPPORTED)
     1507#ifdef PNG_READ_SWAP_SUPPORTED
    15091508   if (png_ptr->transformations & PNG_SWAP_BYTES)
    15101509      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
    15111510#endif
    15121511
    1513 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
     1512#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
    15141513   if (png_ptr->transformations & PNG_USER_TRANSFORM)
    15151514    {
    … …  
    15251524               /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
    15261525               png_ptr->row_buf + 1);    /* start of pixel data for row */
    1527 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
     1526#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
    15281527      if (png_ptr->user_transform_depth)
    15291528         png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
    … …  
    15401539}
    15411540
    1542 #if defined(PNG_READ_PACK_SUPPORTED)
     1541#ifdef PNG_READ_PACK_SUPPORTED
    15431542/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
    15441543 * without changing the actual values.  Thus, if you had a row with
    … …  
    15511550{
    15521551   png_debug(1, "in png_do_unpack");
    1553 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    1554    if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
    1555 #else
     1552
    15561553   if (row_info->bit_depth < 8)
    1557 #endif
    15581554   {
    15591555      png_uint_32 i;
    … …  
    16331629#endif
    16341630
    1635 #if defined(PNG_READ_SHIFT_SUPPORTED)
     1631#ifdef PNG_READ_SHIFT_SUPPORTED
    16361632/* Reverse the effects of png_do_shift.  This routine merely shifts the
    16371633 * pixels back to their significant bits values.  Thus, if you have
    … …  
    16431639{
    16441640   png_debug(1, "in png_do_unshift");
     1641
    16451642   if (
    1646 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    1647        row != NULL && row_info != NULL && sig_bits != NULL &&
    1648 #endif
    16491643       row_info->color_type != PNG_COLOR_TYPE_PALETTE)
    16501644   {
    … …  
    17461740#endif
    17471741
    1748 #if defined(PNG_READ_16_TO_8_SUPPORTED)
     1742#ifdef PNG_READ_16_TO_8_SUPPORTED
    17491743/* Chop rows of bit depth 16 down to 8 */
    17501744void /* PRIVATE */
    … …  
    17521746{
    17531747   png_debug(1, "in png_do_chop");
    1754 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    1755    if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
    1756 #else
     1748
    17571749   if (row_info->bit_depth == 16)
    1758 #endif
    17591750   {
    17601751      png_bytep sp = row;
    … …  
    17651756      for (i = 0; i<istop; i++, sp += 2, dp++)
    17661757      {
    1767 #if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
     1758#ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
    17681759      /* This does a more accurate scaling of the 16-bit color
    17691760       * value, rather than a simple low-byte truncation.
    … …  
    18041795#endif
    18051796
    1806 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
     1797#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
    18071798void /* PRIVATE */
    18081799png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
    18091800{
    18101801   png_debug(1, "in png_do_read_swap_alpha");
    1811 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    1812    if (row != NULL && row_info != NULL)
    1813 #endif
     1802
    18141803   {
    18151804      png_uint_32 row_width = row_info->width;
    … …  
    18961885#endif
    18971886
    1898 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
     1887#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
    18991888void /* PRIVATE */
    19001889png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
    19011890{
    19021891   png_debug(1, "in png_do_read_invert_alpha");
    1903 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    1904    if (row != NULL && row_info != NULL)
    1905 #endif
     1892
    19061893   {
    19071894      png_uint_32 row_width = row_info->width;
    … …  
    19941981#endif
    19951982
    1996 #if defined(PNG_READ_FILLER_SUPPORTED)
     1983#ifdef PNG_READ_FILLER_SUPPORTED
    19971984/* Add filler channel if we have RGB color */
    19981985void /* PRIVATE */
    … …  
    20071994
    20081995   png_debug(1, "in png_do_read_filler");
     1996
    20091997   if (
    2010 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    2011        row != NULL  && row_info != NULL &&
    2012 #endif
    20131998       row_info->color_type == PNG_COLOR_TYPE_GRAY)
    20141999   {
    … …  
    21702155#endif
    21712156
    2172 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
     2157#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    21732158/* Expand grayscale files to RGB, with or without alpha */
    21742159void /* PRIVATE */
    … …  
    21792164
    21802165   png_debug(1, "in png_do_gray_to_rgb");
     2166
    21812167   if (row_info->bit_depth >= 8 &&
    2182 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    2183        row != NULL && row_info != NULL &&
    2184 #endif
    21852168      !(row_info->color_type & PNG_COLOR_MASK_COLOR))
    21862169   {
    … …  
    22532236#endif
    22542237
    2255 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
     2238#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    22562239/* Reduce RGB files to grayscale, with or without alpha
    22572240 * using the equation given in Poynton's ColorFAQ at
    … …  
    22852268
    22862269   png_debug(1, "in png_do_rgb_to_gray");
     2270
    22872271   if (
    2288 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    2289        row != NULL && row_info != NULL &&
    2290 #endif
    22912272      (row_info->color_type & PNG_COLOR_MASK_COLOR))
    22922273   {
    … …  
    25232504
    25242505   png_debug(1, "in png_do_build_grayscale_palette");
     2506
    25252507   if (palette == NULL)
    25262508      return;
    … …  
    25622544}
    25632545
    2564 /* This function is currently unused.  Do we really need it? */
    2565 #if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
    2566 void /* PRIVATE */
    2567 png_correct_palette(png_structp png_ptr, png_colorp palette,
    2568    int num_palette)
    2569 {
    2570    png_debug(1, "in png_correct_palette");
    2571 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
    2572     defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
    2573    if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
    2574    {
    2575       png_color back, back_1;
    2576 
    2577       if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
    2578       {
    2579          back.red = png_ptr->gamma_table[png_ptr->background.red];
    2580          back.green = png_ptr->gamma_table[png_ptr->background.green];
    2581          back.blue = png_ptr->gamma_table[png_ptr->background.blue];
    2582 
    2583          back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
    2584          back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
    2585          back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
    2586       }
    2587       else
    2588       {
    2589          double g;
    2590 
    2591          g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
    2592 
    2593          if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
    2594              fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
    2595          {
    2596             back.red = png_ptr->background.red;
    2597             back.green = png_ptr->background.green;
    2598             back.blue = png_ptr->background.blue;
    2599          }
    2600          else
    2601          {
    2602             back.red =
    2603                (png_byte)(pow((double)png_ptr->background.red/255, g) *
    2604                 255.0 + 0.5);
    2605             back.green =
    2606                (png_byte)(pow((double)png_ptr->background.green/255, g) *
    2607                 255.0 + 0.5);
    2608             back.blue =
    2609                (png_byte)(pow((double)png_ptr->background.blue/255, g) *
    2610                 255.0 + 0.5);
    2611          }
    2612 
    2613          g = 1.0 / png_ptr->background_gamma;
    2614 
    2615          back_1.red =
    2616             (png_byte)(pow((double)png_ptr->background.red/255, g) *
    2617              255.0 + 0.5);
    2618          back_1.green =
    2619             (png_byte)(pow((double)png_ptr->background.green/255, g) *
    2620              255.0 + 0.5);
    2621          back_1.blue =
    2622             (png_byte)(pow((double)png_ptr->background.blue/255, g) *
    2623              255.0 + 0.5);
    2624       }
    2625 
    2626       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    2627       {
    2628          png_uint_32 i;
    2629 
    2630          for (i = 0; i < (png_uint_32)num_palette; i++)
    2631          {
    2632             if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
    2633             {
    2634                palette[i] = back;
    2635             }
    2636             else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
    2637             {
    2638                png_byte v, w;
    2639 
    2640                v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
    2641                png_composite(w, v, png_ptr->trans[i], back_1.red);
    2642                palette[i].red = png_ptr->gamma_from_1[w];
    2643 
    2644                v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
    2645                png_composite(w, v, png_ptr->trans[i], back_1.green);
    2646                palette[i].green = png_ptr->gamma_from_1[w];
    2647 
    2648                v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
    2649                png_composite(w, v, png_ptr->trans[i], back_1.blue);
    2650                palette[i].blue = png_ptr->gamma_from_1[w];
    2651             }
    2652             else
    2653             {
    2654                palette[i].red = png_ptr->gamma_table[palette[i].red];
    2655                palette[i].green = png_ptr->gamma_table[palette[i].green];
    2656                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
    2657             }
    2658          }
    2659       }
    2660       else
    2661       {
    2662          int i;
    2663 
    2664          for (i = 0; i < num_palette; i++)
    2665          {
    2666             if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
    2667             {
    2668                palette[i] = back;
    2669             }
    2670             else
    2671             {
    2672                palette[i].red = png_ptr->gamma_table[palette[i].red];
    2673                palette[i].green = png_ptr->gamma_table[palette[i].green];
    2674                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
    2675             }
    2676          }
    2677       }
    2678    }
    2679    else
    2680 #endif
    2681 #if defined(PNG_READ_GAMMA_SUPPORTED)
    2682    if (png_ptr->transformations & PNG_GAMMA)
    2683    {
    2684       int i;
    2685 
    2686       for (i = 0; i < num_palette; i++)
    2687       {
    2688          palette[i].red = png_ptr->gamma_table[palette[i].red];
    2689          palette[i].green = png_ptr->gamma_table[palette[i].green];
    2690          palette[i].blue = png_ptr->gamma_table[palette[i].blue];
    2691       }
    2692    }
    2693 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
    2694    else
    2695 #endif
    2696 #endif
    2697 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
    2698    if (png_ptr->transformations & PNG_BACKGROUND)
    2699    {
    2700       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    2701       {
    2702          png_color back;
    2703 
    2704          back.red   = (png_byte)png_ptr->background.red;
    2705          back.green = (png_byte)png_ptr->background.green;
    2706          back.blue  = (png_byte)png_ptr->background.blue;
    2707 
    2708          for (i = 0; i < (int)png_ptr->num_trans; i++)
    2709          {
    2710             if (png_ptr->trans[i] == 0)
    2711             {
    2712                palette[i].red = back.red;
    2713                palette[i].green = back.green;
    2714                palette[i].blue = back.blue;
    2715             }
    2716             else if (png_ptr->trans[i] != 0xff)
    2717             {
    2718                png_composite(palette[i].red, png_ptr->palette[i].red,
    2719                   png_ptr->trans[i], back.red);
    2720                png_composite(palette[i].green, png_ptr->palette[i].green,
    2721                   png_ptr->trans[i], back.green);
    2722                png_composite(palette[i].blue, png_ptr->palette[i].blue,
    2723                   png_ptr->trans[i], back.blue);
    2724             }
    2725          }
    2726       }
    2727       else /* Assume grayscale palette (what else could it be?) */
    2728       {
    2729          int i;
    2730 
    2731          for (i = 0; i < num_palette; i++)
    2732          {
    2733             if (i == (png_byte)png_ptr->trans_values.gray)
    2734             {
    2735                palette[i].red = (png_byte)png_ptr->background.red;
    2736                palette[i].green = (png_byte)png_ptr->background.green;
    2737                palette[i].blue = (png_byte)png_ptr->background.blue;
    2738             }
    2739          }
    2740       }
    2741    }
    2742 #endif
    2743 }
    2744 #endif
    2745 
    2746 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
     2546
     2547#ifdef PNG_READ_BACKGROUND_SUPPORTED
    27472548/* Replace any alpha or transparency with the supplied background color.
    27482549 * "background" is already in the screen gamma, while "background_1" is
    … …  
    27512552void /* PRIVATE */
    27522553png_do_background(png_row_infop row_info, png_bytep row,
    2753    png_color_16p trans_values, png_color_16p background
    2754 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2554   png_color_16p trans_color, png_color_16p background
     2555#ifdef PNG_READ_GAMMA_SUPPORTED
    27552556   , png_color_16p background_1,
    27562557   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
    … …  
    27662567
    27672568   png_debug(1, "in png_do_background");
     2569
    27682570   if (background != NULL &&
    2769 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    2770        row != NULL && row_info != NULL &&
    2771 #endif
    27722571      (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
    2773       (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
     2572      (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color)))
    27742573   {
    27752574      switch (row_info->color_type)
    … …  
    27862585                  {
    27872586                     if ((png_uint_16)((*sp >> shift) & 0x01)
    2788                         == trans_values->gray)
     2587                        == trans_color->gray)
    27892588                     {
    27902589                        *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
    … …  
    28042603               case 2:
    28052604               {
    2806 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2605#ifdef PNG_READ_GAMMA_SUPPORTED
    28072606                  if (gamma_table != NULL)
    28082607                  {
    … …  
    28122611                     {
    28132612                        if ((png_uint_16)((*sp >> shift) & 0x03)
    2814                             == trans_values->gray)
     2613                            == trans_color->gray)
    28152614                        {
    28162615                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
    … …  
    28422641                     {
    28432642                        if ((png_uint_16)((*sp >> shift) & 0x03)
    2844                             == trans_values->gray)
     2643                            == trans_color->gray)
    28452644                        {
    28462645                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
    … …  
    28612660               case 4:
    28622661               {
    2863 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2662#ifdef PNG_READ_GAMMA_SUPPORTED
    28642663                  if (gamma_table != NULL)
    28652664                  {
    … …  
    28692668                     {
    28702669                        if ((png_uint_16)((*sp >> shift) & 0x0f)
    2871                             == trans_values->gray)
     2670                            == trans_color->gray)
    28722671                        {
    28732672                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
    … …  
    28992698                     {
    29002699                        if ((png_uint_16)((*sp >> shift) & 0x0f)
    2901                             == trans_values->gray)
     2700                            == trans_color->gray)
    29022701                        {
    29032702                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
    … …  
    29182717               case 8:
    29192718               {
    2920 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2719#ifdef PNG_READ_GAMMA_SUPPORTED
    29212720                  if (gamma_table != NULL)
    29222721                  {
    … …  
    29242723                     for (i = 0; i < row_width; i++, sp++)
    29252724                     {
    2926                         if (*sp == trans_values->gray)
     2725                        if (*sp == trans_color->gray)
    29272726                        {
    29282727                           *sp = (png_byte)background->gray;
    … …  
    29402739                     for (i = 0; i < row_width; i++, sp++)
    29412740                     {
    2942                         if (*sp == trans_values->gray)
     2741                        if (*sp == trans_color->gray)
    29432742                        {
    29442743                           *sp = (png_byte)background->gray;
    … …  
    29512750               case 16:
    29522751               {
    2953 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2752#ifdef PNG_READ_GAMMA_SUPPORTED
    29542753                  if (gamma_16 != NULL)
    29552754                  {
    … …  
    29602759
    29612760                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
    2962                         if (v == trans_values->gray)
     2761                        if (v == trans_color->gray)
    29632762                        {
    29642763                           /* Background is already in screen gamma */
    … …  
    29832782
    29842783                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
    2985                         if (v == trans_values->gray)
     2784                        if (v == trans_color->gray)
    29862785                        {
    29872786                           *sp = (png_byte)((background->gray >> 8) & 0xff);
    … …  
    30002799            if (row_info->bit_depth == 8)
    30012800            {
    3002 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2801#ifdef PNG_READ_GAMMA_SUPPORTED
    30032802               if (gamma_table != NULL)
    30042803               {
    … …  
    30062805                  for (i = 0; i < row_width; i++, sp += 3)
    30072806                  {
    3008                      if (*sp == trans_values->red &&
    3009                         *(sp + 1) == trans_values->green &&
    3010                         *(sp + 2) == trans_values->blue)
     2807                     if (*sp == trans_color->red &&
     2808                        *(sp + 1) == trans_color->green &&
     2809                        *(sp + 2) == trans_color->blue)
    30112810                     {
    30122811                        *sp = (png_byte)background->red;
    … …  
    30282827                  for (i = 0; i < row_width; i++, sp += 3)
    30292828                  {
    3030                      if (*sp == trans_values->red &&
    3031                         *(sp + 1) == trans_values->green &&
    3032                         *(sp + 2) == trans_values->blue)
     2829                     if (*sp == trans_color->red &&
     2830                        *(sp + 1) == trans_color->green &&
     2831                        *(sp + 2) == trans_color->blue)
    30332832                     {
    30342833                        *sp = (png_byte)background->red;
    … …  
    30412840            else /* if (row_info->bit_depth == 16) */
    30422841            {
    3043 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2842#ifdef PNG_READ_GAMMA_SUPPORTED
    30442843               if (gamma_16 != NULL)
    30452844               {
    … …  
    30502849                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
    30512850                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
    3052                      if (r == trans_values->red && g == trans_values->green &&
    3053                         b == trans_values->blue)
     2851                     if (r == trans_color->red && g == trans_color->green &&
     2852                        b == trans_color->blue)
    30542853                     {
    30552854                        /* Background is already in screen gamma */
    … …  
    30852884                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
    30862885
    3087                      if (r == trans_values->red && g == trans_values->green &&
    3088                         b == trans_values->blue)
     2886                     if (r == trans_color->red && g == trans_color->green &&
     2887                        b == trans_color->blue)
    30892888                     {
    30902889                        *sp = (png_byte)((background->red >> 8) & 0xff);
    … …  
    31052904            if (row_info->bit_depth == 8)
    31062905            {
    3107 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2906#ifdef PNG_READ_GAMMA_SUPPORTED
    31082907               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
    31092908                   gamma_table != NULL)
    … …  
    31472946                        *dp = *sp;
    31482947                     }
    3149 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2948#ifdef PNG_READ_GAMMA_SUPPORTED
    31502949                     else if (a == 0)
    31512950                     {
    … …  
    31642963            else /* if (png_ptr->bit_depth == 16) */
    31652964            {
    3166 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2965#ifdef PNG_READ_GAMMA_SUPPORTED
    31672966               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
    31682967                   gamma_16_to_1 != NULL)
    … …  
    31822981                        *(dp + 1) = (png_byte)(v & 0xff);
    31832982                     }
    3184 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2983#ifdef PNG_READ_GAMMA_SUPPORTED
    31852984                     else if (a == 0)
    31862985#else
    … …  
    31922991                        *(dp + 1) = (png_byte)(background->gray & 0xff);
    31932992                     }
    3194 #if defined(PNG_READ_GAMMA_SUPPORTED)
     2993#ifdef PNG_READ_GAMMA_SUPPORTED
    31952994                     else
    31962995                     {
    … …  
    32183017                        png_memcpy(dp, sp, 2);
    32193018                     }
    3220 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3019#ifdef PNG_READ_GAMMA_SUPPORTED
    32213020                     else if (a == 0)
    32223021#else
    … …  
    32273026                        *(dp + 1) = (png_byte)(background->gray & 0xff);
    32283027                     }
    3229 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3028#ifdef PNG_READ_GAMMA_SUPPORTED
    32303029                     else
    32313030                     {
    … …  
    32483047            if (row_info->bit_depth == 8)
    32493048            {
    3250 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3049#ifdef PNG_READ_GAMMA_SUPPORTED
    32513050               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
    32523051                   gamma_table != NULL)
    … …  
    33213120            else /* if (row_info->bit_depth == 16) */
    33223121            {
    3323 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3122#ifdef PNG_READ_GAMMA_SUPPORTED
    33243123               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
    33253124                   gamma_16_to_1 != NULL)
    … …  
    34383237#endif
    34393238
    3440 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3239#ifdef PNG_READ_GAMMA_SUPPORTED
    34413240/* Gamma correct the image, avoiding the alpha channel.  Make sure
    34423241 * you do this after you deal with the transparency issue on grayscale
    … …  
    34553254
    34563255   png_debug(1, "in png_do_gamma");
     3256
    34573257   if (
    3458 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    3459        row != NULL && row_info != NULL &&
    3460 #endif
    34613258       ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
    34623259        (row_info->bit_depth == 16 && gamma_16_table != NULL)))
    … …  
    36293426#endif
    36303427
    3631 #if defined(PNG_READ_EXPAND_SUPPORTED)
     3428#ifdef PNG_READ_EXPAND_SUPPORTED
    36323429/* Expands a palette row to an RGB or RGBA row depending
    36333430 * upon whether you supply trans and num_trans.
    … …  
    36353432void /* PRIVATE */
    36363433png_do_expand_palette(png_row_infop row_info, png_bytep row,
    3637    png_colorp palette, png_bytep trans, int num_trans)
     3434   png_colorp palette, png_bytep trans_alpha, int num_trans)
    36383435{
    36393436   int shift, value;
    … …  
    36433440
    36443441   png_debug(1, "in png_do_expand_palette");
     3442
    36453443   if (
    3646 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    3647        row != NULL && row_info != NULL &&
    3648 #endif
    36493444       row_info->color_type == PNG_COLOR_TYPE_PALETTE)
    36503445   {
    … …  
    37293524         case 8:
    37303525         {
    3731             if (trans != NULL)
     3526            if (trans_alpha != NULL)
    37323527            {
    37333528               sp = row + (png_size_t)row_width - 1;
    … …  
    37393534                     *dp-- = 0xff;
    37403535                  else
    3741                      *dp-- = trans[*sp];
     3536                     *dp-- = trans_alpha[*sp];
    37423537                  *dp-- = palette[*sp].blue;
    37433538                  *dp-- = palette[*sp].green;
    … …  
    37893584
    37903585   png_debug(1, "in png_do_expand");
    3791 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    3792    if (row != NULL && row_info != NULL)
    3793 #endif
     3586
    37943587   {
    37953588      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
    … …  
    39903783#endif
    39913784
    3992 #if defined(PNG_READ_DITHER_SUPPORTED)
     3785#ifdef PNG_READ_DITHER_SUPPORTED
    39933786void /* PRIVATE */
    39943787png_do_dither(png_row_infop row_info, png_bytep row,
    … …  
    40003793
    40013794   png_debug(1, "in png_do_dither");
    4002 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    4003    if (row != NULL && row_info != NULL)
    4004 #endif
     3795
    40053796   {
    40063797      if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
    … …  
    40823873
    40833874#ifdef PNG_FLOATING_POINT_SUPPORTED
    4084 #if defined(PNG_READ_GAMMA_SUPPORTED)
     3875#ifdef PNG_READ_GAMMA_SUPPORTED
    40853876static PNG_CONST int png_gamma_shift[] =
    40863877   {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
    … …  
    40903881 * the future.  Note also how the gamma_16 tables are segmented so that
    40913882 * we don't need to allocate > 64K chunks for a full 16-bit table.
     3883 *
     3884 * See the PNG extensions document for an integer algorithm for creating
     3885 * the gamma tables.  Maybe we will implement that here someday.
     3886 *
     3887 * We should only reach this point if
     3888 *
     3889 *      the file_gamma is known (i.e., the gAMA or sRGB chunk is present,
     3890 *      or the application has provided a file_gamma)
     3891 *
     3892 *   AND
     3893 *      {
     3894 *         the screen_gamma is known
     3895 *
     3896 *      OR
     3897 *
     3898 *         RGB_to_gray transformation is being performed
     3899 *      }
     3900 *
     3901 *   AND
     3902 *      {
     3903 *         the screen_gamma is different from the reciprocal of the
     3904 *         file_gamma by more than the specified threshold
     3905 *
     3906 *      OR
     3907 *
     3908 *         a background color has been specified and the file_gamma
     3909 *         and screen_gamma are not 1.0, within the specified threshold.
     3910 *      }
    40923911 */
     3912
    40933913void /* PRIVATE */
    4094 png_build_gamma_table(png_structp png_ptr)
     3914png_build_gamma_table(png_structp png_ptr, png_byte bit_depth)
    40953915{
    40963916  png_debug(1, "in png_build_gamma_table");
    40973917
    4098   if (png_ptr->bit_depth <= 8)
     3918  if (bit_depth <= 8)
    40993919  {
    41003920     int i;
    … …  
    42004020        g = 1.0;
    42014021
    4202      png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
     4022     png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,
    42034023        (png_uint_32)(num * png_sizeof(png_uint_16p)));
    4204      png_memset(png_ptr->gamma_16_table, 0, num * png_sizeof(png_uint_16p));
    42054024
    42064025     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
    … …  
    42624081        g = 1.0 / (png_ptr->gamma);
    42634082
    4264         png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
     4083        png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,
    42654084           (png_uint_32)(num * png_sizeof(png_uint_16p )));
    4266         png_memset(png_ptr->gamma_16_to_1, 0, num * png_sizeof(png_uint_16p));
    42674085
    42684086        for (i = 0; i < num; i++)
    … …  
    42874105           g = png_ptr->gamma;   /* Probably doing rgb_to_gray */
    42884106
    4289         png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
     4107        png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,
    42904108           (png_uint_32)(num * png_sizeof(png_uint_16p)));
    4291         png_memset(png_ptr->gamma_16_from_1, 0,
    4292            num * png_sizeof(png_uint_16p));
    42934109
    42944110        for (i = 0; i < num; i++)
    … …  
    43154131#endif
    43164132
    4317 #if defined(PNG_MNG_FEATURES_SUPPORTED)
     4133#ifdef PNG_MNG_FEATURES_SUPPORTED
    43184134/* Undoes intrapixel differencing  */
    43194135void /* PRIVATE */
    … …  
    43214137{
    43224138   png_debug(1, "in png_do_read_intrapixel");
     4139
    43234140   if (
    4324 #if defined(PNG_USELESS_TESTS_SUPPORTED)
    4325        row != NULL && row_info != NULL &&
    4326 #endif
    43274141       (row_info->color_type & PNG_COLOR_MASK_COLOR))
    43284142   {
Note: See TracChangeset for help on using the changeset viewer.