syslinux/com32/lib/libpng/pngrtran.c

   1
   2 /* pngrtran.c - transforms the data in a row for PNG readers
   3  *
   4  * libpng version  1.2.8 - December 3, 2004
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
   7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   9  *
  10  * This file contains functions optionally called by an application
  11  * in order to tell libpng how to handle data when reading a PNG.
  12  * Transformations that are used in both reading and writing are
  13  * in pngtrans.c.
  14  */
  15
  16 #define PNG_INTERNAL
  17 #include "png.h"
  18
  19 /* Set the action on getting a CRC error for an ancillary or critical chunk. */
  20 void PNGAPI
  21 png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
  22 {
  23    png_debug(1, "in png_set_crc_action\n");
  24    /* Tell libpng how we react to CRC errors in critical chunks */
  25    switch (crit_action)
  26    {
  27       case PNG_CRC_NO_CHANGE:                        /* leave setting as is */
  28          break;
  29       case PNG_CRC_WARN_USE:                               /* warn/use data */
  30          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  31          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
  32          break;
  33       case PNG_CRC_QUIET_USE:                             /* quiet/use data */
  34          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  35          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
  36                            PNG_FLAG_CRC_CRITICAL_IGNORE;
  37          break;
  38       case PNG_CRC_WARN_DISCARD:    /* not a valid action for critical data */
  39          png_warning(png_ptr, "Can't discard critical data on CRC error.");
  40       case PNG_CRC_ERROR_QUIT:                                /* error/quit */
  41       case PNG_CRC_DEFAULT:
  42       default:
  43          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
  44          break;
  45    }
  46
  47    switch (ancil_action)
  48    {
  49       case PNG_CRC_NO_CHANGE:                       /* leave setting as is */
  50          break;
  51       case PNG_CRC_WARN_USE:                              /* warn/use data */
  52          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  53          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
  54          break;
  55       case PNG_CRC_QUIET_USE:                            /* quiet/use data */
  56          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  57          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
  58                            PNG_FLAG_CRC_ANCILLARY_NOWARN;
  59          break;
  60       case PNG_CRC_ERROR_QUIT:                               /* error/quit */
  61          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  62          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
  63          break;
  64       case PNG_CRC_WARN_DISCARD:                      /* warn/discard data */
  65       case PNG_CRC_DEFAULT:
  66       default:
  67          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
  68          break;
  69    }
  70 }
  71
  72 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
  73     defined(PNG_FLOATING_POINT_SUPPORTED)
  74 /* handle alpha and tRNS via a background color */
  75 void PNGAPI
  76 png_set_background(png_structp png_ptr,
  77    png_color_16p background_color, int background_gamma_code,
  78    int need_expand, double background_gamma)
  79 {
  80    png_debug(1, "in png_set_background\n");
  81    if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
  82    {
  83       png_warning(png_ptr, "Application must supply a known background gamma");
  84       return;
  85    }
  86
  87    png_ptr->transformations |= PNG_BACKGROUND;
  88    png_memcpy(&(png_ptr->background), background_color,
  89       png_sizeof(png_color_16));
  90    png_ptr->background_gamma = (float)background_gamma;
  91    png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
  92    png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
  93
  94    /* Note:  if need_expand is set and color_type is either RGB or RGB_ALPHA
  95     * (in which case need_expand is superfluous anyway), the background color
  96     * might actually be gray yet not be flagged as such. This is not a problem
  97     * for the current code, which uses PNG_BACKGROUND_IS_GRAY only to
  98     * decide when to do the png_do_gray_to_rgb() transformation.
  99     */
 100    if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) ||
 101        (!need_expand && background_color->red == background_color->green &&
 102         background_color->red == background_color->blue))
 103       png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
 104 }
 105 #endif
 106
 107 #if defined(PNG_READ_16_TO_8_SUPPORTED)
 108 /* strip 16 bit depth files to 8 bit depth */
 109 void PNGAPI
 110 png_set_strip_16(png_structp png_ptr)
 111 {
 112    png_debug(1, "in png_set_strip_16\n");
 113    png_ptr->transformations |= PNG_16_TO_8;
 114 }
 115 #endif
 116
 117 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 118 void PNGAPI
 119 png_set_strip_alpha(png_structp png_ptr)
 120 {
 121    png_debug(1, "in png_set_strip_alpha\n");
 122    png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
 123 }
 124 #endif
 125
 126 #if defined(PNG_READ_DITHER_SUPPORTED)
 127 /* Dither file to 8 bit.  Supply a palette, the current number
 128  * of elements in the palette, the maximum number of elements
 129  * allowed, and a histogram if possible.  If the current number
 130  * of colors is greater then the maximum number, the palette will be
 131  * modified to fit in the maximum number.  "full_dither" indicates
 132  * whether we need a dithering cube set up for RGB images, or if we
 133  * simply are reducing the number of colors in a paletted image.
 134  */
 135
 136 typedef struct png_dsort_struct
 137 {
 138    struct png_dsort_struct FAR * next;
 139    png_byte left;
 140    png_byte right;
 141 } png_dsort;
 142 typedef png_dsort FAR *       png_dsortp;
 143 typedef png_dsort FAR * FAR * png_dsortpp;
 144
 145 void PNGAPI
 146 png_set_dither(png_structp png_ptr, png_colorp palette,
 147    int num_palette, int maximum_colors, png_uint_16p histogram,
 148    int full_dither)
 149 {
 150    png_debug(1, "in png_set_dither\n");
 151    png_ptr->transformations |= PNG_DITHER;
 152
 153    if (!full_dither)
 154    {
 155       int i;
 156
 157       png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
 158          (png_uint_32)(num_palette * png_sizeof (png_byte)));
 159       for (i = 0; i < num_palette; i++)
 160          png_ptr->dither_index[i] = (png_byte)i;
 161    }
 162
 163    if (num_palette > maximum_colors)
 164    {
 165       if (histogram != NULL)
 166       {
 167          /* This is easy enough, just throw out the least used colors.
 168             Perhaps not the best solution, but good enough. */
 169
 170          int i;
 171
 172          /* initialize an array to sort colors */
 173          png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
 174             (png_uint_32)(num_palette * png_sizeof (png_byte)));
 175
 176          /* initialize the dither_sort array */
 177          for (i = 0; i < num_palette; i++)
 178             png_ptr->dither_sort[i] = (png_byte)i;
 179
 180          /* Find the least used palette entries by starting a
 181             bubble sort, and running it until we have sorted
 182             out enough colors.  Note that we don't care about
 183             sorting all the colors, just finding which are
 184             least used. */
 185
 186          for (i = num_palette - 1; i >= maximum_colors; i--)
 187          {
 188             int done; /* to stop early if the list is pre-sorted */
 189             int j;
 190
 191             done = 1;
 192             for (j = 0; j < i; j++)
 193             {
 194                if (histogram[png_ptr->dither_sort[j]]
 195                    < histogram[png_ptr->dither_sort[j + 1]])
 196                {
 197                   png_byte t;
 198
 199                   t = png_ptr->dither_sort[j];
 200                   png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
 201                   png_ptr->dither_sort[j + 1] = t;
 202                   done = 0;
 203                }
 204             }
 205             if (done)
 206                break;
 207          }
 208
 209          /* swap the palette around, and set up a table, if necessary */
 210          if (full_dither)
 211          {
 212             int j = num_palette;
 213
 214             /* put all the useful colors within the max, but don't
 215                move the others */
 216             for (i = 0; i < maximum_colors; i++)
 217             {
 218                if ((int)png_ptr->dither_sort[i] >= maximum_colors)
 219                {
 220                   do
 221                      j--;
 222                   while ((int)png_ptr->dither_sort[j] >= maximum_colors);
 223                   palette[i] = palette[j];
 224                }
 225             }
 226          }
 227          else
 228          {
 229             int j = num_palette;
 230
 231             /* move all the used colors inside the max limit, and
 232                develop a translation table */
 233             for (i = 0; i < maximum_colors; i++)
 234             {
 235                /* only move the colors we need to */
 236                if ((int)png_ptr->dither_sort[i] >= maximum_colors)
 237                {
 238                   png_color tmp_color;
 239
 240                   do
 241                      j--;
 242                   while ((int)png_ptr->dither_sort[j] >= maximum_colors);
 243
 244                   tmp_color = palette[j];
 245                   palette[j] = palette[i];
 246                   palette[i] = tmp_color;
 247                   /* indicate where the color went */
 248                   png_ptr->dither_index[j] = (png_byte)i;
 249                   png_ptr->dither_index[i] = (png_byte)j;
 250                }
 251             }
 252
 253             /* find closest color for those colors we are not using */
 254             for (i = 0; i < num_palette; i++)
 255             {
 256                if ((int)png_ptr->dither_index[i] >= maximum_colors)
 257                {
 258                   int min_d, k, min_k, d_index;
 259
 260                   /* find the closest color to one we threw out */
 261                   d_index = png_ptr->dither_index[i];
 262                   min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
 263                   for (k = 1, min_k = 0; k < maximum_colors; k++)
 264                   {
 265                      int d;
 266
 267                      d = PNG_COLOR_DIST(palette[d_index], palette[k]);
 268
 269                      if (d < min_d)
 270                      {
 271                         min_d = d;
 272                         min_k = k;
 273                      }
 274                   }
 275                   /* point to closest color */
 276                   png_ptr->dither_index[i] = (png_byte)min_k;
 277                }
 278             }
 279          }
 280          png_free(png_ptr, png_ptr->dither_sort);
 281          png_ptr->dither_sort=NULL;
 282       }
 283       else
 284       {
 285          /* This is much harder to do simply (and quickly).  Perhaps
 286             we need to go through a median cut routine, but those
 287             don't always behave themselves with only a few colors
 288             as input.  So we will just find the closest two colors,
 289             and throw out one of them (chosen somewhat randomly).
 290             [We don't understand this at all, so if someone wants to
 291              work on improving it, be our guest - AED, GRP]
 292             */
 293          int i;
 294          int max_d;
 295          int num_new_palette;
 296          png_dsortp t;
 297          png_dsortpp hash;
 298
 299          t=NULL;
 300
 301          /* initialize palette index arrays */
 302          png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
 303             (png_uint_32)(num_palette * png_sizeof (png_byte)));
 304          png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
 305             (png_uint_32)(num_palette * png_sizeof (png_byte)));
 306
 307          /* initialize the sort array */
 308          for (i = 0; i < num_palette; i++)
 309          {
 310             png_ptr->index_to_palette[i] = (png_byte)i;
 311             png_ptr->palette_to_index[i] = (png_byte)i;
 312          }
 313
 314          hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
 315             png_sizeof (png_dsortp)));
 316          for (i = 0; i < 769; i++)
 317             hash[i] = NULL;
 318 /*         png_memset(hash, 0, 769 * png_sizeof (png_dsortp)); */
 319
 320          num_new_palette = num_palette;
 321
 322          /* initial wild guess at how far apart the farthest pixel
 323             pair we will be eliminating will be.  Larger
 324             numbers mean more areas will be allocated, Smaller
 325             numbers run the risk of not saving enough data, and
 326             having to do this all over again.
 327
 328             I have not done extensive checking on this number.
 329             */
 330          max_d = 96;
 331
 332          while (num_new_palette > maximum_colors)
 333          {
 334             for (i = 0; i < num_new_palette - 1; i++)
 335             {
 336                int j;
 337
 338                for (j = i + 1; j < num_new_palette; j++)
 339                {
 340                   int d;
 341
 342                   d = PNG_COLOR_DIST(palette[i], palette[j]);
 343
 344                   if (d <= max_d)
 345                   {
 346
 347                      t = (png_dsortp)png_malloc_warn(png_ptr,
 348                          (png_uint_32)(png_sizeof(png_dsort)));
 349                      if (t == NULL)
 350                          break;
 351                      t->next = hash[d];
 352                      t->left = (png_byte)i;
 353                      t->right = (png_byte)j;
 354                      hash[d] = t;
 355                   }
 356                }
 357                if (t == NULL)
 358                   break;
 359             }
 360
 361             if (t != NULL)
 362             for (i = 0; i <= max_d; i++)
 363             {
 364                if (hash[i] != NULL)
 365                {
 366                   png_dsortp p;
 367
 368                   for (p = hash[i]; p; p = p->next)
 369                   {
 370                      if ((int)png_ptr->index_to_palette[p->left]
 371                         < num_new_palette &&
 372                         (int)png_ptr->index_to_palette[p->right]
 373                         < num_new_palette)
 374                      {
 375                         int j, next_j;
 376
 377                         if (num_new_palette & 0x01)
 378                         {
 379                            j = p->left;
 380                            next_j = p->right;
 381                         }
 382                         else
 383                         {
 384                            j = p->right;
 385                            next_j = p->left;
 386                         }
 387
 388                         num_new_palette--;
 389                         palette[png_ptr->index_to_palette[j]]
 390                           = palette[num_new_palette];
 391                         if (!full_dither)
 392                         {
 393                            int k;
 394
 395                            for (k = 0; k < num_palette; k++)
 396                            {
 397                               if (png_ptr->dither_index[k] ==
 398                                  png_ptr->index_to_palette[j])
 399                                  png_ptr->dither_index[k] =
 400                                     png_ptr->index_to_palette[next_j];
 401                               if ((int)png_ptr->dither_index[k] ==
 402                                  num_new_palette)
 403                                  png_ptr->dither_index[k] =
 404                                     png_ptr->index_to_palette[j];
 405                            }
 406                         }
 407
 408                         png_ptr->index_to_palette[png_ptr->palette_to_index
 409                            [num_new_palette]] = png_ptr->index_to_palette[j];
 410                         png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
 411                            = png_ptr->palette_to_index[num_new_palette];
 412
 413                         png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
 414                         png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
 415                      }
 416                      if (num_new_palette <= maximum_colors)
 417                         break;
 418                   }
 419                   if (num_new_palette <= maximum_colors)
 420                      break;
 421                }
 422             }
 423
 424             for (i = 0; i < 769; i++)
 425             {
 426                if (hash[i] != NULL)
 427                {
 428                   png_dsortp p = hash[i];
 429                   while (p)
 430                   {
 431                      t = p->next;
 432                      png_free(png_ptr, p);
 433                      p = t;
 434                   }
 435                }
 436                hash[i] = 0;
 437             }
 438             max_d += 96;
 439          }
 440          png_free(png_ptr, hash);
 441          png_free(png_ptr, png_ptr->palette_to_index);
 442          png_free(png_ptr, png_ptr->index_to_palette);
 443          png_ptr->palette_to_index=NULL;
 444          png_ptr->index_to_palette=NULL;
 445       }
 446       num_palette = maximum_colors;
 447    }
 448    if (png_ptr->palette == NULL)
 449    {
 450       png_ptr->palette = palette;
 451    }
 452    png_ptr->num_palette = (png_uint_16)num_palette;
 453
 454    if (full_dither)
 455    {
 456       int i;
 457       png_bytep distance;
 458       int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
 459          PNG_DITHER_BLUE_BITS;
 460       int num_red = (1 << PNG_DITHER_RED_BITS);
 461       int num_green = (1 << PNG_DITHER_GREEN_BITS);
 462       int num_blue = (1 << PNG_DITHER_BLUE_BITS);
 463       png_size_t num_entries = ((png_size_t)1 << total_bits);
 464
 465       png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
 466          (png_uint_32)(num_entries * png_sizeof (png_byte)));
 467
 468       png_memset(png_ptr->palette_lookup, 0, num_entries *
 469          png_sizeof (png_byte));
 470
 471       distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
 472          png_sizeof(png_byte)));
 473
 474       png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
 475
 476       for (i = 0; i < num_palette; i++)
 477       {
 478          int ir, ig, ib;
 479          int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
 480          int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
 481          int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
 482
 483          for (ir = 0; ir < num_red; ir++)
 484          {
 485             /* int dr = abs(ir - r); */
 486             int dr = ((ir > r) ? ir - r : r - ir);
 487             int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
 488
 489             for (ig = 0; ig < num_green; ig++)
 490             {
 491                /* int dg = abs(ig - g); */
 492                int dg = ((ig > g) ? ig - g : g - ig);
 493                int dt = dr + dg;
 494                int dm = ((dr > dg) ? dr : dg);
 495                int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
 496
 497                for (ib = 0; ib < num_blue; ib++)
 498                {
 499                   int d_index = index_g | ib;
 500                   /* int db = abs(ib - b); */
 501                   int db = ((ib > b) ? ib - b : b - ib);
 502                   int dmax = ((dm > db) ? dm : db);
 503                   int d = dmax + dt + db;
 504
 505                   if (d < (int)distance[d_index])
 506                   {
 507                      distance[d_index] = (png_byte)d;
 508                      png_ptr->palette_lookup[d_index] = (png_byte)i;
 509                   }
 510                }
 511             }
 512          }
 513       }
 514
 515       png_free(png_ptr, distance);
 516    }
 517 }
 518 #endif
 519
 520 #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
 521 /* Transform the image from the file_gamma to the screen_gamma.  We
 522  * only do transformations on images where the file_gamma and screen_gamma
 523  * are not close reciprocals, otherwise it slows things down slightly, and
 524  * also needlessly introduces small errors.
 525  *
 526  * We will turn off gamma transformation later if no semitransparent entries
 527  * are present in the tRNS array for palette images.  We can't do it here
 528  * because we don't necessarily have the tRNS chunk yet.
 529  */
 530 void PNGAPI
 531 png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
 532 {
 533    png_debug(1, "in png_set_gamma\n");
 534    if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
 535        (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
 536        (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
 537      png_ptr->transformations |= PNG_GAMMA;
 538    png_ptr->gamma = (float)file_gamma;
 539    png_ptr->screen_gamma = (float)scrn_gamma;
 540 }
 541 #endif
 542
 543 #if defined(PNG_READ_EXPAND_SUPPORTED)
 544 /* Expand paletted images to RGB, expand grayscale images of
 545  * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
 546  * to alpha channels.
 547  */
 548 void PNGAPI
 549 png_set_expand(png_structp png_ptr)
 550 {
 551    png_debug(1, "in png_set_expand\n");
 552    png_ptr->transformations |= PNG_EXPAND;
 553 }
 554
 555 /* GRR 19990627:  the following three functions currently are identical
 556  *  to png_set_expand().  However, it is entirely reasonable that someone
 557  *  might wish to expand an indexed image to RGB but *not* expand a single,
 558  *  fully transparent palette entry to a full alpha channel--perhaps instead
 559  *  convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
 560  *  the transparent color with a particular RGB value, or drop tRNS entirely.
 561  *  IOW, a future version of the library may make the transformations flag
 562  *  a bit more fine-grained, with separate bits for each of these three
 563  *  functions.
 564  *
 565  *  More to the point, these functions make it obvious what libpng will be
 566  *  doing, whereas "expand" can (and does) mean any number of things.
 567  */
 568
 569 /* Expand paletted images to RGB. */
 570 void PNGAPI
 571 png_set_palette_to_rgb(png_structp png_ptr)
 572 {
 573    png_debug(1, "in png_set_expand\n");
 574    png_ptr->transformations |= PNG_EXPAND;
 575 }
 576
 577 /* Expand grayscale images of less than 8-bit depth to 8 bits. */
 578 void PNGAPI
 579 png_set_gray_1_2_4_to_8(png_structp png_ptr)
 580 {
 581    png_debug(1, "in png_set_expand\n");
 582    png_ptr->transformations |= PNG_EXPAND;
 583 }
 584
 585 /* Expand tRNS chunks to alpha channels. */
 586 void PNGAPI
 587 png_set_tRNS_to_alpha(png_structp png_ptr)
 588 {
 589    png_debug(1, "in png_set_expand\n");
 590    png_ptr->transformations |= PNG_EXPAND;
 591 }
 592 #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
 593
 594 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
 595 void PNGAPI
 596 png_set_gray_to_rgb(png_structp png_ptr)
 597 {
 598    png_debug(1, "in png_set_gray_to_rgb\n");
 599    png_ptr->transformations |= PNG_GRAY_TO_RGB;
 600 }
 601 #endif
 602
 603 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
 604 #if defined(PNG_FLOATING_POINT_SUPPORTED)
 605 /* Convert a RGB image to a grayscale of the same width.  This allows us,
 606  * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
 607  */
 608
 609 void PNGAPI
 610 png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
 611    double green)
 612 {
 613       int red_fixed = (int)((float)red*100000.0 + 0.5);
 614       int green_fixed = (int)((float)green*100000.0 + 0.5);
 615       png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
 616 }
 617 #endif
 618
 619 void PNGAPI
 620 png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
 621    png_fixed_point red, png_fixed_point green)
 622 {
 623    png_debug(1, "in png_set_rgb_to_gray\n");
 624    switch(error_action)
 625    {
 626       case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
 627               break;
 628       case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
 629               break;
 630       case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
 631    }
 632    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 633 #if defined(PNG_READ_EXPAND_SUPPORTED)
 634       png_ptr->transformations |= PNG_EXPAND;
 635 #else
 636    {
 637       png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
 638       png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
 639    }
 640 #endif
 641    {
 642       png_uint_16 red_int, green_int;
 643       if(red < 0 || green < 0)
 644       {
 645          red_int   =  6968; /* .212671 * 32768 + .5 */
 646          green_int = 23434; /* .715160 * 32768 + .5 */
 647       }
 648       else if(red + green < 100000L)
 649       {
 650         red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
 651         green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
 652       }
 653       else
 654       {
 655          png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
 656          red_int   =  6968;
 657          green_int = 23434;
 658       }
 659       png_ptr->rgb_to_gray_red_coeff   = red_int;
 660       png_ptr->rgb_to_gray_green_coeff = green_int;
 661       png_ptr->rgb_to_gray_blue_coeff  = (png_uint_16)(32768-red_int-green_int);
 662    }
 663 }
 664 #endif
 665
 666 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
 667     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
 668     defined(PNG_LEGACY_SUPPORTED)
 669 void PNGAPI
 670 png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
 671    read_user_transform_fn)
 672 {
 673    png_debug(1, "in png_set_read_user_transform_fn\n");
 674 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 675    png_ptr->transformations |= PNG_USER_TRANSFORM;
 676    png_ptr->read_user_transform_fn = read_user_transform_fn;
 677 #endif
 678 #ifdef PNG_LEGACY_SUPPORTED
 679    if(read_user_transform_fn)
 680       png_warning(png_ptr,
 681         "This version of libpng does not support user transforms");
 682 #endif
 683 }
 684 #endif
 685
 686 /* Initialize everything needed for the read.  This includes modifying
 687  * the palette.
 688  */
 689 void /* PRIVATE */
 690 png_init_read_transformations(png_structp png_ptr)
 691 {
 692    png_debug(1, "in png_init_read_transformations\n");
 693 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 694    if(png_ptr != NULL)
 695 #endif
 696   {
 697 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
 698  || defined(PNG_READ_GAMMA_SUPPORTED)
 699    int color_type = png_ptr->color_type;
 700 #endif
 701
 702 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
 703    if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
 704        (png_ptr->transformations & PNG_EXPAND))
 705    {
 706       if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */
 707       {
 708          /* expand background chunk. */
 709          switch (png_ptr->bit_depth)
 710          {
 711             case 1:
 712                png_ptr->background.gray *= (png_uint_16)0xff;
 713                png_ptr->background.red = png_ptr->background.green
 714                  =  png_ptr->background.blue = png_ptr->background.gray;
 715                break;
 716             case 2:
 717                png_ptr->background.gray *= (png_uint_16)0x55;
 718                png_ptr->background.red = png_ptr->background.green
 719                  = png_ptr->background.blue = png_ptr->background.gray;
 720                break;
 721             case 4:
 722                png_ptr->background.gray *= (png_uint_16)0x11;
 723                png_ptr->background.red = png_ptr->background.green
 724                  = png_ptr->background.blue = png_ptr->background.gray;
 725                break;
 726             case 8:
 727             case 16:
 728                png_ptr->background.red = png_ptr->background.green
 729                  = png_ptr->background.blue = png_ptr->background.gray;
 730                break;
 731          }
 732       }
 733       else if (color_type == PNG_COLOR_TYPE_PALETTE)
 734       {
 735          png_ptr->background.red   =
 736             png_ptr->palette[png_ptr->background.index].red;
 737          png_ptr->background.green =
 738             png_ptr->palette[png_ptr->background.index].green;
 739          png_ptr->background.blue  =
 740             png_ptr->palette[png_ptr->background.index].blue;
 741
 742 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
 743         if (png_ptr->transformations & PNG_INVERT_ALPHA)
 744         {
 745 #if defined(PNG_READ_EXPAND_SUPPORTED)
 746            if (!(png_ptr->transformations & PNG_EXPAND))
 747 #endif
 748            {
 749            /* invert the alpha channel (in tRNS) unless the pixels are
 750               going to be expanded, in which case leave it for later */
 751               int i,istop;
 752               istop=(int)png_ptr->num_trans;
 753               for (i=0; i<istop; i++)
 754                  png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
 755            }
 756         }
 757 #endif
 758
 759       }
 760    }
 761 #endif
 762
 763 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
 764    png_ptr->background_1 = png_ptr->background;
 765 #endif
 766 #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
 767
 768    if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
 769        && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
 770          < PNG_GAMMA_THRESHOLD))
 771    {
 772     int i,k;
 773     k=0;
 774     for (i=0; i<png_ptr->num_trans; i++)
 775     {
 776       if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
 777         k=1; /* partial transparency is present */
 778     }
 779     if (k == 0)
 780       png_ptr->transformations &= (~PNG_GAMMA);
 781    }
 782
 783    if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY))
 784    {
 785       png_build_gamma_table(png_ptr);
 786 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
 787       if (png_ptr->transformations & PNG_BACKGROUND)
 788       {
 789          if (color_type == PNG_COLOR_TYPE_PALETTE)
 790          {
 791            /* could skip if no transparency and
 792            */
 793             png_color back, back_1;
 794             png_colorp palette = png_ptr->palette;
 795             int num_palette = png_ptr->num_palette;
 796             int i;
 797             if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
 798             {
 799                back.red = png_ptr->gamma_table[png_ptr->background.red];
 800                back.green = png_ptr->gamma_table[png_ptr->background.green];
 801                back.blue = png_ptr->gamma_table[png_ptr->background.blue];
 802
 803                back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
 804                back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
 805                back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
 806             }
 807             else
 808             {
 809                double g, gs;
 810
 811                switch (png_ptr->background_gamma_type)
 812                {
 813                   case PNG_BACKGROUND_GAMMA_SCREEN:
 814                      g = (png_ptr->screen_gamma);
 815                      gs = 1.0;
 816                      break;
 817                   case PNG_BACKGROUND_GAMMA_FILE:
 818                      g = 1.0 / (png_ptr->gamma);
 819                      gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
 820                      break;
 821                   case PNG_BACKGROUND_GAMMA_UNIQUE:
 822                      g = 1.0 / (png_ptr->background_gamma);
 823                      gs = 1.0 / (png_ptr->background_gamma *
 824                                  png_ptr->screen_gamma);
 825                      break;
 826                   default:
 827                      g = 1.0;    /* back_1 */
 828                      gs = 1.0;   /* back */
 829                }
 830
 831                if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
 832                {
 833                   back.red   = (png_byte)png_ptr->background.red;
 834                   back.green = (png_byte)png_ptr->background.green;
 835                   back.blue  = (png_byte)png_ptr->background.blue;
 836                }
 837                else
 838                {
 839                   back.red = (png_byte)(pow(
 840                      (double)png_ptr->background.red/255, gs) * 255.0 + .5);
 841                   back.green = (png_byte)(pow(
 842                      (double)png_ptr->background.green/255, gs) * 255.0 + .5);
 843                   back.blue = (png_byte)(pow(
 844                      (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
 845                }
 846
 847                back_1.red = (png_byte)(pow(
 848                   (double)png_ptr->background.red/255, g) * 255.0 + .5);
 849                back_1.green = (png_byte)(pow(
 850                   (double)png_ptr->background.green/255, g) * 255.0 + .5);
 851                back_1.blue = (png_byte)(pow(
 852                   (double)png_ptr->background.blue/255, g) * 255.0 + .5);
 853             }
 854             for (i = 0; i < num_palette; i++)
 855             {
 856                if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
 857                {
 858                   if (png_ptr->trans[i] == 0)
 859                   {
 860                      palette[i] = back;
 861                   }
 862                   else /* if (png_ptr->trans[i] != 0xff) */
 863                   {
 864                      png_byte v, w;
 865
 866                      v = png_ptr->gamma_to_1[palette[i].red];
 867                      png_composite(w, v, png_ptr->trans[i], back_1.red);
 868                      palette[i].red = png_ptr->gamma_from_1[w];
 869
 870                      v = png_ptr->gamma_to_1[palette[i].green];
 871                      png_composite(w, v, png_ptr->trans[i], back_1.green);
 872                      palette[i].green = png_ptr->gamma_from_1[w];
 873
 874                      v = png_ptr->gamma_to_1[palette[i].blue];
 875                      png_composite(w, v, png_ptr->trans[i], back_1.blue);
 876                      palette[i].blue = png_ptr->gamma_from_1[w];
 877                   }
 878                }
 879                else
 880                {
 881                   palette[i].red = png_ptr->gamma_table[palette[i].red];
 882                   palette[i].green = png_ptr->gamma_table[palette[i].green];
 883                   palette[i].blue = png_ptr->gamma_table[palette[i].blue];
 884                }
 885             }
 886          }
 887          /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
 888          else
 889          /* color_type != PNG_COLOR_TYPE_PALETTE */
 890          {
 891             double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
 892             double g = 1.0;
 893             double gs = 1.0;
 894
 895             switch (png_ptr->background_gamma_type)
 896             {
 897                case PNG_BACKGROUND_GAMMA_SCREEN:
 898                   g = (png_ptr->screen_gamma);
 899                   gs = 1.0;
 900                   break;
 901                case PNG_BACKGROUND_GAMMA_FILE:
 902                   g = 1.0 / (png_ptr->gamma);
 903                   gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
 904                   break;
 905                case PNG_BACKGROUND_GAMMA_UNIQUE:
 906                   g = 1.0 / (png_ptr->background_gamma);
 907                   gs = 1.0 / (png_ptr->background_gamma *
 908                      png_ptr->screen_gamma);
 909                   break;
 910             }
 911
 912             png_ptr->background_1.gray = (png_uint_16)(pow(
 913                (double)png_ptr->background.gray / m, g) * m + .5);
 914             png_ptr->background.gray = (png_uint_16)(pow(
 915                (double)png_ptr->background.gray / m, gs) * m + .5);
 916
 917             if ((png_ptr->background.red != png_ptr->background.green) ||
 918                 (png_ptr->background.red != png_ptr->background.blue) ||
 919                 (png_ptr->background.red != png_ptr->background.gray))
 920             {
 921                /* RGB or RGBA with color background */
 922                png_ptr->background_1.red = (png_uint_16)(pow(
 923                   (double)png_ptr->background.red / m, g) * m + .5);
 924                png_ptr->background_1.green = (png_uint_16)(pow(
 925                   (double)png_ptr->background.green / m, g) * m + .5);
 926                png_ptr->background_1.blue = (png_uint_16)(pow(
 927                   (double)png_ptr->background.blue / m, g) * m + .5);
 928                png_ptr->background.red = (png_uint_16)(pow(
 929                   (double)png_ptr->background.red / m, gs) * m + .5);
 930                png_ptr->background.green = (png_uint_16)(pow(
 931                   (double)png_ptr->background.green / m, gs) * m + .5);
 932                png_ptr->background.blue = (png_uint_16)(pow(
 933                   (double)png_ptr->background.blue / m, gs) * m + .5);
 934             }
 935             else
 936             {
 937                /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
 938                png_ptr->background_1.red = png_ptr->background_1.green
 939                  = png_ptr->background_1.blue = png_ptr->background_1.gray;
 940                png_ptr->background.red = png_ptr->background.green
 941                  = png_ptr->background.blue = png_ptr->background.gray;
 942             }
 943          }
 944       }
 945       else
 946       /* transformation does not include PNG_BACKGROUND */
 947 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
 948       if (color_type == PNG_COLOR_TYPE_PALETTE)
 949       {
 950          png_colorp palette = png_ptr->palette;
 951          int num_palette = png_ptr->num_palette;
 952          int i;
 953
 954          for (i = 0; i < num_palette; i++)
 955          {
 956             palette[i].red = png_ptr->gamma_table[palette[i].red];
 957             palette[i].green = png_ptr->gamma_table[palette[i].green];
 958             palette[i].blue = png_ptr->gamma_table[palette[i].blue];
 959          }
 960       }
 961    }
 962 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
 963    else
 964 #endif
 965 #endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
 966 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
 967    /* No GAMMA transformation */
 968    if ((png_ptr->transformations & PNG_BACKGROUND) &&
 969        (color_type == PNG_COLOR_TYPE_PALETTE))
 970    {
 971       int i;
 972       int istop = (int)png_ptr->num_trans;
 973       png_color back;
 974       png_colorp palette = png_ptr->palette;
 975
 976       back.red   = (png_byte)png_ptr->background.red;
 977       back.green = (png_byte)png_ptr->background.green;
 978       back.blue  = (png_byte)png_ptr->background.blue;
 979
 980       for (i = 0; i < istop; i++)
 981       {
 982          if (png_ptr->trans[i] == 0)
 983          {
 984             palette[i] = back;
 985          }
 986          else if (png_ptr->trans[i] != 0xff)
 987          {
 988             /* The png_composite() macro is defined in png.h */
 989             png_composite(palette[i].red, palette[i].red,
 990                png_ptr->trans[i], back.red);
 991             png_composite(palette[i].green, palette[i].green,
 992                png_ptr->trans[i], back.green);
 993             png_composite(palette[i].blue, palette[i].blue,
 994                png_ptr->trans[i], back.blue);
 995          }
 996       }
 997    }
 998 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
 999
1000 #if defined(PNG_READ_SHIFT_SUPPORTED)
1001    if ((png_ptr->transformations & PNG_SHIFT) &&
1002       (color_type == PNG_COLOR_TYPE_PALETTE))
1003    {
1004       png_uint_16 i;
1005       png_uint_16 istop = png_ptr->num_palette;
1006       int sr = 8 - png_ptr->sig_bit.red;
1007       int sg = 8 - png_ptr->sig_bit.green;
1008       int sb = 8 - png_ptr->sig_bit.blue;
1009
1010       if (sr < 0 || sr > 8)
1011          sr = 0;
1012       if (sg < 0 || sg > 8)
1013          sg = 0;
1014       if (sb < 0 || sb > 8)
1015          sb = 0;
1016       for (i = 0; i < istop; i++)
1017       {
1018          png_ptr->palette[i].red >>= sr;
1019          png_ptr->palette[i].green >>= sg;
1020          png_ptr->palette[i].blue >>= sb;
1021       }
1022    }
1023 #endif  /* PNG_READ_SHIFT_SUPPORTED */
1024  }
1025 #if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
1026  && !defined(PNG_READ_BACKGROUND_SUPPORTED)
1027    if(png_ptr)
1028       return;
1029 #endif
1030 }
1031
1032 /* Modify the info structure to reflect the transformations.  The
1033  * info should be updated so a PNG file could be written with it,
1034  * assuming the transformations result in valid PNG data.
1035  */
1036 void /* PRIVATE */
1037 png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
1038 {
1039    png_debug(1, "in png_read_transform_info\n");
1040 #if defined(PNG_READ_EXPAND_SUPPORTED)
1041    if (png_ptr->transformations & PNG_EXPAND)
1042    {
1043       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1044       {
1045          if (png_ptr->num_trans)
1046             info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
1047          else
1048             info_ptr->color_type = PNG_COLOR_TYPE_RGB;
1049          info_ptr->bit_depth = 8;
1050          info_ptr->num_trans = 0;
1051       }
1052       else
1053       {
1054          if (png_ptr->num_trans)
1055             info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
1056          if (info_ptr->bit_depth < 8)
1057             info_ptr->bit_depth = 8;
1058          info_ptr->num_trans = 0;
1059       }
1060    }
1061 #endif
1062
1063 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
1064    if (png_ptr->transformations & PNG_BACKGROUND)
1065    {
1066       info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
1067       info_ptr->num_trans = 0;
1068       info_ptr->background = png_ptr->background;
1069    }
1070 #endif
1071
1072 #if defined(PNG_READ_GAMMA_SUPPORTED)
1073    if (png_ptr->transformations & PNG_GAMMA)
1074    {
1075 #ifdef PNG_FLOATING_POINT_SUPPORTED
1076       info_ptr->gamma = png_ptr->gamma;
1077 #endif
1078 #ifdef PNG_FIXED_POINT_SUPPORTED
1079       info_ptr->int_gamma = png_ptr->int_gamma;
1080 #endif
1081    }
1082 #endif
1083
1084 #if defined(PNG_READ_16_TO_8_SUPPORTED)
1085    if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
1086       info_ptr->bit_depth = 8;
1087 #endif
1088
1089 #if defined(PNG_READ_DITHER_SUPPORTED)
1090    if (png_ptr->transformations & PNG_DITHER)
1091    {
1092       if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
1093          (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
1094          png_ptr->palette_lookup && info_ptr->bit_depth == 8)
1095       {
1096          info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
1097       }
1098    }
1099 #endif
1100
1101 #if defined(PNG_READ_PACK_SUPPORTED)
1102    if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
1103       info_ptr->bit_depth = 8;
1104 #endif
1105
1106 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
1107    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
1108       info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
1109 #endif
1110
1111 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
1112    if (png_ptr->transformations & PNG_RGB_TO_GRAY)
1113       info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
1114 #endif
1115
1116    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1117       info_ptr->channels = 1;
1118    else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
1119       info_ptr->channels = 3;
1120    else
1121       info_ptr->channels = 1;
1122
1123 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
1124    if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
1125       info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
1126 #endif
1127
1128    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
1129       info_ptr->channels++;
1130
1131 #if defined(PNG_READ_FILLER_SUPPORTED)
1132    /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
1133    if ((png_ptr->transformations & PNG_FILLER) &&
1134        ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
1135        (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
1136    {
1137       info_ptr->channels++;
1138       /* if adding a true alpha channel not just filler */
1139 #if !defined(PNG_1_0_X)
1140       if (png_ptr->transformations & PNG_ADD_ALPHA)
1141         info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
1142 #endif
1143    }
1144 #endif
1145
1146 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
1147 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1148    if(png_ptr->transformations & PNG_USER_TRANSFORM)
1149      {
1150        if(info_ptr->bit_depth < png_ptr->user_transform_depth)
1151          info_ptr->bit_depth = png_ptr->user_transform_depth;
1152        if(info_ptr->channels < png_ptr->user_transform_channels)
1153          info_ptr->channels = png_ptr->user_transform_channels;
1154      }
1155 #endif
1156
1157    info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
1158       info_ptr->bit_depth);
1159
1160    info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,info_ptr->width);
1161
1162 #if !defined(PNG_READ_EXPAND_SUPPORTED)
1163    if(png_ptr)
1164       return;
1165 #endif
1166 }
1167
1168 /* Transform the row.  The order of transformations is significant,
1169  * and is very touchy.  If you add a transformation, take care to
1170  * decide how it fits in with the other transformations here.
1171  */
1172 void /* PRIVATE */
1173 png_do_read_transformations(png_structp png_ptr)
1174 {
1175    png_debug(1, "in png_do_read_transformations\n");
1176 #if !defined(PNG_USELESS_TESTS_SUPPORTED)
1177    if (png_ptr->row_buf == NULL)
1178    {
1179 #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
1180       char msg[50];
1181
1182       sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number,
1183          png_ptr->pass);
1184       png_error(png_ptr, msg);
1185 #else
1186       png_error(png_ptr, "NULL row buffer");
1187 #endif
1188    }
1189 #endif
1190
1191 #if defined(PNG_READ_EXPAND_SUPPORTED)
1192    if (png_ptr->transformations & PNG_EXPAND)
1193    {
1194       if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
1195       {
1196          png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
1197             png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
1198       }
1199       else
1200       {
1201          if (png_ptr->num_trans)
1202             png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
1203                &(png_ptr->trans_values));
1204          else
1205             png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
1206                NULL);
1207       }
1208    }
1209 #endif
1210
1211 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
1212    if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
1213       png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
1214          PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
1215 #endif
1216
1217 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
1218    if (png_ptr->transformations & PNG_RGB_TO_GRAY)
1219    {
1220       int rgb_error =
1221          png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
1222       if(rgb_error)
1223       {
1224          png_ptr->rgb_to_gray_status=1;
1225          if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN)
1226             png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
1227          if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR)
1228             png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
1229       }
1230    }
1231 #endif
1232
1233 /*
1234 From Andreas Dilger e-mail to png-implement, 26 March 1998:
1235
1236   In most cases, the "simple transparency" should be done prior to doing
1237   gray-to-RGB, or you will have to test 3x as many bytes to check if a
1238   pixel is transparent.  You would also need to make sure that the
1239   transparency information is upgraded to RGB.
1240
1241   To summarize, the current flow is:
1242   - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
1243                                   with background "in place" if transparent,
1244                                   convert to RGB if necessary
1245   - Gray + alpha -> composite with gray background and remove alpha bytes,
1246                                   convert to RGB if necessary
1247
1248   To support RGB backgrounds for gray images we need:
1249   - Gray + simple transparency -> convert to RGB + simple transparency, compare
1250                                   3 or 6 bytes and composite with background
1251                                   "in place" if transparent (3x compare/pixel
1252                                   compared to doing composite with gray bkgrnd)
1253   - Gray + alpha -> convert to RGB + alpha, composite with background and
1254                                   remove alpha bytes (3x float operations/pixel
1255                                   compared with composite on gray background)
1256
1257   Greg's change will do this.  The reason it wasn't done before is for
1258   performance, as this increases the per-pixel operations.  If we would check
1259   in advance if the background was gray or RGB, and position the gray-to-RGB
1260   transform appropriately, then it would save a lot of work/time.
1261  */
1262
1263 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
1264    /* if gray -> RGB, do so now only if background is non-gray; else do later
1265     * for performance reasons */
1266    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
1267        !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
1268       png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
1269 #endif
1270
1271 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
1272    if ((png_ptr->transformations & PNG_BACKGROUND) &&
1273       ((png_ptr->num_trans != 0 ) ||
1274       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
1275       png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
1276          &(png_ptr->trans_values), &(png_ptr->background)
1277 #if defined(PNG_READ_GAMMA_SUPPORTED)
1278          , &(png_ptr->background_1),
1279          png_ptr->gamma_table, png_ptr->gamma_from_1,
1280          png_ptr->gamma_to_1, png_ptr->gamma_16_table,
1281          png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
1282          png_ptr->gamma_shift
1283 #endif
1284 );
1285 #endif
1286
1287 #if defined(PNG_READ_GAMMA_SUPPORTED)
1288    if ((png_ptr->transformations & PNG_GAMMA) &&
1289 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
1290       !((png_ptr->transformations & PNG_BACKGROUND) &&
1291       ((png_ptr->num_trans != 0) ||
1292       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
1293 #endif
1294       (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
1295       png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
1296          png_ptr->gamma_table, png_ptr->gamma_16_table,
1297          png_ptr->gamma_shift);
1298 #endif
1299
1300 #if defined(PNG_READ_16_TO_8_SUPPORTED)
1301    if (png_ptr->transformations & PNG_16_TO_8)
1302       png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
1303 #endif
1304
1305 #if defined(PNG_READ_DITHER_SUPPORTED)
1306    if (png_ptr->transformations & PNG_DITHER)
1307    {
1308       png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
1309          png_ptr->palette_lookup, png_ptr->dither_index);
1310       if(png_ptr->row_info.rowbytes == (png_uint_32)0)
1311          png_error(png_ptr, "png_do_dither returned rowbytes=0");
1312    }
1313 #endif
1314
1315 #if defined(PNG_READ_INVERT_SUPPORTED)
1316    if (png_ptr->transformations & PNG_INVERT_MONO)
1317       png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
1318 #endif
1319
1320 #if defined(PNG_READ_SHIFT_SUPPORTED)
1321    if (png_ptr->transformations & PNG_SHIFT)
1322       png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
1323          &(png_ptr->shift));
1324 #endif
1325
1326 #if defined(PNG_READ_PACK_SUPPORTED)
1327    if (png_ptr->transformations & PNG_PACK)
1328       png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
1329 #endif
1330
1331 #if defined(PNG_READ_BGR_SUPPORTED)
1332    if (png_ptr->transformations & PNG_BGR)
1333       png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
1334 #endif
1335
1336 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
1337    if (png_ptr->transformations & PNG_PACKSWAP)
1338       png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
1339 #endif
1340
1341 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
1342    /* if gray -> RGB, do so now only if we did not do so above */
1343    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
1344        (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
1345       png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
1346 #endif
1347
1348 #if defined(PNG_READ_FILLER_SUPPORTED)
1349    if (png_ptr->transformations & PNG_FILLER)
1350       png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
1351          (png_uint_32)png_ptr->filler, png_ptr->flags);
1352 #endif
1353
1354 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
1355    if (png_ptr->transformations & PNG_INVERT_ALPHA)
1356       png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
1357 #endif
1358
1359 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
1360    if (png_ptr->transformations & PNG_SWAP_ALPHA)
1361       png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
1362 #endif
1363
1364 #if defined(PNG_READ_SWAP_SUPPORTED)
1365    if (png_ptr->transformations & PNG_SWAP_BYTES)
1366       png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
1367 #endif
1368
1369 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
1370    if (png_ptr->transformations & PNG_USER_TRANSFORM)
1371     {
1372       if(png_ptr->read_user_transform_fn != NULL)
1373         (*(png_ptr->read_user_transform_fn)) /* user read transform function */
1374           (png_ptr,                    /* png_ptr */
1375            &(png_ptr->row_info),       /* row_info:     */
1376              /*  png_uint_32 width;          width of row */
1377              /*  png_uint_32 rowbytes;       number of bytes in row */
1378              /*  png_byte color_type;        color type of pixels */
1379              /*  png_byte bit_depth;         bit depth of samples */
1380              /*  png_byte channels;          number of channels (1-4) */
1381              /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
1382            png_ptr->row_buf + 1);      /* start of pixel data for row */
1383 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
1384       if(png_ptr->user_transform_depth)
1385          png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
1386       if(png_ptr->user_transform_channels)
1387          png_ptr->row_info.channels = png_ptr->user_transform_channels;
1388 #endif
1389       png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
1390          png_ptr->row_info.channels);
1391       png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
1392          png_ptr->row_info.width);
1393    }
1394 #endif
1395
1396 }
1397
1398 #if defined(PNG_READ_PACK_SUPPORTED)
1399 /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
1400  * without changing the actual values.  Thus, if you had a row with
1401  * a bit depth of 1, you would end up with bytes that only contained
1402  * the numbers 0 or 1.  If you would rather they contain 0 and 255, use
1403  * png_do_shift() after this.
1404  */
1405 void /* PRIVATE */
1406 png_do_unpack(png_row_infop row_info, png_bytep row)
1407 {
1408    png_debug(1, "in png_do_unpack\n");
1409 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1410    if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
1411 #else
1412    if (row_info->bit_depth < 8)
1413 #endif
1414    {
1415       png_uint_32 i;
1416       png_uint_32 row_width=row_info->width;
1417
1418       switch (row_info->bit_depth)
1419       {
1420          case 1:
1421          {
1422             png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
1423             png_bytep dp = row + (png_size_t)row_width - 1;
1424             png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
1425             for (i = 0; i < row_width; i++)
1426             {
1427                *dp = (png_byte)((*sp >> shift) & 0x01);
1428                if (shift == 7)
1429                {
1430                   shift = 0;
1431                   sp--;
1432                }
1433                else
1434                   shift++;
1435
1436                dp--;
1437             }
1438             break;
1439          }
1440          case 2:
1441          {
1442
1443             png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
1444             png_bytep dp = row + (png_size_t)row_width - 1;
1445             png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
1446             for (i = 0; i < row_width; i++)
1447             {
1448                *dp = (png_byte)((*sp >> shift) & 0x03);
1449                if (shift == 6)
1450                {
1451                   shift = 0;
1452                   sp--;
1453                }
1454                else
1455                   shift += 2;
1456
1457                dp--;
1458             }
1459             break;
1460          }
1461          case 4:
1462          {
1463             png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
1464             png_bytep dp = row + (png_size_t)row_width - 1;
1465             png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
1466             for (i = 0; i < row_width; i++)
1467             {
1468                *dp = (png_byte)((*sp >> shift) & 0x0f);
1469                if (shift == 4)
1470                {
1471                   shift = 0;
1472                   sp--;
1473                }
1474                else
1475                   shift = 4;
1476
1477                dp--;
1478             }
1479             break;
1480          }
1481       }
1482       row_info->bit_depth = 8;
1483       row_info->pixel_depth = (png_byte)(8 * row_info->channels);
1484       row_info->rowbytes = row_width * row_info->channels;
1485    }
1486 }
1487 #endif
1488
1489 #if defined(PNG_READ_SHIFT_SUPPORTED)
1490 /* Reverse the effects of png_do_shift.  This routine merely shifts the
1491  * pixels back to their significant bits values.  Thus, if you have
1492  * a row of bit depth 8, but only 5 are significant, this will shift
1493  * the values back to 0 through 31.
1494  */
1495 void /* PRIVATE */
1496 png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
1497 {
1498    png_debug(1, "in png_do_unshift\n");
1499    if (
1500 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1501        row != NULL && row_info != NULL && sig_bits != NULL &&
1502 #endif
1503        row_info->color_type != PNG_COLOR_TYPE_PALETTE)
1504    {
1505       int shift[4];
1506       int channels = 0;
1507       int c;
1508       png_uint_16 value = 0;
1509       png_uint_32 row_width = row_info->width;
1510
1511       if (row_info->color_type & PNG_COLOR_MASK_COLOR)
1512       {
1513          shift[channels++] = row_info->bit_depth - sig_bits->red;
1514          shift[channels++] = row_info->bit_depth - sig_bits->green;
1515          shift[channels++] = row_info->bit_depth - sig_bits->blue;
1516       }
1517       else
1518       {
1519          shift[channels++] = row_info->bit_depth - sig_bits->gray;
1520       }
1521       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
1522       {
1523          shift[channels++] = row_info->bit_depth - sig_bits->alpha;
1524       }
1525
1526       for (c = 0; c < channels; c++)
1527       {
1528          if (shift[c] <= 0)
1529             shift[c] = 0;
1530          else
1531             value = 1;
1532       }
1533
1534       if (!value)
1535          return;
1536
1537       switch (row_info->bit_depth)
1538       {
1539          case 2:
1540          {
1541             png_bytep bp;
1542             png_uint_32 i;
1543             png_uint_32 istop = row_info->rowbytes;
1544
1545             for (bp = row, i = 0; i < istop; i++)
1546             {
1547                *bp >>= 1;
1548                *bp++ &= 0x55;
1549             }
1550             break;
1551          }
1552          case 4:
1553          {
1554             png_bytep bp = row;
1555             png_uint_32 i;
1556             png_uint_32 istop = row_info->rowbytes;
1557             png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
1558                (png_byte)((int)0xf >> shift[0]));
1559
1560             for (i = 0; i < istop; i++)
1561             {
1562                *bp >>= shift[0];
1563                *bp++ &= mask;
1564             }
1565             break;
1566          }
1567          case 8:
1568          {
1569             png_bytep bp = row;
1570             png_uint_32 i;
1571             png_uint_32 istop = row_width * channels;
1572
1573             for (i = 0; i < istop; i++)
1574             {
1575                *bp++ >>= shift[i%channels];
1576             }
1577             break;
1578          }
1579          case 16:
1580          {
1581             png_bytep bp = row;
1582             png_uint_32 i;
1583             png_uint_32 istop = channels * row_width;
1584
1585             for (i = 0; i < istop; i++)
1586             {
1587                value = (png_uint_16)((*bp << 8) + *(bp + 1));
1588                value >>= shift[i%channels];
1589                *bp++ = (png_byte)(value >> 8);
1590                *bp++ = (png_byte)(value & 0xff);
1591             }
1592             break;
1593          }
1594       }
1595    }
1596 }
1597 #endif
1598
1599 #if defined(PNG_READ_16_TO_8_SUPPORTED)
1600 /* chop rows of bit depth 16 down to 8 */
1601 void /* PRIVATE */
1602 png_do_chop(png_row_infop row_info, png_bytep row)
1603 {
1604    png_debug(1, "in png_do_chop\n");
1605 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1606    if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
1607 #else
1608    if (row_info->bit_depth == 16)
1609 #endif
1610    {
1611       png_bytep sp = row;
1612       png_bytep dp = row;
1613       png_uint_32 i;
1614       png_uint_32 istop = row_info->width * row_info->channels;
1615
1616       for (i = 0; i<istop; i++, sp += 2, dp++)
1617       {
1618 #if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
1619       /* This does a more accurate scaling of the 16-bit color
1620        * value, rather than a simple low-byte truncation.
1621        *
1622        * What the ideal calculation should be:
1623        *   *dp = (((((png_uint_32)(*sp) << 8) |
1624        *          (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
1625        *
1626        * GRR: no, I think this is what it really should be:
1627        *   *dp = (((((png_uint_32)(*sp) << 8) |
1628        *           (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
1629        *
1630        * GRR: here's the exact calculation with shifts:
1631        *   temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;
1632        *   *dp = (temp - (temp >> 8)) >> 8;
1633        *
1634        * Approximate calculation with shift/add instead of multiply/divide:
1635        *   *dp = ((((png_uint_32)(*sp) << 8) |
1636        *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;
1637        *
1638        * What we actually do to avoid extra shifting and conversion:
1639        */
1640
1641          *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);
1642 #else
1643        /* Simply discard the low order byte */
1644          *dp = *sp;
1645 #endif
1646       }
1647       row_info->bit_depth = 8;
1648       row_info->pixel_depth = (png_byte)(8 * row_info->channels);
1649       row_info->rowbytes = row_info->width * row_info->channels;
1650    }
1651 }
1652 #endif
1653
1654 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
1655 void /* PRIVATE */
1656 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
1657 {
1658    png_debug(1, "in png_do_read_swap_alpha\n");
1659 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1660    if (row != NULL && row_info != NULL)
1661 #endif
1662    {
1663       png_uint_32 row_width = row_info->width;
1664       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
1665       {
1666          /* This converts from RGBA to ARGB */
1667          if (row_info->bit_depth == 8)
1668          {
1669             png_bytep sp = row + row_info->rowbytes;
1670             png_bytep dp = sp;
1671             png_byte save;
1672             png_uint_32 i;
1673
1674             for (i = 0; i < row_width; i++)
1675             {
1676                save = *(--sp);
1677                *(--dp) = *(--sp);
1678                *(--dp) = *(--sp);
1679                *(--dp) = *(--sp);
1680                *(--dp) = save;
1681             }
1682          }
1683          /* This converts from RRGGBBAA to AARRGGBB */
1684          else
1685          {
1686             png_bytep sp = row + row_info->rowbytes;
1687             png_bytep dp = sp;
1688             png_byte save[2];
1689             png_uint_32 i;
1690
1691             for (i = 0; i < row_width; i++)
1692             {
1693                save[0] = *(--sp);
1694                save[1] = *(--sp);
1695                *(--dp) = *(--sp);
1696                *(--dp) = *(--sp);
1697                *(--dp) = *(--sp);
1698                *(--dp) = *(--sp);
1699                *(--dp) = *(--sp);
1700                *(--dp) = *(--sp);
1701                *(--dp) = save[0];
1702                *(--dp) = save[1];
1703             }
1704          }
1705       }
1706       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
1707       {
1708          /* This converts from GA to AG */
1709          if (row_info->bit_depth == 8)
1710          {
1711             png_bytep sp = row + row_info->rowbytes;
1712             png_bytep dp = sp;
1713             png_byte save;
1714             png_uint_32 i;
1715
1716             for (i = 0; i < row_width; i++)
1717             {
1718                save = *(--sp);
1719                *(--dp) = *(--sp);
1720                *(--dp) = save;
1721             }
1722          }
1723          /* This converts from GGAA to AAGG */
1724          else
1725          {
1726             png_bytep sp = row + row_info->rowbytes;
1727             png_bytep dp = sp;
1728             png_byte save[2];
1729             png_uint_32 i;
1730
1731             for (i = 0; i < row_width; i++)
1732             {
1733                save[0] = *(--sp);
1734                save[1] = *(--sp);
1735                *(--dp) = *(--sp);
1736                *(--dp) = *(--sp);
1737                *(--dp) = save[0];
1738                *(--dp) = save[1];
1739             }
1740          }
1741       }
1742    }
1743 }
1744 #endif
1745
1746 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
1747 void /* PRIVATE */
1748 png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
1749 {
1750    png_debug(1, "in png_do_read_invert_alpha\n");
1751 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1752    if (row != NULL && row_info != NULL)
1753 #endif
1754    {
1755       png_uint_32 row_width = row_info->width;
1756       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
1757       {
1758          /* This inverts the alpha channel in RGBA */
1759          if (row_info->bit_depth == 8)
1760          {
1761             png_bytep sp = row + row_info->rowbytes;
1762             png_bytep dp = sp;
1763             png_uint_32 i;
1764
1765             for (i = 0; i < row_width; i++)
1766             {
1767                *(--dp) = (png_byte)(255 - *(--sp));
1768
1769 /*             This does nothing:
1770                *(--dp) = *(--sp);
1771                *(--dp) = *(--sp);
1772                *(--dp) = *(--sp);
1773                We can replace it with:
1774 */
1775                sp-=3;
1776                dp=sp;
1777             }
1778          }
1779          /* This inverts the alpha channel in RRGGBBAA */
1780          else
1781          {
1782             png_bytep sp = row + row_info->rowbytes;
1783             png_bytep dp = sp;
1784             png_uint_32 i;
1785
1786             for (i = 0; i < row_width; i++)
1787             {
1788                *(--dp) = (png_byte)(255 - *(--sp));
1789                *(--dp) = (png_byte)(255 - *(--sp));
1790
1791 /*             This does nothing:
1792                *(--dp) = *(--sp);
1793                *(--dp) = *(--sp);
1794                *(--dp) = *(--sp);
1795                *(--dp) = *(--sp);
1796                *(--dp) = *(--sp);
1797                *(--dp) = *(--sp);
1798                We can replace it with:
1799 */
1800                sp-=6;
1801                dp=sp;
1802             }
1803          }
1804       }
1805       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
1806       {
1807          /* This inverts the alpha channel in GA */
1808          if (row_info->bit_depth == 8)
1809          {
1810             png_bytep sp = row + row_info->rowbytes;
1811             png_bytep dp = sp;
1812             png_uint_32 i;
1813
1814             for (i = 0; i < row_width; i++)
1815             {
1816                *(--dp) = (png_byte)(255 - *(--sp));
1817                *(--dp) = *(--sp);
1818             }
1819          }
1820          /* This inverts the alpha channel in GGAA */
1821          else
1822          {
1823             png_bytep sp  = row + row_info->rowbytes;
1824             png_bytep dp = sp;
1825             png_uint_32 i;
1826
1827             for (i = 0; i < row_width; i++)
1828             {
1829                *(--dp) = (png_byte)(255 - *(--sp));
1830                *(--dp) = (png_byte)(255 - *(--sp));
1831 /*
1832                *(--dp) = *(--sp);
1833                *(--dp) = *(--sp);
1834 */
1835                sp-=2;
1836                dp=sp;
1837             }
1838          }
1839       }
1840    }
1841 }
1842 #endif
1843
1844 #if defined(PNG_READ_FILLER_SUPPORTED)
1845 /* Add filler channel if we have RGB color */
1846 void /* PRIVATE */
1847 png_do_read_filler(png_row_infop row_info, png_bytep row,
1848    png_uint_32 filler, png_uint_32 flags)
1849 {
1850    png_uint_32 i;
1851    png_uint_32 row_width = row_info->width;
1852
1853    png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
1854    png_byte lo_filler = (png_byte)(filler & 0xff);
1855
1856    png_debug(1, "in png_do_read_filler\n");
1857    if (
1858 #if defined(PNG_USELESS_TESTS_SUPPORTED)
1859        row != NULL  && row_info != NULL &&
1860 #endif
1861        row_info->color_type == PNG_COLOR_TYPE_GRAY)
1862    {
1863       if(row_info->bit_depth == 8)
1864       {
1865          /* This changes the data from G to GX */
1866          if (flags & PNG_FLAG_FILLER_AFTER)
1867          {
1868             png_bytep sp = row + (png_size_t)row_width;
1869             png_bytep dp =  sp + (png_size_t)row_width;
1870             for (i = 1; i < row_width; i++)
1871             {
1872                *(--dp) = lo_filler;
1873                *(--dp) = *(--sp);
1874             }
1875             *(--dp) = lo_filler;
1876             row_info->channels = 2;
1877             row_info->pixel_depth = 16;
1878             row_info->rowbytes = row_width * 2;
1879          }
1880       /* This changes the data from G to XG */
1881          else
1882          {
1883             png_bytep sp = row + (png_size_t)row_width;
1884             png_bytep dp = sp  + (png_size_t)row_width;
1885             for (i = 0; i < row_width; i++)
1886             {
1887                *(--dp) = *(--sp);
1888                *(--dp) = lo_filler;
1889             }
1890             row_info->channels = 2;
1891             row_info->pixel_depth = 16;
1892             row_info->rowbytes = row_width * 2;
1893          }
1894       }
1895       else if(row_info->bit_depth == 16)
1896       {
1897          /* This changes the data from GG to GGXX */
1898          if (flags & PNG_FLAG_FILLER_AFTER)
1899          {
1900             png_bytep sp = row + (png_size_t)row_width * 2;
1901             png_bytep dp = sp  + (png_size_t)row_width * 2;
1902             for (i = 1; i < row_width; i++)
1903             {
1904                *(--dp) = hi_filler;
1905                *(--dp) = lo_filler;
1906                *(--dp) = *(--sp);
1907                *(--dp) = *(--sp);
1908             }
1909             *(--dp) = hi_filler;
1910             *(--dp) = lo_filler;
1911             row_info->channels = 2;
1912             row_info->pixel_depth = 32;
1913             row_info->rowbytes = row_width * 4;
1914          }
1915          /* This changes the data from GG to XXGG */
1916          else
1917          {
1918             png_bytep sp = row + (png_size_t)row_width * 2;
1919             png_bytep dp = sp  + (png_size_t)row_width * 2;
1920             for (i = 0; i < row_width; i++)
1921             {
1922                *(--dp) = *(--sp);
1923                *(--dp) = *(--sp);
1924                *(--dp) = hi_filler;
1925                *(--dp) = lo_filler;
1926             }
1927             row_info->channels = 2;
1928             row_info->pixel_depth = 32;
1929             row_info->rowbytes = row_width * 4;
1930          }
1931       }
1932    } /* COLOR_TYPE == GRAY */
1933    else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
1934    {
1935       if(row_info->bit_depth == 8)
1936       {
1937          /* This changes the data from RGB to RGBX */
1938          if (flags & PNG_FLAG_FILLER_AFTER)
1939          {
1940             png_bytep sp = row + (png_size_t)row_width * 3;
1941             png_bytep dp = sp  + (png_size_t)row_width;
1942             for (i = 1; i < row_width; i++)
1943             {
1944                *(--dp) = lo_filler;
1945                *(--dp) = *(--sp);
1946                *(--dp) = *(--sp);
1947                *(--dp) = *(--sp);
1948             }
1949             *(--dp) = lo_filler;
1950             row_info->channels = 4;
1951             row_info->pixel_depth = 32;
1952             row_info->rowbytes = row_width * 4;
1953          }
1954       /* This changes the data from RGB to XRGB */
1955          else
1956          {
1957             png_bytep sp = row + (png_size_t)row_width * 3;
1958             png_bytep dp = sp + (png_size_t)row_width;
1959             for (i = 0; i < row_width; i++)
1960             {
1961                *(--dp) = *(--sp);
1962                *(--dp) = *(--sp);
1963                *(--dp) = *(--sp);
1964                *(--dp) = lo_filler;
1965             }
1966             row_info->channels = 4;
1967             row_info->pixel_depth = 32;
1968             row_info->rowbytes = row_width * 4;
1969          }
1970       }
1971       else if(row_info->bit_depth == 16)
1972       {
1973          /* This changes the data from RRGGBB to RRGGBBXX */
1974          if (flags & PNG_FLAG_FILLER_AFTER)
1975          {
1976             png_bytep sp = row + (png_size_t)row_width * 6;
1977             png_bytep dp = sp  + (png_size_t)row_width * 2;
1978             for (i = 1; i < row_width; i++)
1979             {
1980                *(--dp) = hi_filler;
1981                *(--dp) = lo_filler;
1982                *(--dp) = *(--sp);
1983                *(--dp) = *(--sp);
1984                *(--dp) = *(--sp);
1985                *(--dp) = *(--sp);
1986                *(--dp) = *(--sp);
1987                *(--dp) = *(--sp);
1988             }
1989             *(--dp) = hi_filler;
1990             *(--dp) = lo_filler;
1991             row_info->channels = 4;
1992             row_info->pixel_depth = 64;
1993             row_info->rowbytes = row_width * 8;
1994          }
1995          /* This changes the data from RRGGBB to XXRRGGBB */
1996          else
1997          {
1998             png_bytep sp = row + (png_size_t)row_width * 6;
1999             png_bytep dp = sp  + (png_size_t)row_width * 2;
2000             for (i = 0; i < row_width; i++)
2001             {
2002                *(--dp) = *(--sp);
2003                *(--dp) = *(--sp);
2004                *(--dp) = *(--sp);
2005                *(--dp) = *(--sp);
2006                *(--dp) = *(--sp);
2007                *(--dp) = *(--sp);
2008                *(--dp) = hi_filler;
2009                *(--dp) = lo_filler;
2010             }
2011             row_info->channels = 4;
2012             row_info->pixel_depth = 64;
2013             row_info->rowbytes = row_width * 8;
2014          }
2015       }
2016    } /* COLOR_TYPE == RGB */
2017 }
2018 #endif
2019
2020 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
2021 /* expand grayscale files to RGB, with or without alpha */
2022 void /* PRIVATE */
2023 png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
2024 {
2025    png_uint_32 i;
2026    png_uint_32 row_width = row_info->width;
2027
2028    png_debug(1, "in png_do_gray_to_rgb\n");
2029    if (row_info->bit_depth >= 8 &&
2030 #if defined(PNG_USELESS_TESTS_SUPPORTED)
2031        row != NULL && row_info != NULL &&
2032 #endif
2033       !(row_info->color_type & PNG_COLOR_MASK_COLOR))
2034    {
2035       if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
2036       {
2037          if (row_info->bit_depth == 8)
2038          {
2039             png_bytep sp = row + (png_size_t)row_width - 1;
2040             png_bytep dp = sp  + (png_size_t)row_width * 2;
2041             for (i = 0; i < row_width; i++)
2042             {
2043                *(dp--) = *sp;
2044                *(dp--) = *sp;
2045                *(dp--) = *(sp--);
2046             }
2047          }
2048          else
2049          {
2050             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
2051             png_bytep dp = sp  + (png_size_t)row_width * 4;
2052             for (i = 0; i < row_width; i++)
2053             {
2054                *(dp--) = *sp;
2055                *(dp--) = *(sp - 1);
2056                *(dp--) = *sp;
2057                *(dp--) = *(sp - 1);
2058                *(dp--) = *(sp--);
2059                *(dp--) = *(sp--);
2060             }
2061          }
2062       }
2063       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
2064       {
2065          if (row_info->bit_depth == 8)
2066          {
2067             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
2068             png_bytep dp = sp  + (png_size_t)row_width * 2;
2069             for (i = 0; i < row_width; i++)
2070             {
2071                *(dp--) = *(sp--);
2072                *(dp--) = *sp;
2073                *(dp--) = *sp;
2074                *(dp--) = *(sp--);
2075             }
2076          }
2077          else
2078          {
2079             png_bytep sp = row + (png_size_t)row_width * 4 - 1;
2080             png_bytep dp = sp  + (png_size_t)row_width * 4;
2081             for (i = 0; i < row_width; i++)
2082             {
2083                *(dp--) = *(sp--);
2084                *(dp--) = *(sp--);
2085                *(dp--) = *sp;
2086                *(dp--) = *(sp - 1);
2087                *(dp--) = *sp;
2088                *(dp--) = *(sp - 1);
2089                *(dp--) = *(sp--);
2090                *(dp--) = *(sp--);
2091             }
2092          }
2093       }
2094       row_info->channels += (png_byte)2;
2095       row_info->color_type |= PNG_COLOR_MASK_COLOR;
2096       row_info->pixel_depth = (png_byte)(row_info->channels *
2097          row_info->bit_depth);
2098       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
2099    }
2100 }
2101 #endif
2102
2103 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2104 /* reduce RGB files to grayscale, with or without alpha
2105  * using the equation given in Poynton's ColorFAQ at
2106  * <http://www.inforamp.net/~poynton/>
2107  * Copyright (c) 1998-01-04 Charles Poynton poynton at inforamp.net
2108  *
2109  *     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
2110  *
2111  *  We approximate this with
2112  *
2113  *     Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B
2114  *
2115  *  which can be expressed with integers as
2116  *
2117  *     Y = (6969 * R + 23434 * G + 2365 * B)/32768
2118  *
2119  *  The calculation is to be done in a linear colorspace.
2120  *
2121  *  Other integer coefficents can be used via png_set_rgb_to_gray().
2122  */
2123 int /* PRIVATE */
2124 png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
2125
2126 {
2127    png_uint_32 i;
2128
2129    png_uint_32 row_width = row_info->width;
2130    int rgb_error = 0;
2131
2132    png_debug(1, "in png_do_rgb_to_gray\n");
2133    if (
2134 #if defined(PNG_USELESS_TESTS_SUPPORTED)
2135        row != NULL && row_info != NULL &&
2136 #endif
2137       (row_info->color_type & PNG_COLOR_MASK_COLOR))
2138    {
2139       png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
2140       png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
2141       png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
2142
2143       if (row_info->color_type == PNG_COLOR_TYPE_RGB)
2144       {
2145          if (row_info->bit_depth == 8)
2146          {
2147 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
2148             if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
2149             {
2150                png_bytep sp = row;
2151                png_bytep dp = row;
2152
2153                for (i = 0; i < row_width; i++)
2154                {
2155                   png_byte red   = png_ptr->gamma_to_1[*(sp++)];
2156                   png_byte green = png_ptr->gamma_to_1[*(sp++)];
2157                   png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
2158                   if(red != green || red != blue)
2159                   {
2160                      rgb_error |= 1;
2161                      *(dp++) = png_ptr->gamma_from_1[
2162                        (rc*red+gc*green+bc*blue)>>15];
2163                   }
2164                   else
2165                      *(dp++) = *(sp-1);
2166                }
2167             }
2168             else
2169 #endif
2170             {
2171                png_bytep sp = row;
2172                png_bytep dp = row;
2173                for (i = 0; i < row_width; i++)
2174                {
2175                   png_byte red   = *(sp++);
2176                   png_byte green = *(sp++);
2177                   png_byte blue  = *(sp++);
2178                   if(red != green || red != blue)
2179                   {
2180                      rgb_error |= 1;
2181                      *(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15);
2182                   }
2183                   else
2184                      *(dp++) = *(sp-1);
2185                }
2186             }
2187          }
2188
2189          else /* RGB bit_depth == 16 */
2190          {
2191 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
2192             if (png_ptr->gamma_16_to_1 != NULL &&
2193                 png_ptr->gamma_16_from_1 != NULL)
2194             {
2195                png_bytep sp = row;
2196                png_bytep dp = row;
2197                for (i = 0; i < row_width; i++)
2198                {
2199                   png_uint_16 red, green, blue, w;
2200
2201                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2202                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2203                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2204
2205                   if(red == green && red == blue)
2206                      w = red;
2207                   else
2208                   {
2209                      png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
2210                                   png_ptr->gamma_shift][red>>8];
2211                      png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
2212                                   png_ptr->gamma_shift][green>>8];
2213                      png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
2214                                   png_ptr->gamma_shift][blue>>8];
2215                      png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1
2216                                   + bc*blue_1)>>15);
2217                      w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
2218                          png_ptr->gamma_shift][gray16 >> 8];
2219                      rgb_error |= 1;
2220                   }
2221
2222                   *(dp++) = (png_byte)((w>>8) & 0xff);
2223                   *(dp++) = (png_byte)(w & 0xff);
2224                }
2225             }
2226             else
2227 #endif
2228             {
2229                png_bytep sp = row;
2230                png_bytep dp = row;
2231                for (i = 0; i < row_width; i++)
2232                {
2233                   png_uint_16 red, green, blue, gray16;
2234
2235                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2236                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2237                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2238
2239                   if(red != green || red != blue)
2240                      rgb_error |= 1;
2241                   gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
2242                   *(dp++) = (png_byte)((gray16>>8) & 0xff);
2243                   *(dp++) = (png_byte)(gray16 & 0xff);
2244                }
2245             }
2246          }
2247       }
2248       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
2249       {
2250          if (row_info->bit_depth == 8)
2251          {
2252 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
2253             if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
2254             {
2255                png_bytep sp = row;
2256                png_bytep dp = row;
2257                for (i = 0; i < row_width; i++)
2258                {
2259                   png_byte red   = png_ptr->gamma_to_1[*(sp++)];
2260                   png_byte green = png_ptr->gamma_to_1[*(sp++)];
2261                   png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
2262                   if(red != green || red != blue)
2263                      rgb_error |= 1;
2264                   *(dp++) =  png_ptr->gamma_from_1
2265                              [(rc*red + gc*green + bc*blue)>>15];
2266                   *(dp++) = *(sp++);  /* alpha */
2267                }
2268             }
2269             else
2270 #endif
2271             {
2272                png_bytep sp = row;
2273                png_bytep dp = row;
2274                for (i = 0; i < row_width; i++)
2275                {
2276                   png_byte red   = *(sp++);
2277                   png_byte green = *(sp++);
2278                   png_byte blue  = *(sp++);
2279                   if(red != green || red != blue)
2280                      rgb_error |= 1;
2281                   *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);
2282                   *(dp++) = *(sp++);  /* alpha */
2283                }
2284             }
2285          }
2286          else /* RGBA bit_depth == 16 */
2287          {
2288 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
2289             if (png_ptr->gamma_16_to_1 != NULL &&
2290                 png_ptr->gamma_16_from_1 != NULL)
2291             {
2292                png_bytep sp = row;
2293                png_bytep dp = row;
2294                for (i = 0; i < row_width; i++)
2295                {
2296                   png_uint_16 red, green, blue, w;
2297
2298                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2299                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2300                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
2301
2302                   if(red == green && red == blue)
2303                      w = red;
2304                   else
2305                   {
2306                      png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
2307                                   png_ptr->gamma_shift][red>>8];
2308                      png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
2309                                   png_ptr->gamma_shift][green>>8];
2310                      png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
2311                                   png_ptr->gamma_shift][blue>>8];
2312                      png_uint_16 gray16  = (png_uint_16)((rc * red_1
2313                                   + gc * green_1 + bc * blue_1)>>15);
2314                      w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
2315                          png_ptr->gamma_shift][gray16 >> 8];
2316                      rgb_error |= 1;
2317                   }
2318
2319                   *(dp++) = (png_byte)((w>>8) & 0xff);
2320                   *(dp++) = (png_byte)(w & 0xff);
2321                   *(dp++) = *(sp++);  /* alpha */
2322                   *(dp++) = *(sp++);
2323                }
2324             }
2325             else
2326 #endif
2327             {
2328                png_bytep sp = row;
2329                png_bytep dp = row;
2330                for (i = 0; i < row_width; i++)
2331                {
2332                   png_uint_16 red, green, blue, gray16;
2333                   red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
2334                   green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
2335                   blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
2336                   if(red != green || red != blue)
2337                      rgb_error |= 1;
2338                   gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
2339                   *(dp++) = (png_byte)((gray16>>8) & 0xff);
2340                   *(dp++) = (png_byte)(gray16 & 0xff);
2341                   *(dp++) = *(sp++);  /* alpha */
2342                   *(dp++) = *(sp++);
2343                }
2344             }
2345          }
2346       }
2347    row_info->channels -= (png_byte)2;
2348       row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
2349       row_info->pixel_depth = (png_byte)(row_info->channels *
2350          row_info->bit_depth);
2351       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
2352    }
2353    return rgb_error;
2354 }
2355 #endif
2356
2357 /* Build a grayscale palette.  Palette is assumed to be 1 << bit_depth
2358  * large of png_color.  This lets grayscale images be treated as
2359  * paletted.  Most useful for gamma correction and simplification
2360  * of code.
2361  */
2362 void PNGAPI
2363 png_build_grayscale_palette(int bit_depth, png_colorp palette)
2364 {
2365    int num_palette;
2366    int color_inc;
2367    int i;
2368    int v;
2369
2370    png_debug(1, "in png_do_build_grayscale_palette\n");
2371    if (palette == NULL)
2372       return;
2373
2374    switch (bit_depth)
2375    {
2376       case 1:
2377          num_palette = 2;
2378          color_inc = 0xff;
2379          break;
2380       case 2:
2381          num_palette = 4;
2382          color_inc = 0x55;
2383          break;
2384       case 4:
2385          num_palette = 16;
2386          color_inc = 0x11;
2387          break;
2388       case 8:
2389          num_palette = 256;
2390          color_inc = 1;
2391          break;
2392       default:
2393          num_palette = 0;
2394          color_inc = 0;
2395          break;
2396    }
2397
2398    for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
2399    {
2400       palette[i].red = (png_byte)v;
2401       palette[i].green = (png_byte)v;
2402       palette[i].blue = (png_byte)v;
2403    }
2404 }
2405
2406 /* This function is currently unused.  Do we really need it? */
2407 #if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
2408 void /* PRIVATE */
2409 png_correct_palette(png_structp png_ptr, png_colorp palette,
2410    int num_palette)
2411 {
2412    png_debug(1, "in png_correct_palette\n");
2413 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
2414     defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
2415    if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
2416    {
2417       png_color back, back_1;
2418
2419       if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
2420       {
2421          back.red = png_ptr->gamma_table[png_ptr->background.red];
2422          back.green = png_ptr->gamma_table[png_ptr->background.green];
2423          back.blue = png_ptr->gamma_table[png_ptr->background.blue];
2424
2425          back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
2426          back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
2427          back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
2428       }
2429       else
2430       {
2431          double g;
2432
2433          g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
2434
2435          if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
2436              fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
2437          {
2438             back.red = png_ptr->background.red;
2439             back.green = png_ptr->background.green;
2440             back.blue = png_ptr->background.blue;
2441          }
2442          else
2443          {
2444             back.red =
2445                (png_byte)(pow((double)png_ptr->background.red/255, g) *
2446                 255.0 + 0.5);
2447             back.green =
2448                (png_byte)(pow((double)png_ptr->background.green/255, g) *
2449                 255.0 + 0.5);
2450             back.blue =
2451                (png_byte)(pow((double)png_ptr->background.blue/255, g) *
2452                 255.0 + 0.5);
2453          }
2454
2455          g = 1.0 / png_ptr->background_gamma;
2456
2457          back_1.red =
2458             (png_byte)(pow((double)png_ptr->background.red/255, g) *
2459              255.0 + 0.5);
2460          back_1.green =
2461             (png_byte)(pow((double)png_ptr->background.green/255, g) *
2462              255.0 + 0.5);
2463          back_1.blue =
2464             (png_byte)(pow((double)png_ptr->background.blue/255, g) *
2465              255.0 + 0.5);
2466       }
2467
2468       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
2469       {
2470          png_uint_32 i;
2471
2472          for (i = 0; i < (png_uint_32)num_palette; i++)
2473          {
2474             if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
2475             {
2476                palette[i] = back;
2477             }
2478             else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
2479             {
2480                png_byte v, w;
2481
2482                v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
2483                png_composite(w, v, png_ptr->trans[i], back_1.red);
2484                palette[i].red = png_ptr->gamma_from_1[w];
2485
2486                v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
2487                png_composite(w, v, png_ptr->trans[i], back_1.green);
2488                palette[i].green = png_ptr->gamma_from_1[w];
2489
2490                v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
2491                png_composite(w, v, png_ptr->trans[i], back_1.blue);
2492                palette[i].blue = png_ptr->gamma_from_1[w];
2493             }
2494             else
2495             {
2496                palette[i].red = png_ptr->gamma_table[palette[i].red];
2497                palette[i].green = png_ptr->gamma_table[palette[i].green];
2498                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
2499             }
2500          }
2501       }
2502       else
2503       {
2504          int i;
2505
2506          for (i = 0; i < num_palette; i++)
2507          {
2508             if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
2509             {
2510                palette[i] = back;
2511             }
2512             else
2513             {
2514                palette[i].red = png_ptr->gamma_table[palette[i].red];
2515                palette[i].green = png_ptr->gamma_table[palette[i].green];
2516                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
2517             }
2518          }
2519       }
2520    }
2521    else
2522 #endif
2523 #if defined(PNG_READ_GAMMA_SUPPORTED)
2524    if (png_ptr->transformations & PNG_GAMMA)
2525    {
2526       int i;
2527
2528       for (i = 0; i < num_palette; i++)
2529       {
2530          palette[i].red = png_ptr->gamma_table[palette[i].red];
2531          palette[i].green = png_ptr->gamma_table[palette[i].green];
2532          palette[i].blue = png_ptr->gamma_table[palette[i].blue];
2533       }
2534    }
2535 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
2536    else
2537 #endif
2538 #endif
2539 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
2540    if (png_ptr->transformations & PNG_BACKGROUND)
2541    {
2542       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
2543       {
2544          png_color back;
2545
2546          back.red   = (png_byte)png_ptr->background.red;
2547          back.green = (png_byte)png_ptr->background.green;
2548          back.blue  = (png_byte)png_ptr->background.blue;
2549
2550          for (i = 0; i < (int)png_ptr->num_trans; i++)
2551          {
2552             if (png_ptr->trans[i] == 0)
2553             {
2554                palette[i].red = back.red;
2555                palette[i].green = back.green;
2556                palette[i].blue = back.blue;
2557             }
2558             else if (png_ptr->trans[i] != 0xff)
2559             {
2560                png_composite(palette[i].red, png_ptr->palette[i].red,
2561                   png_ptr->trans[i], back.red);
2562                png_composite(palette[i].green, png_ptr->palette[i].green,
2563                   png_ptr->trans[i], back.green);
2564                png_composite(palette[i].blue, png_ptr->palette[i].blue,
2565                   png_ptr->trans[i], back.blue);
2566             }
2567          }
2568       }
2569       else /* assume grayscale palette (what else could it be?) */
2570       {
2571          int i;
2572
2573          for (i = 0; i < num_palette; i++)
2574          {
2575             if (i == (png_byte)png_ptr->trans_values.gray)
2576             {
2577                palette[i].red = (png_byte)png_ptr->background.red;
2578                palette[i].green = (png_byte)png_ptr->background.green;
2579                palette[i].blue = (png_byte)png_ptr->background.blue;
2580             }
2581          }
2582       }
2583    }
2584 #endif
2585 }
2586 #endif
2587
2588 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
2589 /* Replace any alpha or transparency with the supplied background color.
2590  * "background" is already in the screen gamma, while "background_1" is
2591  * at a gamma of 1.0.  Paletted files have already been taken care of.
2592  */
2593 void /* PRIVATE */
2594 png_do_background(png_row_infop row_info, png_bytep row,
2595    png_color_16p trans_values, png_color_16p background
2596 #if defined(PNG_READ_GAMMA_SUPPORTED)
2597    , png_color_16p background_1,
2598    png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
2599    png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
2600    png_uint_16pp gamma_16_to_1, int gamma_shift
2601 #endif
2602    )
2603 {
2604    png_bytep sp, dp;
2605    png_uint_32 i;
2606    png_uint_32 row_width=row_info->width;
2607    int shift;
2608
2609    png_debug(1, "in png_do_background\n");
2610    if (background != NULL &&
2611 #if defined(PNG_USELESS_TESTS_SUPPORTED)
2612        row != NULL && row_info != NULL &&
2613 #endif
2614       (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
2615       (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
2616    {
2617       switch (row_info->color_type)
2618       {
2619          case PNG_COLOR_TYPE_GRAY:
2620          {
2621             switch (row_info->bit_depth)
2622             {
2623                case 1:
2624                {
2625                   sp = row;
2626                   shift = 7;
2627                   for (i = 0; i < row_width; i++)
2628                   {
2629                      if ((png_uint_16)((*sp >> shift) & 0x01)
2630                         == trans_values->gray)
2631                      {
2632                         *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
2633                         *sp |= (png_byte)(background->gray << shift);
2634                      }
2635                      if (!shift)
2636                      {
2637                         shift = 7;
2638                         sp++;
2639                      }
2640                      else
2641                         shift--;
2642                   }
2643                   break;
2644                }
2645                case 2:
2646                {
2647 #if defined(PNG_READ_GAMMA_SUPPORTED)
2648                   if (gamma_table != NULL)
2649                   {
2650                      sp = row;
2651                      shift = 6;
2652                      for (i = 0; i < row_width; i++)
2653                      {
2654                         if ((png_uint_16)((*sp >> shift) & 0x03)
2655                             == trans_values->gray)
2656                         {
2657                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
2658                            *sp |= (png_byte)(background->gray << shift);
2659                         }
2660                         else
2661                         {
2662                            png_byte p = (png_byte)((*sp >> shift) & 0x03);
2663                            png_byte g = (png_byte)((gamma_table [p | (p << 2) |
2664                                (p << 4) | (p << 6)] >> 6) & 0x03);
2665                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
2666                            *sp |= (png_byte)(g << shift);
2667                         }
2668                         if (!shift)
2669                         {
2670                            shift = 6;
2671                            sp++;
2672                         }
2673                         else
2674                            shift -= 2;
2675                      }
2676                   }
2677                   else
2678 #endif
2679                   {
2680                      sp = row;
2681                      shift = 6;
2682                      for (i = 0; i < row_width; i++)
2683                      {
2684                         if ((png_uint_16)((*sp >> shift) & 0x03)
2685                             == trans_values->gray)
2686                         {
2687                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
2688                            *sp |= (png_byte)(background->gray << shift);
2689                         }
2690                         if (!shift)
2691                         {
2692                            shift = 6;
2693                            sp++;
2694                         }
2695                         else
2696                            shift -= 2;
2697                      }
2698                   }
2699                   break;
2700                }
2701                case 4:
2702                {
2703 #if defined(PNG_READ_GAMMA_SUPPORTED)
2704                   if (gamma_table != NULL)
2705                   {
2706                      sp = row;
2707                      shift = 4;
2708                      for (i = 0; i < row_width; i++)
2709                      {
2710                         if ((png_uint_16)((*sp >> shift) & 0x0f)
2711                             == trans_values->gray)
2712                         {
2713                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
2714                            *sp |= (png_byte)(background->gray << shift);
2715                         }
2716                         else
2717                         {
2718                            png_byte p = (png_byte)((*sp >> shift) & 0x0f);
2719                            png_byte g = (png_byte)((gamma_table[p |
2720                              (p << 4)] >> 4) & 0x0f);
2721                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
2722                            *sp |= (png_byte)(g << shift);
2723                         }
2724                         if (!shift)
2725                         {
2726                            shift = 4;
2727                            sp++;
2728                         }
2729                         else
2730                            shift -= 4;
2731                      }
2732                   }
2733                   else
2734 #endif
2735                   {
2736                      sp = row;
2737                      shift = 4;
2738                      for (i = 0; i < row_width; i++)
2739                      {
2740                         if ((png_uint_16)((*sp >> shift) & 0x0f)
2741                             == trans_values->gray)
2742                         {
2743                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
2744                            *sp |= (png_byte)(background->gray << shift);
2745                         }
2746                         if (!shift)
2747                         {
2748                            shift = 4;
2749                            sp++;
2750                         }
2751                         else
2752                            shift -= 4;
2753                      }
2754                   }
2755                   break;
2756                }
2757                case 8:
2758                {
2759 #if defined(PNG_READ_GAMMA_SUPPORTED)
2760                   if (gamma_table != NULL)
2761                   {
2762                      sp = row;
2763                      for (i = 0; i < row_width; i++, sp++)
2764                      {
2765                         if (*sp == trans_values->gray)
2766                         {
2767                            *sp = (png_byte)background->gray;
2768                         }
2769                         else
2770                         {
2771                            *sp = gamma_table[*sp];
2772                         }
2773                      }
2774                   }
2775                   else
2776 #endif
2777                   {
2778                      sp = row;
2779                      for (i = 0; i < row_width; i++, sp++)
2780                      {
2781                         if (*sp == trans_values->gray)
2782                         {
2783                            *sp = (png_byte)background->gray;
2784                         }
2785                      }
2786                   }
2787                   break;
2788                }
2789                case 16:
2790                {
2791 #if defined(PNG_READ_GAMMA_SUPPORTED)
2792                   if (gamma_16 != NULL)
2793                   {
2794                      sp = row;
2795                      for (i = 0; i < row_width; i++, sp += 2)
2796                      {
2797                         png_uint_16 v;
2798
2799                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
2800                         if (v == trans_values->gray)
2801                         {
2802                            /* background is already in screen gamma */
2803                            *sp = (png_byte)((background->gray >> 8) & 0xff);
2804                            *(sp + 1) = (png_byte)(background->gray & 0xff);
2805                         }
2806                         else
2807                         {
2808                            v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
2809                            *sp = (png_byte)((v >> 8) & 0xff);
2810                            *(sp + 1) = (png_byte)(v & 0xff);
2811                         }
2812                      }
2813                   }
2814                   else
2815 #endif
2816                   {
2817                      sp = row;
2818                      for (i = 0; i < row_width; i++, sp += 2)
2819                      {
2820                         png_uint_16 v;
2821
2822                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
2823                         if (v == trans_values->gray)
2824                         {
2825                            *sp = (png_byte)((background->gray >> 8) & 0xff);
2826                            *(sp + 1) = (png_byte)(background->gray & 0xff);
2827                         }
2828                      }
2829                   }
2830                   break;
2831                }
2832             }
2833             break;
2834          }
2835          case PNG_COLOR_TYPE_RGB:
2836          {
2837             if (row_info->bit_depth == 8)
2838             {
2839 #if defined(PNG_READ_GAMMA_SUPPORTED)
2840                if (gamma_table != NULL)
2841                {
2842                   sp = row;
2843                   for (i = 0; i < row_width; i++, sp += 3)
2844                   {
2845                      if (*sp == trans_values->red &&
2846                         *(sp + 1) == trans_values->green &&
2847                         *(sp + 2) == trans_values->blue)
2848                      {
2849                         *sp = (png_byte)background->red;
2850                         *(sp + 1) = (png_byte)background->green;
2851                         *(sp + 2) = (png_byte)background->blue;
2852                      }
2853                      else
2854                      {
2855                         *sp = gamma_table[*sp];
2856                         *(sp + 1) = gamma_table[*(sp + 1)];
2857                         *(sp + 2) = gamma_table[*(sp + 2)];
2858                      }
2859                   }
2860                }
2861                else
2862 #endif
2863                {
2864                   sp = row;
2865                   for (i = 0; i < row_width; i++, sp += 3)
2866                   {
2867                      if (*sp == trans_values->red &&
2868                         *(sp + 1) == trans_values->green &&
2869                         *(sp + 2) == trans_values->blue)
2870                      {
2871                         *sp = (png_byte)background->red;
2872                         *(sp + 1) = (png_byte)background->green;
2873                         *(sp + 2) = (png_byte)background->blue;
2874                      }
2875                   }
2876                }
2877             }
2878             else /* if (row_info->bit_depth == 16) */
2879             {
2880 #if defined(PNG_READ_GAMMA_SUPPORTED)
2881                if (gamma_16 != NULL)
2882                {
2883                   sp = row;
2884                   for (i = 0; i < row_width; i++, sp += 6)
2885                   {
2886                      png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
2887                      png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
2888                      png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
2889                      if (r == trans_values->red && g == trans_values->green &&
2890                         b == trans_values->blue)
2891                      {
2892                         /* background is already in screen gamma */
2893                         *sp = (png_byte)((background->red >> 8) & 0xff);
2894                         *(sp + 1) = (png_byte)(background->red & 0xff);
2895                         *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
2896                         *(sp + 3) = (png_byte)(background->green & 0xff);
2897                         *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
2898                         *(sp + 5) = (png_byte)(background->blue & 0xff);
2899                      }
2900                      else
2901                      {
2902                         png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
2903                         *sp = (png_byte)((v >> 8) & 0xff);
2904                         *(sp + 1) = (png_byte)(v & 0xff);
2905                         v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
2906                         *(sp + 2) = (png_byte)((v >> 8) & 0xff);
2907                         *(sp + 3) = (png_byte)(v & 0xff);
2908                         v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
2909                         *(sp + 4) = (png_byte)((v >> 8) & 0xff);
2910                         *(sp + 5) = (png_byte)(v & 0xff);
2911                      }
2912                   }
2913                }
2914                else
2915 #endif
2916                {
2917                   sp = row;
2918                   for (i = 0; i < row_width; i++, sp += 6)
2919                   {
2920                      png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));
2921                      png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
2922                      png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
2923
2924                      if (r == trans_values->red && g == trans_values->green &&
2925                         b == trans_values->blue)
2926                      {
2927                         *sp = (png_byte)((background->red >> 8) & 0xff);
2928                         *(sp + 1) = (png_byte)(background->red & 0xff);
2929                         *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
2930                         *(sp + 3) = (png_byte)(background->green & 0xff);
2931                         *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
2932                         *(sp + 5) = (png_byte)(background->blue & 0xff);
2933                      }
2934                   }
2935                }
2936             }
2937             break;
2938          }
2939          case PNG_COLOR_TYPE_GRAY_ALPHA:
2940          {
2941             if (row_info->bit_depth == 8)
2942             {
2943 #if defined(PNG_READ_GAMMA_SUPPORTED)
2944                if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
2945                    gamma_table != NULL)
2946                {
2947                   sp = row;
2948                   dp = row;
2949                   for (i = 0; i < row_width; i++, sp += 2, dp++)
2950                   {
2951                      png_uint_16 a = *(sp + 1);
2952
2953                      if (a == 0xff)
2954                      {
2955                         *dp = gamma_table[*sp];
2956                      }
2957                      else if (a == 0)
2958                      {
2959                         /* background is already in screen gamma */
2960                         *dp = (png_byte)background->gray;
2961                      }
2962                      else
2963                      {
2964                         png_byte v, w;
2965
2966                         v = gamma_to_1[*sp];
2967                         png_composite(w, v, a, background_1->gray);
2968                         *dp = gamma_from_1[w];
2969                      }
2970                   }
2971                }
2972                else
2973 #endif
2974                {
2975                   sp = row;
2976                   dp = row;
2977                   for (i = 0; i < row_width; i++, sp += 2, dp++)
2978                   {
2979                      png_byte a = *(sp + 1);
2980
2981                      if (a == 0xff)
2982                      {
2983                         *dp = *sp;
2984                      }
2985 #if defined(PNG_READ_GAMMA_SUPPORTED)
2986                      else if (a == 0)
2987                      {
2988                         *dp = (png_byte)background->gray;
2989                      }
2990                      else
2991                      {
2992                         png_composite(*dp, *sp, a, background_1->gray);
2993                      }
2994 #else
2995                      *dp = (png_byte)background->gray;
2996 #endif
2997                   }
2998                }
2999             }
3000             else /* if (png_ptr->bit_depth == 16) */
3001             {
3002 #if defined(PNG_READ_GAMMA_SUPPORTED)
3003                if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
3004                    gamma_16_to_1 != NULL)
3005                {
3006                   sp = row;
3007                   dp = row;
3008                   for (i = 0; i < row_width; i++, sp += 4, dp += 2)
3009                   {
3010                      png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
3011
3012                      if (a == (png_uint_16)0xffff)
3013                      {
3014                         png_uint_16 v;
3015
3016                         v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3017                         *dp = (png_byte)((v >> 8) & 0xff);
3018                         *(dp + 1) = (png_byte)(v & 0xff);
3019                      }
3020 #if defined(PNG_READ_GAMMA_SUPPORTED)
3021                      else if (a == 0)
3022 #else
3023                      else
3024 #endif
3025                      {
3026                         /* background is already in screen gamma */
3027                         *dp = (png_byte)((background->gray >> 8) & 0xff);
3028                         *(dp + 1) = (png_byte)(background->gray & 0xff);
3029                      }
3030 #if defined(PNG_READ_GAMMA_SUPPORTED)
3031                      else
3032                      {
3033                         png_uint_16 g, v, w;
3034
3035                         g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
3036                         png_composite_16(v, g, a, background_1->gray);
3037                         w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
3038                         *dp = (png_byte)((w >> 8) & 0xff);
3039                         *(dp + 1) = (png_byte)(w & 0xff);
3040                      }
3041 #endif
3042                   }
3043                }
3044                else
3045 #endif
3046                {
3047                   sp = row;
3048                   dp = row;
3049                   for (i = 0; i < row_width; i++, sp += 4, dp += 2)
3050                   {
3051                      png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
3052                      if (a == (png_uint_16)0xffff)
3053                      {
3054                         png_memcpy(dp, sp, 2);
3055                      }
3056 #if defined(PNG_READ_GAMMA_SUPPORTED)
3057                      else if (a == 0)
3058 #else
3059                      else
3060 #endif
3061                      {
3062                         *dp = (png_byte)((background->gray >> 8) & 0xff);
3063                         *(dp + 1) = (png_byte)(background->gray & 0xff);
3064                      }
3065 #if defined(PNG_READ_GAMMA_SUPPORTED)
3066                      else
3067                      {
3068                         png_uint_16 g, v;
3069
3070                         g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3071                         png_composite_16(v, g, a, background_1->gray);
3072                         *dp = (png_byte)((v >> 8) & 0xff);
3073                         *(dp + 1) = (png_byte)(v & 0xff);
3074                      }
3075 #endif
3076                   }
3077                }
3078             }
3079             break;
3080          }
3081          case PNG_COLOR_TYPE_RGB_ALPHA:
3082          {
3083             if (row_info->bit_depth == 8)
3084             {
3085 #if defined(PNG_READ_GAMMA_SUPPORTED)
3086                if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
3087                    gamma_table != NULL)
3088                {
3089                   sp = row;
3090                   dp = row;
3091                   for (i = 0; i < row_width; i++, sp += 4, dp += 3)
3092                   {
3093                      png_byte a = *(sp + 3);
3094
3095                      if (a == 0xff)
3096                      {
3097                         *dp = gamma_table[*sp];
3098                         *(dp + 1) = gamma_table[*(sp + 1)];
3099                         *(dp + 2) = gamma_table[*(sp + 2)];
3100                      }
3101                      else if (a == 0)
3102                      {
3103                         /* background is already in screen gamma */
3104                         *dp = (png_byte)background->red;
3105                         *(dp + 1) = (png_byte)background->green;
3106                         *(dp + 2) = (png_byte)background->blue;
3107                      }
3108                      else
3109                      {
3110                         png_byte v, w;
3111
3112                         v = gamma_to_1[*sp];
3113                         png_composite(w, v, a, background_1->red);
3114                         *dp = gamma_from_1[w];
3115                         v = gamma_to_1[*(sp + 1)];
3116                         png_composite(w, v, a, background_1->green);
3117                         *(dp + 1) = gamma_from_1[w];
3118                         v = gamma_to_1[*(sp + 2)];
3119                         png_composite(w, v, a, background_1->blue);
3120                         *(dp + 2) = gamma_from_1[w];
3121                      }
3122                   }
3123                }
3124                else
3125 #endif
3126                {
3127                   sp = row;
3128                   dp = row;
3129                   for (i = 0; i < row_width; i++, sp += 4, dp += 3)
3130                   {
3131                      png_byte a = *(sp + 3);
3132
3133                      if (a == 0xff)
3134                      {
3135                         *dp = *sp;
3136                         *(dp + 1) = *(sp + 1);
3137                         *(dp + 2) = *(sp + 2);
3138                      }
3139                      else if (a == 0)
3140                      {
3141                         *dp = (png_byte)background->red;
3142                         *(dp + 1) = (png_byte)background->green;
3143                         *(dp + 2) = (png_byte)background->blue;
3144                      }
3145                      else
3146                      {
3147                         png_composite(*dp, *sp, a, background->red);
3148                         png_composite(*(dp + 1), *(sp + 1), a,
3149                            background->green);
3150                         png_composite(*(dp + 2), *(sp + 2), a,
3151                            background->blue);
3152                      }
3153                   }
3154                }
3155             }
3156             else /* if (row_info->bit_depth == 16) */
3157             {
3158 #if defined(PNG_READ_GAMMA_SUPPORTED)
3159                if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
3160                    gamma_16_to_1 != NULL)
3161                {
3162                   sp = row;
3163                   dp = row;
3164                   for (i = 0; i < row_width; i++, sp += 8, dp += 6)
3165                   {
3166                      png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
3167                          << 8) + (png_uint_16)(*(sp + 7)));
3168                      if (a == (png_uint_16)0xffff)
3169                      {
3170                         png_uint_16 v;
3171
3172                         v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3173                         *dp = (png_byte)((v >> 8) & 0xff);
3174                         *(dp + 1) = (png_byte)(v & 0xff);
3175                         v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
3176                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
3177                         *(dp + 3) = (png_byte)(v & 0xff);
3178                         v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
3179                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
3180                         *(dp + 5) = (png_byte)(v & 0xff);
3181                      }
3182                      else if (a == 0)
3183                      {
3184                         /* background is already in screen gamma */
3185                         *dp = (png_byte)((background->red >> 8) & 0xff);
3186                         *(dp + 1) = (png_byte)(background->red & 0xff);
3187                         *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
3188                         *(dp + 3) = (png_byte)(background->green & 0xff);
3189                         *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
3190                         *(dp + 5) = (png_byte)(background->blue & 0xff);
3191                      }
3192                      else
3193                      {
3194                         png_uint_16 v, w, x;
3195
3196                         v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
3197                         png_composite_16(w, v, a, background_1->red);
3198                         x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
3199                         *dp = (png_byte)((x >> 8) & 0xff);
3200                         *(dp + 1) = (png_byte)(x & 0xff);
3201                         v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
3202                         png_composite_16(w, v, a, background_1->green);
3203                         x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
3204                         *(dp + 2) = (png_byte)((x >> 8) & 0xff);
3205                         *(dp + 3) = (png_byte)(x & 0xff);
3206                         v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
3207                         png_composite_16(w, v, a, background_1->blue);
3208                         x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
3209                         *(dp + 4) = (png_byte)((x >> 8) & 0xff);
3210                         *(dp + 5) = (png_byte)(x & 0xff);
3211                      }
3212                   }
3213                }
3214                else
3215 #endif
3216                {
3217                   sp = row;
3218                   dp = row;
3219                   for (i = 0; i < row_width; i++, sp += 8, dp += 6)
3220                   {
3221                      png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
3222                         << 8) + (png_uint_16)(*(sp + 7)));
3223                      if (a == (png_uint_16)0xffff)
3224                      {
3225                         png_memcpy(dp, sp, 6);
3226                      }
3227                      else if (a == 0)
3228                      {
3229                         *dp = (png_byte)((background->red >> 8) & 0xff);
3230                         *(dp + 1) = (png_byte)(background->red & 0xff);
3231                         *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
3232                         *(dp + 3) = (png_byte)(background->green & 0xff);
3233                         *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
3234                         *(dp + 5) = (png_byte)(background->blue & 0xff);
3235                      }
3236                      else
3237                      {
3238                         png_uint_16 v;
3239
3240                         png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3241                         png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
3242                             + *(sp + 3));
3243                         png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
3244                             + *(sp + 5));
3245
3246                         png_composite_16(v, r, a, background->red);
3247                         *dp = (png_byte)((v >> 8) & 0xff);
3248                         *(dp + 1) = (png_byte)(v & 0xff);
3249                         png_composite_16(v, g, a, background->green);
3250                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
3251                         *(dp + 3) = (png_byte)(v & 0xff);
3252                         png_composite_16(v, b, a, background->blue);
3253                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
3254                         *(dp + 5) = (png_byte)(v & 0xff);
3255                      }
3256                   }
3257                }
3258             }
3259             break;
3260          }
3261       }
3262
3263       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
3264       {
3265          row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
3266          row_info->channels--;
3267          row_info->pixel_depth = (png_byte)(row_info->channels *
3268             row_info->bit_depth);
3269          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
3270       }
3271    }
3272 }
3273 #endif
3274
3275 #if defined(PNG_READ_GAMMA_SUPPORTED)
3276 /* Gamma correct the image, avoiding the alpha channel.  Make sure
3277  * you do this after you deal with the transparency issue on grayscale
3278  * or RGB images. If your bit depth is 8, use gamma_table, if it
3279  * is 16, use gamma_16_table and gamma_shift.  Build these with
3280  * build_gamma_table().
3281  */
3282 void /* PRIVATE */
3283 png_do_gamma(png_row_infop row_info, png_bytep row,
3284    png_bytep gamma_table, png_uint_16pp gamma_16_table,
3285    int gamma_shift)
3286 {
3287    png_bytep sp;
3288    png_uint_32 i;
3289    png_uint_32 row_width=row_info->width;
3290
3291    png_debug(1, "in png_do_gamma\n");
3292    if (
3293 #if defined(PNG_USELESS_TESTS_SUPPORTED)
3294        row != NULL && row_info != NULL &&
3295 #endif
3296        ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
3297         (row_info->bit_depth == 16 && gamma_16_table != NULL)))
3298    {
3299       switch (row_info->color_type)
3300       {
3301          case PNG_COLOR_TYPE_RGB:
3302          {
3303             if (row_info->bit_depth == 8)
3304             {
3305                sp = row;
3306                for (i = 0; i < row_width; i++)
3307                {
3308                   *sp = gamma_table[*sp];
3309                   sp++;
3310                   *sp = gamma_table[*sp];
3311                   sp++;
3312                   *sp = gamma_table[*sp];
3313                   sp++;
3314                }
3315             }
3316             else /* if (row_info->bit_depth == 16) */
3317             {
3318                sp = row;
3319                for (i = 0; i < row_width; i++)
3320                {
3321                   png_uint_16 v;
3322
3323                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3324                   *sp = (png_byte)((v >> 8) & 0xff);
3325                   *(sp + 1) = (png_byte)(v & 0xff);
3326                   sp += 2;
3327                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3328                   *sp = (png_byte)((v >> 8) & 0xff);
3329                   *(sp + 1) = (png_byte)(v & 0xff);
3330                   sp += 2;
3331                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3332                   *sp = (png_byte)((v >> 8) & 0xff);
3333                   *(sp + 1) = (png_byte)(v & 0xff);
3334                   sp += 2;
3335                }
3336             }
3337             break;
3338          }
3339          case PNG_COLOR_TYPE_RGB_ALPHA:
3340          {
3341             if (row_info->bit_depth == 8)
3342             {
3343                sp = row;
3344                for (i = 0; i < row_width; i++)
3345                {
3346                   *sp = gamma_table[*sp];
3347                   sp++;
3348                   *sp = gamma_table[*sp];
3349                   sp++;
3350                   *sp = gamma_table[*sp];
3351                   sp++;
3352                   sp++;
3353                }
3354             }
3355             else /* if (row_info->bit_depth == 16) */
3356             {
3357                sp = row;
3358                for (i = 0; i < row_width; i++)
3359                {
3360                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3361                   *sp = (png_byte)((v >> 8) & 0xff);
3362                   *(sp + 1) = (png_byte)(v & 0xff);
3363                   sp += 2;
3364                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3365                   *sp = (png_byte)((v >> 8) & 0xff);
3366                   *(sp + 1) = (png_byte)(v & 0xff);
3367                   sp += 2;
3368                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3369                   *sp = (png_byte)((v >> 8) & 0xff);
3370                   *(sp + 1) = (png_byte)(v & 0xff);
3371                   sp += 4;
3372                }
3373             }
3374             break;
3375          }
3376          case PNG_COLOR_TYPE_GRAY_ALPHA:
3377          {
3378             if (row_info->bit_depth == 8)
3379             {
3380                sp = row;
3381                for (i = 0; i < row_width; i++)
3382                {
3383                   *sp = gamma_table[*sp];
3384                   sp += 2;
3385                }
3386             }
3387             else /* if (row_info->bit_depth == 16) */
3388             {
3389                sp = row;
3390                for (i = 0; i < row_width; i++)
3391                {
3392                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3393                   *sp = (png_byte)((v >> 8) & 0xff);
3394                   *(sp + 1) = (png_byte)(v & 0xff);
3395                   sp += 4;
3396                }
3397             }
3398             break;
3399          }
3400          case PNG_COLOR_TYPE_GRAY:
3401          {
3402             if (row_info->bit_depth == 2)
3403             {
3404                sp = row;
3405                for (i = 0; i < row_width; i += 4)
3406                {
3407                   int a = *sp & 0xc0;
3408                   int b = *sp & 0x30;
3409                   int c = *sp & 0x0c;
3410                   int d = *sp & 0x03;
3411
3412                   *sp = (png_byte)(
3413                         ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|
3414                         ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
3415                         ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
3416                         ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
3417                   sp++;
3418                }
3419             }
3420             if (row_info->bit_depth == 4)
3421             {
3422                sp = row;
3423                for (i = 0; i < row_width; i += 2)
3424                {
3425                   int msb = *sp & 0xf0;
3426                   int lsb = *sp & 0x0f;
3427
3428                   *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
3429                           | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
3430                   sp++;
3431                }
3432             }
3433             else if (row_info->bit_depth == 8)
3434             {
3435                sp = row;
3436                for (i = 0; i < row_width; i++)
3437                {
3438                   *sp = gamma_table[*sp];
3439                   sp++;
3440                }
3441             }
3442             else if (row_info->bit_depth == 16)
3443             {
3444                sp = row;
3445                for (i = 0; i < row_width; i++)
3446                {
3447                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3448                   *sp = (png_byte)((v >> 8) & 0xff);
3449                   *(sp + 1) = (png_byte)(v & 0xff);
3450                   sp += 2;
3451                }
3452             }
3453             break;
3454          }
3455       }
3456    }
3457 }
3458 #endif
3459
3460 #if defined(PNG_READ_EXPAND_SUPPORTED)
3461 /* Expands a palette row to an RGB or RGBA row depending
3462  * upon whether you supply trans and num_trans.
3463  */
3464 void /* PRIVATE */
3465 png_do_expand_palette(png_row_infop row_info, png_bytep row,
3466    png_colorp palette, png_bytep trans, int num_trans)
3467 {
3468    int shift, value;
3469    png_bytep sp, dp;
3470    png_uint_32 i;
3471    png_uint_32 row_width=row_info->width;
3472
3473    png_debug(1, "in png_do_expand_palette\n");
3474    if (
3475 #if defined(PNG_USELESS_TESTS_SUPPORTED)
3476        row != NULL && row_info != NULL &&
3477 #endif
3478        row_info->color_type == PNG_COLOR_TYPE_PALETTE)
3479    {
3480       if (row_info->bit_depth < 8)
3481       {
3482          switch (row_info->bit_depth)
3483          {
3484             case 1:
3485             {
3486                sp = row + (png_size_t)((row_width - 1) >> 3);
3487                dp = row + (png_size_t)row_width - 1;
3488                shift = 7 - (int)((row_width + 7) & 0x07);
3489                for (i = 0; i < row_width; i++)
3490                {
3491                   if ((*sp >> shift) & 0x01)
3492                      *dp = 1;
3493                   else
3494                      *dp = 0;
3495                   if (shift == 7)
3496                   {
3497                      shift = 0;
3498                      sp--;
3499                   }
3500                   else
3501                      shift++;
3502
3503                   dp--;
3504                }
3505                break;
3506             }
3507             case 2:
3508             {
3509                sp = row + (png_size_t)((row_width - 1) >> 2);
3510                dp = row + (png_size_t)row_width - 1;
3511                shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
3512                for (i = 0; i < row_width; i++)
3513                {
3514                   value = (*sp >> shift) & 0x03;
3515                   *dp = (png_byte)value;
3516                   if (shift == 6)
3517                   {
3518                      shift = 0;
3519                      sp--;
3520                   }
3521                   else
3522                      shift += 2;
3523
3524                   dp--;
3525                }
3526                break;
3527             }
3528             case 4:
3529             {
3530                sp = row + (png_size_t)((row_width - 1) >> 1);
3531                dp = row + (png_size_t)row_width - 1;
3532                shift = (int)((row_width & 0x01) << 2);
3533                for (i = 0; i < row_width; i++)
3534                {
3535                   value = (*sp >> shift) & 0x0f;
3536                   *dp = (png_byte)value;
3537                   if (shift == 4)
3538                   {
3539                      shift = 0;
3540                      sp--;
3541                   }
3542                   else
3543                      shift += 4;
3544
3545                   dp--;
3546                }
3547                break;
3548             }
3549          }
3550          row_info->bit_depth = 8;
3551          row_info->pixel_depth = 8;
3552          row_info->rowbytes = row_width;
3553       }
3554       switch (row_info->bit_depth)
3555       {
3556          case 8:
3557          {
3558             if (trans != NULL)
3559             {
3560                sp = row + (png_size_t)row_width - 1;
3561                dp = row + (png_size_t)(row_width << 2) - 1;
3562
3563                for (i = 0; i < row_width; i++)
3564                {
3565                   if ((int)(*sp) >= num_trans)
3566                      *dp-- = 0xff;
3567                   else
3568                      *dp-- = trans[*sp];
3569                   *dp-- = palette[*sp].blue;
3570                   *dp-- = palette[*sp].green;
3571                   *dp-- = palette[*sp].red;
3572                   sp--;
3573                }
3574                row_info->bit_depth = 8;
3575                row_info->pixel_depth = 32;
3576                row_info->rowbytes = row_width * 4;
3577                row_info->color_type = 6;
3578                row_info->channels = 4;
3579             }
3580             else
3581             {
3582                sp = row + (png_size_t)row_width - 1;
3583                dp = row + (png_size_t)(row_width * 3) - 1;
3584
3585                for (i = 0; i < row_width; i++)
3586                {
3587                   *dp-- = palette[*sp].blue;
3588                   *dp-- = palette[*sp].green;
3589                   *dp-- = palette[*sp].red;
3590                   sp--;
3591                }
3592                row_info->bit_depth = 8;
3593                row_info->pixel_depth = 24;
3594                row_info->rowbytes = row_width * 3;
3595                row_info->color_type = 2;
3596                row_info->channels = 3;
3597             }
3598             break;
3599          }
3600       }
3601    }
3602 }
3603
3604 /* If the bit depth < 8, it is expanded to 8.  Also, if the
3605  * transparency value is supplied, an alpha channel is built.
3606  */
3607 void /* PRIVATE */
3608 png_do_expand(png_row_infop row_info, png_bytep row,
3609    png_color_16p trans_value)
3610 {
3611    int shift, value;
3612    png_bytep sp, dp;
3613    png_uint_32 i;
3614    png_uint_32 row_width=row_info->width;
3615
3616    png_debug(1, "in png_do_expand\n");
3617 #if defined(PNG_USELESS_TESTS_SUPPORTED)
3618    if (row != NULL && row_info != NULL)
3619 #endif
3620    {
3621       if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
3622       {
3623          png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
3624
3625          if (row_info->bit_depth < 8)
3626          {
3627             switch (row_info->bit_depth)
3628             {
3629                case 1:
3630                {
3631                   gray = (png_uint_16)(gray*0xff);
3632                   sp = row + (png_size_t)((row_width - 1) >> 3);
3633                   dp = row + (png_size_t)row_width - 1;
3634                   shift = 7 - (int)((row_width + 7) & 0x07);
3635                   for (i = 0; i < row_width; i++)
3636                   {
3637                      if ((*sp >> shift) & 0x01)
3638                         *dp = 0xff;
3639                      else
3640                         *dp = 0;
3641                      if (shift == 7)
3642                      {
3643                         shift = 0;
3644                         sp--;
3645                      }
3646                      else
3647                         shift++;
3648
3649                      dp--;
3650                   }
3651                   break;
3652                }
3653                case 2:
3654                {
3655                   gray = (png_uint_16)(gray*0x55);
3656                   sp = row + (png_size_t)((row_width - 1) >> 2);
3657                   dp = row + (png_size_t)row_width - 1;
3658                   shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
3659                   for (i = 0; i < row_width; i++)
3660                   {
3661                      value = (*sp >> shift) & 0x03;
3662                      *dp = (png_byte)(value | (value << 2) | (value << 4) |
3663                         (value << 6));
3664                      if (shift == 6)
3665                      {
3666                         shift = 0;
3667                         sp--;
3668                      }
3669                      else
3670                         shift += 2;
3671
3672                      dp--;
3673                   }
3674                   break;
3675                }
3676                case 4:
3677                {
3678                   gray = (png_uint_16)(gray*0x11);
3679                   sp = row + (png_size_t)((row_width - 1) >> 1);
3680                   dp = row + (png_size_t)row_width - 1;
3681                   shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
3682                   for (i = 0; i < row_width; i++)
3683                   {
3684                      value = (*sp >> shift) & 0x0f;
3685                      *dp = (png_byte)(value | (value << 4));
3686                      if (shift == 4)
3687                      {
3688                         shift = 0;
3689                         sp--;
3690                      }
3691                      else
3692                         shift = 4;
3693
3694                      dp--;
3695                   }
3696                   break;
3697                }
3698             }
3699             row_info->bit_depth = 8;
3700             row_info->pixel_depth = 8;
3701             row_info->rowbytes = row_width;
3702          }
3703
3704          if (trans_value != NULL)
3705          {
3706             if (row_info->bit_depth == 8)
3707             {
3708                sp = row + (png_size_t)row_width - 1;
3709                dp = row + (png_size_t)(row_width << 1) - 1;
3710                for (i = 0; i < row_width; i++)
3711                {
3712                   if (*sp == gray)
3713                      *dp-- = 0;
3714                   else
3715                      *dp-- = 0xff;
3716                   *dp-- = *sp--;
3717                }
3718             }
3719             else if (row_info->bit_depth == 16)
3720             {
3721                sp = row + row_info->rowbytes - 1;
3722                dp = row + (row_info->rowbytes << 1) - 1;
3723                for (i = 0; i < row_width; i++)
3724                {
3725                   if (((png_uint_16)*(sp) |
3726                      ((png_uint_16)*(sp - 1) << 8)) == gray)
3727                   {
3728                      *dp-- = 0;
3729                      *dp-- = 0;
3730                   }
3731                   else
3732                   {
3733                      *dp-- = 0xff;
3734                      *dp-- = 0xff;
3735                   }
3736                   *dp-- = *sp--;
3737                   *dp-- = *sp--;
3738                }
3739             }
3740             row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
3741             row_info->channels = 2;
3742             row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
3743             row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
3744                row_width);
3745          }
3746       }
3747       else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
3748       {
3749          if (row_info->bit_depth == 8)
3750          {
3751             sp = row + (png_size_t)row_info->rowbytes - 1;
3752             dp = row + (png_size_t)(row_width << 2) - 1;
3753             for (i = 0; i < row_width; i++)
3754             {
3755                if (*(sp - 2) == trans_value->red &&
3756                   *(sp - 1) == trans_value->green &&
3757                   *(sp - 0) == trans_value->blue)
3758                   *dp-- = 0;
3759                else
3760                   *dp-- = 0xff;
3761                *dp-- = *sp--;
3762                *dp-- = *sp--;
3763                *dp-- = *sp--;
3764             }
3765          }
3766          else if (row_info->bit_depth == 16)
3767          {
3768             sp = row + row_info->rowbytes - 1;
3769             dp = row + (png_size_t)(row_width << 3) - 1;
3770             for (i = 0; i < row_width; i++)
3771             {
3772                if ((((png_uint_16)*(sp - 4) |
3773                   ((png_uint_16)*(sp - 5) << 8)) == trans_value->red) &&
3774                   (((png_uint_16)*(sp - 2) |
3775                   ((png_uint_16)*(sp - 3) << 8)) == trans_value->green) &&
3776                   (((png_uint_16)*(sp - 0) |
3777                   ((png_uint_16)*(sp - 1) << 8)) == trans_value->blue))
3778                {
3779                   *dp-- = 0;
3780                   *dp-- = 0;
3781                }
3782                else
3783                {
3784                   *dp-- = 0xff;
3785                   *dp-- = 0xff;
3786                }
3787                *dp-- = *sp--;
3788                *dp-- = *sp--;
3789                *dp-- = *sp--;
3790                *dp-- = *sp--;
3791                *dp-- = *sp--;
3792                *dp-- = *sp--;
3793             }
3794          }
3795          row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
3796          row_info->channels = 4;
3797          row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
3798          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
3799       }
3800    }
3801 }
3802 #endif
3803
3804 #if defined(PNG_READ_DITHER_SUPPORTED)
3805 void /* PRIVATE */
3806 png_do_dither(png_row_infop row_info, png_bytep row,
3807     png_bytep palette_lookup, png_bytep dither_lookup)
3808 {
3809    png_bytep sp, dp;
3810    png_uint_32 i;
3811    png_uint_32 row_width=row_info->width;
3812
3813    png_debug(1, "in png_do_dither\n");
3814 #if defined(PNG_USELESS_TESTS_SUPPORTED)
3815    if (row != NULL && row_info != NULL)
3816 #endif
3817    {
3818       if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
3819          palette_lookup && row_info->bit_depth == 8)
3820       {
3821          int r, g, b, p;
3822          sp = row;
3823          dp = row;
3824          for (i = 0; i < row_width; i++)
3825          {
3826             r = *sp++;
3827             g = *sp++;
3828             b = *sp++;
3829
3830             /* this looks real messy, but the compiler will reduce
3831                it down to a reasonable formula.  For example, with
3832                5 bits per color, we get:
3833                p = (((r >> 3) & 0x1f) << 10) |
3834                   (((g >> 3) & 0x1f) << 5) |
3835                   ((b >> 3) & 0x1f);
3836                */
3837             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
3838                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
3839                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
3840                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
3841                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
3842                (PNG_DITHER_BLUE_BITS)) |
3843                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
3844                ((1 << PNG_DITHER_BLUE_BITS) - 1));
3845
3846             *dp++ = palette_lookup[p];
3847          }
3848          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
3849          row_info->channels = 1;
3850          row_info->pixel_depth = row_info->bit_depth;
3851          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
3852       }
3853       else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
3854          palette_lookup != NULL && row_info->bit_depth == 8)
3855       {
3856          int r, g, b, p;
3857          sp = row;
3858          dp = row;
3859          for (i = 0; i < row_width; i++)
3860          {
3861             r = *sp++;
3862             g = *sp++;
3863             b = *sp++;
3864             sp++;
3865
3866             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
3867                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
3868                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
3869                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
3870                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
3871                (PNG_DITHER_BLUE_BITS)) |
3872                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
3873                ((1 << PNG_DITHER_BLUE_BITS) - 1));
3874
3875             *dp++ = palette_lookup[p];
3876          }
3877          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
3878          row_info->channels = 1;
3879          row_info->pixel_depth = row_info->bit_depth;
3880          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);
3881       }
3882       else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
3883          dither_lookup && row_info->bit_depth == 8)
3884       {
3885          sp = row;
3886          for (i = 0; i < row_width; i++, sp++)
3887          {
3888             *sp = dither_lookup[*sp];
3889          }
3890       }
3891    }
3892 }
3893 #endif
3894
3895 #ifdef PNG_FLOATING_POINT_SUPPORTED
3896 #if defined(PNG_READ_GAMMA_SUPPORTED)
3897 static int png_gamma_shift[] =
3898    {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0};
3899
3900 /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
3901  * tables, we don't make a full table if we are reducing to 8-bit in
3902  * the future.  Note also how the gamma_16 tables are segmented so that
3903  * we don't need to allocate > 64K chunks for a full 16-bit table.
3904  */
3905 void /* PRIVATE */
3906 png_build_gamma_table(png_structp png_ptr)
3907 {
3908   png_debug(1, "in png_build_gamma_table\n");
3909   if(png_ptr->gamma != 0.0)
3910   {
3911    if (png_ptr->bit_depth <= 8)
3912    {
3913       int i;
3914       double g;
3915
3916       if (png_ptr->screen_gamma > .000001)
3917          g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
3918       else
3919          g = 1.0;
3920
3921       png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
3922          (png_uint_32)256);
3923
3924       for (i = 0; i < 256; i++)
3925       {
3926          png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
3927             g) * 255.0 + .5);
3928       }
3929
3930 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
3931     defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
3932       if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
3933       {
3934
3935          g = 1.0 / (png_ptr->gamma);
3936
3937          png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
3938             (png_uint_32)256);
3939
3940          for (i = 0; i < 256; i++)
3941          {
3942             png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
3943                g) * 255.0 + .5);
3944          }
3945
3946
3947          png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
3948             (png_uint_32)256);
3949
3950          if(png_ptr->screen_gamma > 0.000001)
3951             g = 1.0 / png_ptr->screen_gamma;
3952          else
3953             g = png_ptr->gamma;   /* probably doing rgb_to_gray */
3954
3955          for (i = 0; i < 256; i++)
3956          {
3957             png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
3958                g) * 255.0 + .5);
3959
3960          }
3961       }
3962 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
3963    }
3964    else
3965    {
3966       double g;
3967       int i, j, shift, num;
3968       int sig_bit;
3969       png_uint_32 ig;
3970
3971       if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
3972       {
3973          sig_bit = (int)png_ptr->sig_bit.red;
3974          if ((int)png_ptr->sig_bit.green > sig_bit)
3975             sig_bit = png_ptr->sig_bit.green;
3976          if ((int)png_ptr->sig_bit.blue > sig_bit)
3977             sig_bit = png_ptr->sig_bit.blue;
3978       }
3979       else
3980       {
3981          sig_bit = (int)png_ptr->sig_bit.gray;
3982       }
3983
3984       if (sig_bit > 0)
3985          shift = 16 - sig_bit;
3986       else
3987          shift = 0;
3988
3989       if (png_ptr->transformations & PNG_16_TO_8)
3990       {
3991          if (shift < (16 - PNG_MAX_GAMMA_8))
3992             shift = (16 - PNG_MAX_GAMMA_8);
3993       }
3994
3995       if (shift > 8)
3996          shift = 8;
3997       if (shift < 0)
3998          shift = 0;
3999
4000       png_ptr->gamma_shift = (png_byte)shift;
4001
4002       num = (1 << (8 - shift));
4003
4004       if (png_ptr->screen_gamma > .000001)
4005          g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
4006       else
4007          g = 1.0;
4008
4009       png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
4010          (png_uint_32)(num * png_sizeof (png_uint_16p)));
4011
4012       if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
4013       {
4014          double fin, fout;
4015          png_uint_32 last, max;
4016
4017          for (i = 0; i < num; i++)
4018          {
4019             png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
4020                (png_uint_32)(256 * png_sizeof (png_uint_16)));
4021          }
4022
4023          g = 1.0 / g;
4024          last = 0;
4025          for (i = 0; i < 256; i++)
4026          {
4027             fout = ((double)i + 0.5) / 256.0;
4028             fin = pow(fout, g);
4029             max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
4030             while (last <= max)
4031             {
4032                png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
4033                   [(int)(last >> (8 - shift))] = (png_uint_16)(
4034                   (png_uint_16)i | ((png_uint_16)i << 8));
4035                last++;
4036             }
4037          }
4038          while (last < ((png_uint_32)num << 8))
4039          {
4040             png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
4041                [(int)(last >> (8 - shift))] = (png_uint_16)65535L;
4042             last++;
4043          }
4044       }
4045       else
4046       {
4047          for (i = 0; i < num; i++)
4048          {
4049             png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
4050                (png_uint_32)(256 * png_sizeof (png_uint_16)));
4051
4052             ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
4053             for (j = 0; j < 256; j++)
4054             {
4055                png_ptr->gamma_16_table[i][j] =
4056                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
4057                      65535.0, g) * 65535.0 + .5);
4058             }
4059          }
4060       }
4061
4062 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4063     defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4064       if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
4065       {
4066
4067          g = 1.0 / (png_ptr->gamma);
4068
4069          png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
4070             (png_uint_32)(num * png_sizeof (png_uint_16p )));
4071
4072          for (i = 0; i < num; i++)
4073          {
4074             png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
4075                (png_uint_32)(256 * png_sizeof (png_uint_16)));
4076
4077             ig = (((png_uint_32)i *
4078                (png_uint_32)png_gamma_shift[shift]) >> 4);
4079             for (j = 0; j < 256; j++)
4080             {
4081                png_ptr->gamma_16_to_1[i][j] =
4082                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
4083                      65535.0, g) * 65535.0 + .5);
4084             }
4085          }
4086
4087          if(png_ptr->screen_gamma > 0.000001)
4088             g = 1.0 / png_ptr->screen_gamma;
4089          else
4090             g = png_ptr->gamma;   /* probably doing rgb_to_gray */
4091
4092          png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
4093             (png_uint_32)(num * png_sizeof (png_uint_16p)));
4094
4095          for (i = 0; i < num; i++)
4096          {
4097             png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
4098                (png_uint_32)(256 * png_sizeof (png_uint_16)));
4099
4100             ig = (((png_uint_32)i *
4101                (png_uint_32)png_gamma_shift[shift]) >> 4);
4102             for (j = 0; j < 256; j++)
4103             {
4104                png_ptr->gamma_16_from_1[i][j] =
4105                   (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
4106                      65535.0, g) * 65535.0 + .5);
4107             }
4108          }
4109       }
4110 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
4111    }
4112  }
4113 }
4114 #endif
4115 /* To do: install integer version of png_build_gamma_table here */
4116 #endif
4117
4118 #if defined(PNG_MNG_FEATURES_SUPPORTED)
4119 /* undoes intrapixel differencing  */
4120 void /* PRIVATE */
4121 png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
4122 {
4123    png_debug(1, "in png_do_read_intrapixel\n");
4124    if (
4125 #if defined(PNG_USELESS_TESTS_SUPPORTED)
4126        row != NULL && row_info != NULL &&
4127 #endif
4128        (row_info->color_type & PNG_COLOR_MASK_COLOR))
4129    {
4130       int bytes_per_pixel;
4131       png_uint_32 row_width = row_info->width;
4132       if (row_info->bit_depth == 8)
4133       {
4134          png_bytep rp;
4135          png_uint_32 i;
4136
4137          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
4138             bytes_per_pixel = 3;
4139          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
4140             bytes_per_pixel = 4;
4141          else
4142             return;
4143
4144          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
4145          {
4146             *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);
4147             *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);
4148          }
4149       }
4150       else if (row_info->bit_depth == 16)
4151       {
4152          png_bytep rp;
4153          png_uint_32 i;
4154
4155          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
4156             bytes_per_pixel = 6;
4157          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
4158             bytes_per_pixel = 8;
4159          else
4160             return;
4161
4162          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
4163          {
4164             png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);
4165             png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);
4166             png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);
4167             png_uint_32 red  = (png_uint_32)((s0+s1+65536L) & 0xffffL);
4168             png_uint_32 blue = (png_uint_32)((s2+s1+65536L) & 0xffffL);
4169             *(rp  ) = (png_byte)((red >> 8) & 0xff);
4170             *(rp+1) = (png_byte)(red & 0xff);
4171             *(rp+4) = (png_byte)((blue >> 8) & 0xff);
4172             *(rp+5) = (png_byte)(blue & 0xff);
4173          }
4174       }
4175    }
4176 }
4177 #endif /* PNG_MNG_FEATURES_SUPPORTED */