开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
pngrtran.c
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：148k
源码类别：

界面编程

开发平台：

Visual C++

pngrtran.c：源码内容
  1.             png_bytep sp = row + (png_size_t)row_width - 1;
  2.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  3.             for (i = 0; i < row_width; i++)
  4.             {
  5.                *(dp--) = *sp;
  6.                *(dp--) = *sp;
  7.                *(dp--) = *(sp--);
  8.             }
  9.          }
  10.          else
  11.          {
  12.             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
  13.             png_bytep dp = sp  + (png_size_t)row_width * 4;
  14.             for (i = 0; i < row_width; i++)
  15.             {
  16.                *(dp--) = *sp;
  17.                *(dp--) = *(sp - 1);
  18.                *(dp--) = *sp;
  19.                *(dp--) = *(sp - 1);
  20.                *(dp--) = *(sp--);
  21.                *(dp--) = *(sp--);
  22.             }
  23.          }
  24.       }
  25.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  26.       {
  27.          if (row_info->bit_depth == 8)
  28.          {
  29.             png_bytep sp = row + (png_size_t)row_width * 2 - 1;
  30.             png_bytep dp = sp  + (png_size_t)row_width * 2;
  31.             for (i = 0; i < row_width; i++)
  32.             {
  33.                *(dp--) = *(sp--);
  34.                *(dp--) = *sp;
  35.                *(dp--) = *sp;
  36.                *(dp--) = *(sp--);
  37.             }
  38.          }
  39.          else
  40.          {
  41.             png_bytep sp = row + (png_size_t)row_width * 4 - 1;
  42.             png_bytep dp = sp  + (png_size_t)row_width * 4;
  43.             for (i = 0; i < row_width; i++)
  44.             {
  45.                *(dp--) = *(sp--);
  46.                *(dp--) = *(sp--);
  47.                *(dp--) = *sp;
  48.                *(dp--) = *(sp - 1);
  49.                *(dp--) = *sp;
  50.                *(dp--) = *(sp - 1);
  51.                *(dp--) = *(sp--);
  52.                *(dp--) = *(sp--);
  53.             }
  54.          }
  55.       }
  56.       row_info->channels += (png_byte)2;
  57.       row_info->color_type |= PNG_COLOR_MASK_COLOR;
  58.       row_info->pixel_depth = (png_byte)(row_info->channels *
  59.          row_info->bit_depth);
  60.       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  61.    }
  62. }
  63. #endif
  65. #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  66. /* reduce RGB files to grayscale, with or without alpha
  67.  * using the equation given in Poynton's ColorFAQ at
  68.  * <http://www.inforamp.net/~poynton/>  (THIS LINK IS DEAD June 2008)
  69.  * New link:
  70.  * <http://www.poynton.com/notes/colour_and_gamma/>
  71.  * Charles Poynton poynton at poynton.com
  72.  *
  73.  *     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
  74.  *
  75.  *  We approximate this with
  76.  *
  77.  *     Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B
  78.  *
  79.  *  which can be expressed with integers as
  80.  *
  81.  *     Y = (6969 * R + 23434 * G + 2365 * B)/32768
  82.  *
  83.  *  The calculation is to be done in a linear colorspace.
  84.  *
  85.  *  Other integer coefficents can be used via png_set_rgb_to_gray().
  86.  */
  87. int /* PRIVATE */
  88. png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
  90. {
  91.    png_uint_32 i;
  93.    png_uint_32 row_width = row_info->width;
  94.    int rgb_error = 0;
  96.    png_debug(1, "in png_do_rgb_to_gray");
  97.    if (
  98. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  99.        row != NULL && row_info != NULL &&
  100. #endif
  101.       (row_info->color_type & PNG_COLOR_MASK_COLOR))
  102.    {
  103.       png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
  104.       png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
  105.       png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
  107.       if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  108.       {
  109.          if (row_info->bit_depth == 8)
  110.          {
  111. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  112.             if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
  113.             {
  114.                png_bytep sp = row;
  115.                png_bytep dp = row;
  117.                for (i = 0; i < row_width; i++)
  118.                {
  119.                   png_byte red   = png_ptr->gamma_to_1[*(sp++)];
  120.                   png_byte green = png_ptr->gamma_to_1[*(sp++)];
  121.                   png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
  122.                   if (red != green || red != blue)
  123.                   {
  124.                      rgb_error |= 1;
  125.                      *(dp++) = png_ptr->gamma_from_1[
  126.                        (rc*red + gc*green + bc*blue)>>15];
  127.                   }
  128.                   else
  129.                      *(dp++) = *(sp - 1);
  130.                }
  131.             }
  132.             else
  133. #endif
  134.             {
  135.                png_bytep sp = row;
  136.                png_bytep dp = row;
  137.                for (i = 0; i < row_width; i++)
  138.                {
  139.                   png_byte red   = *(sp++);
  140.                   png_byte green = *(sp++);
  141.                   png_byte blue  = *(sp++);
  142.                   if (red != green || red != blue)
  143.                   {
  144.                      rgb_error |= 1;
  145.                      *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
  146.                   }
  147.                   else
  148.                      *(dp++) = *(sp - 1);
  149.                }
  150.             }
  151.          }
  153.          else /* RGB bit_depth == 16 */
  154.          {
  155. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  156.             if (png_ptr->gamma_16_to_1 != NULL &&
  157.                 png_ptr->gamma_16_from_1 != NULL)
  158.             {
  159.                png_bytep sp = row;
  160.                png_bytep dp = row;
  161.                for (i = 0; i < row_width; i++)
  162.                {
  163.                   png_uint_16 red, green, blue, w;
  165.                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  166.                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  167.                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  169.                   if (red == green && red == blue)
  170.                      w = red;
  171.                   else
  172.                   {
  173.                      png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
  174.                                   png_ptr->gamma_shift][red>>8];
  175.                      png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
  176.                                   png_ptr->gamma_shift][green>>8];
  177.                      png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
  178.                                   png_ptr->gamma_shift][blue>>8];
  179.                      png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1
  180.                                   + bc*blue_1)>>15);
  181.                      w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
  182.                          png_ptr->gamma_shift][gray16 >> 8];
  183.                      rgb_error |= 1;
  184.                   }
  186.                   *(dp++) = (png_byte)((w>>8) & 0xff);
  187.                   *(dp++) = (png_byte)(w & 0xff);
  188.                }
  189.             }
  190.             else
  191. #endif
  192.             {
  193.                png_bytep sp = row;
  194.                png_bytep dp = row;
  195.                for (i = 0; i < row_width; i++)
  196.                {
  197.                   png_uint_16 red, green, blue, gray16;
  199.                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  200.                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  201.                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  203.                   if (red != green || red != blue)
  204.                      rgb_error |= 1;
  205.                   gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
  206.                   *(dp++) = (png_byte)((gray16>>8) & 0xff);
  207.                   *(dp++) = (png_byte)(gray16 & 0xff);
  208.                }
  209.             }
  210.          }
  211.       }
  212.       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  213.       {
  214.          if (row_info->bit_depth == 8)
  215.          {
  216. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  217.             if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
  218.             {
  219.                png_bytep sp = row;
  220.                png_bytep dp = row;
  221.                for (i = 0; i < row_width; i++)
  222.                {
  223.                   png_byte red   = png_ptr->gamma_to_1[*(sp++)];
  224.                   png_byte green = png_ptr->gamma_to_1[*(sp++)];
  225.                   png_byte blue  = png_ptr->gamma_to_1[*(sp++)];
  226.                   if (red != green || red != blue)
  227.                      rgb_error |= 1;
  228.                   *(dp++) =  png_ptr->gamma_from_1
  229.                              [(rc*red + gc*green + bc*blue)>>15];
  230.                   *(dp++) = *(sp++);  /* alpha */
  231.                }
  232.             }
  233.             else
  234. #endif
  235.             {
  236.                png_bytep sp = row;
  237.                png_bytep dp = row;
  238.                for (i = 0; i < row_width; i++)
  239.                {
  240.                   png_byte red   = *(sp++);
  241.                   png_byte green = *(sp++);
  242.                   png_byte blue  = *(sp++);
  243.                   if (red != green || red != blue)
  244.                      rgb_error |= 1;
  245.                   *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);
  246.                   *(dp++) = *(sp++);  /* alpha */
  247.                }
  248.             }
  249.          }
  250.          else /* RGBA bit_depth == 16 */
  251.          {
  252. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  253.             if (png_ptr->gamma_16_to_1 != NULL &&
  254.                 png_ptr->gamma_16_from_1 != NULL)
  255.             {
  256.                png_bytep sp = row;
  257.                png_bytep dp = row;
  258.                for (i = 0; i < row_width; i++)
  259.                {
  260.                   png_uint_16 red, green, blue, w;
  262.                   red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  263.                   green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  264.                   blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
  266.                   if (red == green && red == blue)
  267.                      w = red;
  268.                   else
  269.                   {
  270.                      png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>
  271.                                   png_ptr->gamma_shift][red>>8];
  272.                      png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
  273.                                   png_ptr->gamma_shift][green>>8];
  274.                      png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>
  275.                                   png_ptr->gamma_shift][blue>>8];
  276.                      png_uint_16 gray16  = (png_uint_16)((rc * red_1
  277.                                   + gc * green_1 + bc * blue_1)>>15);
  278.                      w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
  279.                          png_ptr->gamma_shift][gray16 >> 8];
  280.                      rgb_error |= 1;
  281.                   }
  283.                   *(dp++) = (png_byte)((w>>8) & 0xff);
  284.                   *(dp++) = (png_byte)(w & 0xff);
  285.                   *(dp++) = *(sp++);  /* alpha */
  286.                   *(dp++) = *(sp++);
  287.                }
  288.             }
  289.             else
  290. #endif
  291.             {
  292.                png_bytep sp = row;
  293.                png_bytep dp = row;
  294.                for (i = 0; i < row_width; i++)
  295.                {
  296.                   png_uint_16 red, green, blue, gray16;
  297.                   red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
  298.                   green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
  299.                   blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
  300.                   if (red != green || red != blue)
  301.                      rgb_error |= 1;
  302.                   gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
  303.                   *(dp++) = (png_byte)((gray16>>8) & 0xff);
  304.                   *(dp++) = (png_byte)(gray16 & 0xff);
  305.                   *(dp++) = *(sp++);  /* alpha */
  306.                   *(dp++) = *(sp++);
  307.                }
  308.             }
  309.          }
  310.       }
  311.    row_info->channels -= (png_byte)2;
  312.       row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
  313.       row_info->pixel_depth = (png_byte)(row_info->channels *
  314.          row_info->bit_depth);
  315.       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  316.    }
  317.    return rgb_error;
  318. }
  319. #endif
  321. /* Build a grayscale palette.  Palette is assumed to be 1 << bit_depth
  322.  * large of png_color.  This lets grayscale images be treated as
  323.  * paletted.  Most useful for gamma correction and simplification
  324.  * of code.
  325.  */
  326. void PNGAPI
  327. png_build_grayscale_palette(int bit_depth, png_colorp palette)
  328. {
  329.    int num_palette;
  330.    int color_inc;
  331.    int i;
  332.    int v;
  334.    png_debug(1, "in png_do_build_grayscale_palette");
  335.    if (palette == NULL)
  336.       return;
  338.    switch (bit_depth)
  339.    {
  340.       case 1:
  341.          num_palette = 2;
  342.          color_inc = 0xff;
  343.          break;
  344.       case 2:
  345.          num_palette = 4;
  346.          color_inc = 0x55;
  347.          break;
  348.       case 4:
  349.          num_palette = 16;
  350.          color_inc = 0x11;
  351.          break;
  352.       case 8:
  353.          num_palette = 256;
  354.          color_inc = 1;
  355.          break;
  356.       default:
  357.          num_palette = 0;
  358.          color_inc = 0;
  359.          break;
  360.    }
  362.    for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
  363.    {
  364.       palette[i].red = (png_byte)v;
  365.       palette[i].green = (png_byte)v;
  366.       palette[i].blue = (png_byte)v;
  367.    }
  368. }
  370. /* This function is currently unused.  Do we really need it? */
  371. #if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
  372. void /* PRIVATE */
  373. png_correct_palette(png_structp png_ptr, png_colorp palette,
  374.    int num_palette)
  375. {
  376.    png_debug(1, "in png_correct_palette");
  377. #if defined(PNG_READ_BACKGROUND_SUPPORTED) && 
  378.     defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
  379.    if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
  380.    {
  381.       png_color back, back_1;
  383.       if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
  384.       {
  385.          back.red = png_ptr->gamma_table[png_ptr->background.red];
  386.          back.green = png_ptr->gamma_table[png_ptr->background.green];
  387.          back.blue = png_ptr->gamma_table[png_ptr->background.blue];
  389.          back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
  390.          back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
  391.          back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
  392.       }
  393.       else
  394.       {
  395.          double g;
  397.          g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
  399.          if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
  400.              fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
  401.          {
  402.             back.red = png_ptr->background.red;
  403.             back.green = png_ptr->background.green;
  404.             back.blue = png_ptr->background.blue;
  405.          }
  406.          else
  407.          {
  408.             back.red =
  409.                (png_byte)(pow((double)png_ptr->background.red/255, g) *
  410.                 255.0 + 0.5);
  411.             back.green =
  412.                (png_byte)(pow((double)png_ptr->background.green/255, g) *
  413.                 255.0 + 0.5);
  414.             back.blue =
  415.                (png_byte)(pow((double)png_ptr->background.blue/255, g) *
  416.                 255.0 + 0.5);
  417.          }
  419.          g = 1.0 / png_ptr->background_gamma;
  421.          back_1.red =
  422.             (png_byte)(pow((double)png_ptr->background.red/255, g) *
  423.              255.0 + 0.5);
  424.          back_1.green =
  425.             (png_byte)(pow((double)png_ptr->background.green/255, g) *
  426.              255.0 + 0.5);
  427.          back_1.blue =
  428.             (png_byte)(pow((double)png_ptr->background.blue/255, g) *
  429.              255.0 + 0.5);
  430.       }
  432.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  433.       {
  434.          png_uint_32 i;
  436.          for (i = 0; i < (png_uint_32)num_palette; i++)
  437.          {
  438.             if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
  439.             {
  440.                palette[i] = back;
  441.             }
  442.             else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
  443.             {
  444.                png_byte v, w;
  446.                v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
  447.                png_composite(w, v, png_ptr->trans[i], back_1.red);
  448.                palette[i].red = png_ptr->gamma_from_1[w];
  450.                v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
  451.                png_composite(w, v, png_ptr->trans[i], back_1.green);
  452.                palette[i].green = png_ptr->gamma_from_1[w];
  454.                v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
  455.                png_composite(w, v, png_ptr->trans[i], back_1.blue);
  456.                palette[i].blue = png_ptr->gamma_from_1[w];
  457.             }
  458.             else
  459.             {
  460.                palette[i].red = png_ptr->gamma_table[palette[i].red];
  461.                palette[i].green = png_ptr->gamma_table[palette[i].green];
  462.                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  463.             }
  464.          }
  465.       }
  466.       else
  467.       {
  468.          int i;
  470.          for (i = 0; i < num_palette; i++)
  471.          {
  472.             if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
  473.             {
  474.                palette[i] = back;
  475.             }
  476.             else
  477.             {
  478.                palette[i].red = png_ptr->gamma_table[palette[i].red];
  479.                palette[i].green = png_ptr->gamma_table[palette[i].green];
  480.                palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  481.             }
  482.          }
  483.       }
  484.    }
  485.    else
  486. #endif
  487. #if defined(PNG_READ_GAMMA_SUPPORTED)
  488.    if (png_ptr->transformations & PNG_GAMMA)
  489.    {
  490.       int i;
  492.       for (i = 0; i < num_palette; i++)
  493.       {
  494.          palette[i].red = png_ptr->gamma_table[palette[i].red];
  495.          palette[i].green = png_ptr->gamma_table[palette[i].green];
  496.          palette[i].blue = png_ptr->gamma_table[palette[i].blue];
  497.       }
  498.    }
  499. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  500.    else
  501. #endif
  502. #endif
  503. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  504.    if (png_ptr->transformations & PNG_BACKGROUND)
  505.    {
  506.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  507.       {
  508.          png_color back;
  510.          back.red   = (png_byte)png_ptr->background.red;
  511.          back.green = (png_byte)png_ptr->background.green;
  512.          back.blue  = (png_byte)png_ptr->background.blue;
  514.          for (i = 0; i < (int)png_ptr->num_trans; i++)
  515.          {
  516.             if (png_ptr->trans[i] == 0)
  517.             {
  518.                palette[i].red = back.red;
  519.                palette[i].green = back.green;
  520.                palette[i].blue = back.blue;
  521.             }
  522.             else if (png_ptr->trans[i] != 0xff)
  523.             {
  524.                png_composite(palette[i].red, png_ptr->palette[i].red,
  525.                   png_ptr->trans[i], back.red);
  526.                png_composite(palette[i].green, png_ptr->palette[i].green,
  527.                   png_ptr->trans[i], back.green);
  528.                png_composite(palette[i].blue, png_ptr->palette[i].blue,
  529.                   png_ptr->trans[i], back.blue);
  530.             }
  531.          }
  532.       }
  533.       else /* assume grayscale palette (what else could it be?) */
  534.       {
  535.          int i;
  537.          for (i = 0; i < num_palette; i++)
  538.          {
  539.             if (i == (png_byte)png_ptr->trans_values.gray)
  540.             {
  541.                palette[i].red = (png_byte)png_ptr->background.red;
  542.                palette[i].green = (png_byte)png_ptr->background.green;
  543.                palette[i].blue = (png_byte)png_ptr->background.blue;
  544.             }
  545.          }
  546.       }
  547.    }
  548. #endif
  549. }
  550. #endif
  552. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  553. /* Replace any alpha or transparency with the supplied background color.
  554.  * "background" is already in the screen gamma, while "background_1" is
  555.  * at a gamma of 1.0.  Paletted files have already been taken care of.
  556.  */
  557. void /* PRIVATE */
  558. png_do_background(png_row_infop row_info, png_bytep row,
  559.    png_color_16p trans_values, png_color_16p background
  560. #if defined(PNG_READ_GAMMA_SUPPORTED)
  561.    , png_color_16p background_1,
  562.    png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
  563.    png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
  564.    png_uint_16pp gamma_16_to_1, int gamma_shift
  565. #endif
  566.    )
  567. {
  568.    png_bytep sp, dp;
  569.    png_uint_32 i;
  570.    png_uint_32 row_width=row_info->width;
  571.    int shift;
  573.    png_debug(1, "in png_do_background");
  574.    if (background != NULL &&
  575. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  576.        row != NULL && row_info != NULL &&
  577. #endif
  578.       (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
  579.       (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
  580.    {
  581.       switch (row_info->color_type)
  582.       {
  583.          case PNG_COLOR_TYPE_GRAY:
  584.          {
  585.             switch (row_info->bit_depth)
  586.             {
  587.                case 1:
  588.                {
  589.                   sp = row;
  590.                   shift = 7;
  591.                   for (i = 0; i < row_width; i++)
  592.                   {
  593.                      if ((png_uint_16)((*sp >> shift) & 0x01)
  594.                         == trans_values->gray)
  595.                      {
  596.                         *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
  597.                         *sp |= (png_byte)(background->gray << shift);
  598.                      }
  599.                      if (!shift)
  600.                      {
  601.                         shift = 7;
  602.                         sp++;
  603.                      }
  604.                      else
  605.                         shift--;
  606.                   }
  607.                   break;
  608.                }
  609.                case 2:
  610.                {
  611. #if defined(PNG_READ_GAMMA_SUPPORTED)
  612.                   if (gamma_table != NULL)
  613.                   {
  614.                      sp = row;
  615.                      shift = 6;
  616.                      for (i = 0; i < row_width; i++)
  617.                      {
  618.                         if ((png_uint_16)((*sp >> shift) & 0x03)
  619.                             == trans_values->gray)
  620.                         {
  621.                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
  622.                            *sp |= (png_byte)(background->gray << shift);
  623.                         }
  624.                         else
  625.                         {
  626.                            png_byte p = (png_byte)((*sp >> shift) & 0x03);
  627.                            png_byte g = (png_byte)((gamma_table [p | (p << 2) |
  628.                                (p << 4) | (p << 6)] >> 6) & 0x03);
  629.                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
  630.                            *sp |= (png_byte)(g << shift);
  631.                         }
  632.                         if (!shift)
  633.                         {
  634.                            shift = 6;
  635.                            sp++;
  636.                         }
  637.                         else
  638.                            shift -= 2;
  639.                      }
  640.                   }
  641.                   else
  642. #endif
  643.                   {
  644.                      sp = row;
  645.                      shift = 6;
  646.                      for (i = 0; i < row_width; i++)
  647.                      {
  648.                         if ((png_uint_16)((*sp >> shift) & 0x03)
  649.                             == trans_values->gray)
  650.                         {
  651.                            *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
  652.                            *sp |= (png_byte)(background->gray << shift);
  653.                         }
  654.                         if (!shift)
  655.                         {
  656.                            shift = 6;
  657.                            sp++;
  658.                         }
  659.                         else
  660.                            shift -= 2;
  661.                      }
  662.                   }
  663.                   break;
  664.                }
  665.                case 4:
  666.                {
  667. #if defined(PNG_READ_GAMMA_SUPPORTED)
  668.                   if (gamma_table != NULL)
  669.                   {
  670.                      sp = row;
  671.                      shift = 4;
  672.                      for (i = 0; i < row_width; i++)
  673.                      {
  674.                         if ((png_uint_16)((*sp >> shift) & 0x0f)
  675.                             == trans_values->gray)
  676.                         {
  677.                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
  678.                            *sp |= (png_byte)(background->gray << shift);
  679.                         }
  680.                         else
  681.                         {
  682.                            png_byte p = (png_byte)((*sp >> shift) & 0x0f);
  683.                            png_byte g = (png_byte)((gamma_table[p |
  684.                              (p << 4)] >> 4) & 0x0f);
  685.                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
  686.                            *sp |= (png_byte)(g << shift);
  687.                         }
  688.                         if (!shift)
  689.                         {
  690.                            shift = 4;
  691.                            sp++;
  692.                         }
  693.                         else
  694.                            shift -= 4;
  695.                      }
  696.                   }
  697.                   else
  698. #endif
  699.                   {
  700.                      sp = row;
  701.                      shift = 4;
  702.                      for (i = 0; i < row_width; i++)
  703.                      {
  704.                         if ((png_uint_16)((*sp >> shift) & 0x0f)
  705.                             == trans_values->gray)
  706.                         {
  707.                            *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
  708.                            *sp |= (png_byte)(background->gray << shift);
  709.                         }
  710.                         if (!shift)
  711.                         {
  712.                            shift = 4;
  713.                            sp++;
  714.                         }
  715.                         else
  716.                            shift -= 4;
  717.                      }
  718.                   }
  719.                   break;
  720.                }
  721.                case 8:
  722.                {
  723. #if defined(PNG_READ_GAMMA_SUPPORTED)
  724.                   if (gamma_table != NULL)
  725.                   {
  726.                      sp = row;
  727.                      for (i = 0; i < row_width; i++, sp++)
  728.                      {
  729.                         if (*sp == trans_values->gray)
  730.                         {
  731.                            *sp = (png_byte)background->gray;
  732.                         }
  733.                         else
  734.                         {
  735.                            *sp = gamma_table[*sp];
  736.                         }
  737.                      }
  738.                   }
  739.                   else
  740. #endif
  741.                   {
  742.                      sp = row;
  743.                      for (i = 0; i < row_width; i++, sp++)
  744.                      {
  745.                         if (*sp == trans_values->gray)
  746.                         {
  747.                            *sp = (png_byte)background->gray;
  748.                         }
  749.                      }
  750.                   }
  751.                   break;
  752.                }
  753.                case 16:
  754.                {
  755. #if defined(PNG_READ_GAMMA_SUPPORTED)
  756.                   if (gamma_16 != NULL)
  757.                   {
  758.                      sp = row;
  759.                      for (i = 0; i < row_width; i++, sp += 2)
  760.                      {
  761.                         png_uint_16 v;
  763.                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
  764.                         if (v == trans_values->gray)
  765.                         {
  766.                            /* background is already in screen gamma */
  767.                            *sp = (png_byte)((background->gray >> 8) & 0xff);
  768.                            *(sp + 1) = (png_byte)(background->gray & 0xff);
  769.                         }
  770.                         else
  771.                         {
  772.                            v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
  773.                            *sp = (png_byte)((v >> 8) & 0xff);
  774.                            *(sp + 1) = (png_byte)(v & 0xff);
  775.                         }
  776.                      }
  777.                   }
  778.                   else
  779. #endif
  780.                   {
  781.                      sp = row;
  782.                      for (i = 0; i < row_width; i++, sp += 2)
  783.                      {
  784.                         png_uint_16 v;
  786.                         v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
  787.                         if (v == trans_values->gray)
  788.                         {
  789.                            *sp = (png_byte)((background->gray >> 8) & 0xff);
  790.                            *(sp + 1) = (png_byte)(background->gray & 0xff);
  791.                         }
  792.                      }
  793.                   }
  794.                   break;
  795.                }
  796.             }
  797.             break;
  798.          }
  799.          case PNG_COLOR_TYPE_RGB:
  800.          {
  801.             if (row_info->bit_depth == 8)
  802.             {
  803. #if defined(PNG_READ_GAMMA_SUPPORTED)
  804.                if (gamma_table != NULL)
  805.                {
  806.                   sp = row;
  807.                   for (i = 0; i < row_width; i++, sp += 3)
  808.                   {
  809.                      if (*sp == trans_values->red &&
  810.                         *(sp + 1) == trans_values->green &&
  811.                         *(sp + 2) == trans_values->blue)
  812.                      {
  813.                         *sp = (png_byte)background->red;
  814.                         *(sp + 1) = (png_byte)background->green;
  815.                         *(sp + 2) = (png_byte)background->blue;
  816.                      }
  817.                      else
  818.                      {
  819.                         *sp = gamma_table[*sp];
  820.                         *(sp + 1) = gamma_table[*(sp + 1)];
  821.                         *(sp + 2) = gamma_table[*(sp + 2)];
  822.                      }
  823.                   }
  824.                }
  825.                else
  826. #endif
  827.                {
  828.                   sp = row;
  829.                   for (i = 0; i < row_width; i++, sp += 3)
  830.                   {
  831.                      if (*sp == trans_values->red &&
  832.                         *(sp + 1) == trans_values->green &&
  833.                         *(sp + 2) == trans_values->blue)
  834.                      {
  835.                         *sp = (png_byte)background->red;
  836.                         *(sp + 1) = (png_byte)background->green;
  837.                         *(sp + 2) = (png_byte)background->blue;
  838.                      }
  839.                   }
  840.                }
  841.             }
  842.             else /* if (row_info->bit_depth == 16) */
  843.             {
  844. #if defined(PNG_READ_GAMMA_SUPPORTED)
  845.                if (gamma_16 != NULL)
  846.                {
  847.                   sp = row;
  848.                   for (i = 0; i < row_width; i++, sp += 6)
  849.                   {
  850.                      png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
  851.                      png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
  852.                      png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
  853.                      if (r == trans_values->red && g == trans_values->green &&
  854.                         b == trans_values->blue)
  855.                      {
  856.                         /* background is already in screen gamma */
  857.                         *sp = (png_byte)((background->red >> 8) & 0xff);
  858.                         *(sp + 1) = (png_byte)(background->red & 0xff);
  859.                         *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
  860.                         *(sp + 3) = (png_byte)(background->green & 0xff);
  861.                         *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
  862.                         *(sp + 5) = (png_byte)(background->blue & 0xff);
  863.                      }
  864.                      else
  865.                      {
  866.                         png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
  867.                         *sp = (png_byte)((v >> 8) & 0xff);
  868.                         *(sp + 1) = (png_byte)(v & 0xff);
  869.                         v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
  870.                         *(sp + 2) = (png_byte)((v >> 8) & 0xff);
  871.                         *(sp + 3) = (png_byte)(v & 0xff);
  872.                         v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
  873.                         *(sp + 4) = (png_byte)((v >> 8) & 0xff);
  874.                         *(sp + 5) = (png_byte)(v & 0xff);
  875.                      }
  876.                   }
  877.                }
  878.                else
  879. #endif
  880.                {
  881.                   sp = row;
  882.                   for (i = 0; i < row_width; i++, sp += 6)
  883.                   {
  884.                      png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));
  885.                      png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
  886.                      png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
  888.                      if (r == trans_values->red && g == trans_values->green &&
  889.                         b == trans_values->blue)
  890.                      {
  891.                         *sp = (png_byte)((background->red >> 8) & 0xff);
  892.                         *(sp + 1) = (png_byte)(background->red & 0xff);
  893.                         *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
  894.                         *(sp + 3) = (png_byte)(background->green & 0xff);
  895.                         *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
  896.                         *(sp + 5) = (png_byte)(background->blue & 0xff);
  897.                      }
  898.                   }
  899.                }
  900.             }
  901.             break;
  902.          }
  903.          case PNG_COLOR_TYPE_GRAY_ALPHA:
  904.          {
  905.             if (row_info->bit_depth == 8)
  906.             {
  907. #if defined(PNG_READ_GAMMA_SUPPORTED)
  908.                if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
  909.                    gamma_table != NULL)
  910.                {
  911.                   sp = row;
  912.                   dp = row;
  913.                   for (i = 0; i < row_width; i++, sp += 2, dp++)
  914.                   {
  915.                      png_uint_16 a = *(sp + 1);
  917.                      if (a == 0xff)
  918.                      {
  919.                         *dp = gamma_table[*sp];
  920.                      }
  921.                      else if (a == 0)
  922.                      {
  923.                         /* background is already in screen gamma */
  924.                         *dp = (png_byte)background->gray;
  925.                      }
  926.                      else
  927.                      {
  928.                         png_byte v, w;
  930.                         v = gamma_to_1[*sp];
  931.                         png_composite(w, v, a, background_1->gray);
  932.                         *dp = gamma_from_1[w];
  933.                      }
  934.                   }
  935.                }
  936.                else
  937. #endif
  938.                {
  939.                   sp = row;
  940.                   dp = row;
  941.                   for (i = 0; i < row_width; i++, sp += 2, dp++)
  942.                   {
  943.                      png_byte a = *(sp + 1);
  945.                      if (a == 0xff)
  946.                      {
  947.                         *dp = *sp;
  948.                      }
  949. #if defined(PNG_READ_GAMMA_SUPPORTED)
  950.                      else if (a == 0)
  951.                      {
  952.                         *dp = (png_byte)background->gray;
  953.                      }
  954.                      else
  955.                      {
  956.                         png_composite(*dp, *sp, a, background_1->gray);
  957.                      }
  958. #else
  959.                      *dp = (png_byte)background->gray;
  960. #endif
  961.                   }
  962.                }
  963.             }
  964.             else /* if (png_ptr->bit_depth == 16) */
  965.             {
  966. #if defined(PNG_READ_GAMMA_SUPPORTED)
  967.                if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
  968.                    gamma_16_to_1 != NULL)
  969.                {
  970.                   sp = row;
  971.                   dp = row;
  972.                   for (i = 0; i < row_width; i++, sp += 4, dp += 2)
  973.                   {
  974.                      png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
  976.                      if (a == (png_uint_16)0xffff)
  977.                      {
  978.                         png_uint_16 v;
  980.                         v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
  981.                         *dp = (png_byte)((v >> 8) & 0xff);
  982.                         *(dp + 1) = (png_byte)(v & 0xff);
  983.                      }
  984. #if defined(PNG_READ_GAMMA_SUPPORTED)
  985.                      else if (a == 0)
  986. #else
  987.                      else
  988. #endif
  989.                      {
  990.                         /* background is already in screen gamma */
  991.                         *dp = (png_byte)((background->gray >> 8) & 0xff);
  992.                         *(dp + 1) = (png_byte)(background->gray & 0xff);
  993.                      }
  994. #if defined(PNG_READ_GAMMA_SUPPORTED)
  995.                      else
  996.                      {
  997.                         png_uint_16 g, v, w;
  999.                         g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
  1000.                         png_composite_16(v, g, a, background_1->gray);
  1001.                         w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
  1002.                         *dp = (png_byte)((w >> 8) & 0xff);
  1003.                         *(dp + 1) = (png_byte)(w & 0xff);
  1004.                      }
  1005. #endif
  1006.                   }
  1007.                }
  1008.                else
  1009. #endif
  1010.                {
  1011.                   sp = row;
  1012.                   dp = row;
  1013.                   for (i = 0; i < row_width; i++, sp += 4, dp += 2)
  1014.                   {
  1015.                      png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
  1016.                      if (a == (png_uint_16)0xffff)
  1017.                      {
  1018.                         png_memcpy(dp, sp, 2);
  1019.                      }
  1020. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1021.                      else if (a == 0)
  1022. #else
  1023.                      else
  1024. #endif
  1025.                      {
  1026.                         *dp = (png_byte)((background->gray >> 8) & 0xff);
  1027.                         *(dp + 1) = (png_byte)(background->gray & 0xff);
  1028.                      }
  1029. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1030.                      else
  1031.                      {
  1032.                         png_uint_16 g, v;
  1034.                         g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
  1035.                         png_composite_16(v, g, a, background_1->gray);
  1036.                         *dp = (png_byte)((v >> 8) & 0xff);
  1037.                         *(dp + 1) = (png_byte)(v & 0xff);
  1038.                      }
  1039. #endif
  1040.                   }
  1041.                }
  1042.             }
  1043.             break;
  1044.          }
  1045.          case PNG_COLOR_TYPE_RGB_ALPHA:
  1046.          {
  1047.             if (row_info->bit_depth == 8)
  1048.             {
  1049. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1050.                if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
  1051.                    gamma_table != NULL)
  1052.                {
  1053.                   sp = row;
  1054.                   dp = row;
  1055.                   for (i = 0; i < row_width; i++, sp += 4, dp += 3)
  1056.                   {
  1057.                      png_byte a = *(sp + 3);
  1059.                      if (a == 0xff)
  1060.                      {
  1061.                         *dp = gamma_table[*sp];
  1062.                         *(dp + 1) = gamma_table[*(sp + 1)];
  1063.                         *(dp + 2) = gamma_table[*(sp + 2)];
  1064.                      }
  1065.                      else if (a == 0)
  1066.                      {
  1067.                         /* background is already in screen gamma */
  1068.                         *dp = (png_byte)background->red;
  1069.                         *(dp + 1) = (png_byte)background->green;
  1070.                         *(dp + 2) = (png_byte)background->blue;
  1071.                      }
  1072.                      else
  1073.                      {
  1074.                         png_byte v, w;
  1076.                         v = gamma_to_1[*sp];
  1077.                         png_composite(w, v, a, background_1->red);
  1078.                         *dp = gamma_from_1[w];
  1079.                         v = gamma_to_1[*(sp + 1)];
  1080.                         png_composite(w, v, a, background_1->green);
  1081.                         *(dp + 1) = gamma_from_1[w];
  1082.                         v = gamma_to_1[*(sp + 2)];
  1083.                         png_composite(w, v, a, background_1->blue);
  1084.                         *(dp + 2) = gamma_from_1[w];
  1085.                      }
  1086.                   }
  1087.                }
  1088.                else
  1089. #endif
  1090.                {
  1091.                   sp = row;
  1092.                   dp = row;
  1093.                   for (i = 0; i < row_width; i++, sp += 4, dp += 3)
  1094.                   {
  1095.                      png_byte a = *(sp + 3);
  1097.                      if (a == 0xff)
  1098.                      {
  1099.                         *dp = *sp;
  1100.                         *(dp + 1) = *(sp + 1);
  1101.                         *(dp + 2) = *(sp + 2);
  1102.                      }
  1103.                      else if (a == 0)
  1104.                      {
  1105.                         *dp = (png_byte)background->red;
  1106.                         *(dp + 1) = (png_byte)background->green;
  1107.                         *(dp + 2) = (png_byte)background->blue;
  1108.                      }
  1109.                      else
  1110.                      {
  1111.                         png_composite(*dp, *sp, a, background->red);
  1112.                         png_composite(*(dp + 1), *(sp + 1), a,
  1113.                            background->green);
  1114.                         png_composite(*(dp + 2), *(sp + 2), a,
  1115.                            background->blue);
  1116.                      }
  1117.                   }
  1118.                }
  1119.             }
  1120.             else /* if (row_info->bit_depth == 16) */
  1121.             {
  1122. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1123.                if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
  1124.                    gamma_16_to_1 != NULL)
  1125.                {
  1126.                   sp = row;
  1127.                   dp = row;
  1128.                   for (i = 0; i < row_width; i++, sp += 8, dp += 6)
  1129.                   {
  1130.                      png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
  1131.                          << 8) + (png_uint_16)(*(sp + 7)));
  1132.                      if (a == (png_uint_16)0xffff)
  1133.                      {
  1134.                         png_uint_16 v;
  1136.                         v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
  1137.                         *dp = (png_byte)((v >> 8) & 0xff);
  1138.                         *(dp + 1) = (png_byte)(v & 0xff);
  1139.                         v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
  1140.                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
  1141.                         *(dp + 3) = (png_byte)(v & 0xff);
  1142.                         v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
  1143.                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
  1144.                         *(dp + 5) = (png_byte)(v & 0xff);
  1145.                      }
  1146.                      else if (a == 0)
  1147.                      {
  1148.                         /* background is already in screen gamma */
  1149.                         *dp = (png_byte)((background->red >> 8) & 0xff);
  1150.                         *(dp + 1) = (png_byte)(background->red & 0xff);
  1151.                         *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
  1152.                         *(dp + 3) = (png_byte)(background->green & 0xff);
  1153.                         *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
  1154.                         *(dp + 5) = (png_byte)(background->blue & 0xff);
  1155.                      }
  1156.                      else
  1157.                      {
  1158.                         png_uint_16 v, w, x;
  1160.                         v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
  1161.                         png_composite_16(w, v, a, background_1->red);
  1162.                         x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
  1163.                         *dp = (png_byte)((x >> 8) & 0xff);
  1164.                         *(dp + 1) = (png_byte)(x & 0xff);
  1165.                         v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
  1166.                         png_composite_16(w, v, a, background_1->green);
  1167.                         x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
  1168.                         *(dp + 2) = (png_byte)((x >> 8) & 0xff);
  1169.                         *(dp + 3) = (png_byte)(x & 0xff);
  1170.                         v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
  1171.                         png_composite_16(w, v, a, background_1->blue);
  1172.                         x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
  1173.                         *(dp + 4) = (png_byte)((x >> 8) & 0xff);
  1174.                         *(dp + 5) = (png_byte)(x & 0xff);
  1175.                      }
  1176.                   }
  1177.                }
  1178.                else
  1179. #endif
  1180.                {
  1181.                   sp = row;
  1182.                   dp = row;
  1183.                   for (i = 0; i < row_width; i++, sp += 8, dp += 6)
  1184.                   {
  1185.                      png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
  1186.                         << 8) + (png_uint_16)(*(sp + 7)));
  1187.                      if (a == (png_uint_16)0xffff)
  1188.                      {
  1189.                         png_memcpy(dp, sp, 6);
  1190.                      }
  1191.                      else if (a == 0)
  1192.                      {
  1193.                         *dp = (png_byte)((background->red >> 8) & 0xff);
  1194.                         *(dp + 1) = (png_byte)(background->red & 0xff);
  1195.                         *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
  1196.                         *(dp + 3) = (png_byte)(background->green & 0xff);
  1197.                         *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
  1198.                         *(dp + 5) = (png_byte)(background->blue & 0xff);
  1199.                      }
  1200.                      else
  1201.                      {
  1202.                         png_uint_16 v;
  1204.                         png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
  1205.                         png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
  1206.                             + *(sp + 3));
  1207.                         png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
  1208.                             + *(sp + 5));
  1210.                         png_composite_16(v, r, a, background->red);
  1211.                         *dp = (png_byte)((v >> 8) & 0xff);
  1212.                         *(dp + 1) = (png_byte)(v & 0xff);
  1213.                         png_composite_16(v, g, a, background->green);
  1214.                         *(dp + 2) = (png_byte)((v >> 8) & 0xff);
  1215.                         *(dp + 3) = (png_byte)(v & 0xff);
  1216.                         png_composite_16(v, b, a, background->blue);
  1217.                         *(dp + 4) = (png_byte)((v >> 8) & 0xff);
  1218.                         *(dp + 5) = (png_byte)(v & 0xff);
  1219.                      }
  1220.                   }
  1221.                }
  1222.             }
  1223.             break;
  1224.          }
  1225.       }
  1227.       if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
  1228.       {
  1229.          row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
  1230.          row_info->channels--;
  1231.          row_info->pixel_depth = (png_byte)(row_info->channels *
  1232.             row_info->bit_depth);
  1233.          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  1234.       }
  1235.    }
  1236. }
  1237. #endif
  1239. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1240. /* Gamma correct the image, avoiding the alpha channel.  Make sure
  1241.  * you do this after you deal with the transparency issue on grayscale
  1242.  * or RGB images. If your bit depth is 8, use gamma_table, if it
  1243.  * is 16, use gamma_16_table and gamma_shift.  Build these with
  1244.  * build_gamma_table().
  1245.  */
  1246. void /* PRIVATE */
  1247. png_do_gamma(png_row_infop row_info, png_bytep row,
  1248.    png_bytep gamma_table, png_uint_16pp gamma_16_table,
  1249.    int gamma_shift)
  1250. {
  1251.    png_bytep sp;
  1252.    png_uint_32 i;
  1253.    png_uint_32 row_width=row_info->width;
  1255.    png_debug(1, "in png_do_gamma");
  1256.    if (
  1257. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1258.        row != NULL && row_info != NULL &&
  1259. #endif
  1260.        ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
  1261.         (row_info->bit_depth == 16 && gamma_16_table != NULL)))
  1262.    {
  1263.       switch (row_info->color_type)
  1264.       {
  1265.          case PNG_COLOR_TYPE_RGB:
  1266.          {
  1267.             if (row_info->bit_depth == 8)
  1268.             {
  1269.                sp = row;
  1270.                for (i = 0; i < row_width; i++)
  1271.                {
  1272.                   *sp = gamma_table[*sp];
  1273.                   sp++;
  1274.                   *sp = gamma_table[*sp];
  1275.                   sp++;
  1276.                   *sp = gamma_table[*sp];
  1277.                   sp++;
  1278.                }
  1279.             }
  1280.             else /* if (row_info->bit_depth == 16) */
  1281.             {
  1282.                sp = row;
  1283.                for (i = 0; i < row_width; i++)
  1284.                {
  1285.                   png_uint_16 v;
  1287.                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1288.                   *sp = (png_byte)((v >> 8) & 0xff);
  1289.                   *(sp + 1) = (png_byte)(v & 0xff);
  1290.                   sp += 2;
  1291.                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1292.                   *sp = (png_byte)((v >> 8) & 0xff);
  1293.                   *(sp + 1) = (png_byte)(v & 0xff);
  1294.                   sp += 2;
  1295.                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1296.                   *sp = (png_byte)((v >> 8) & 0xff);
  1297.                   *(sp + 1) = (png_byte)(v & 0xff);
  1298.                   sp += 2;
  1299.                }
  1300.             }
  1301.             break;
  1302.          }
  1303.          case PNG_COLOR_TYPE_RGB_ALPHA:
  1304.          {
  1305.             if (row_info->bit_depth == 8)
  1306.             {
  1307.                sp = row;
  1308.                for (i = 0; i < row_width; i++)
  1309.                {
  1310.                   *sp = gamma_table[*sp];
  1311.                   sp++;
  1312.                   *sp = gamma_table[*sp];
  1313.                   sp++;
  1314.                   *sp = gamma_table[*sp];
  1315.                   sp++;
  1316.                   sp++;
  1317.                }
  1318.             }
  1319.             else /* if (row_info->bit_depth == 16) */
  1320.             {
  1321.                sp = row;
  1322.                for (i = 0; i < row_width; i++)
  1323.                {
  1324.                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1325.                   *sp = (png_byte)((v >> 8) & 0xff);
  1326.                   *(sp + 1) = (png_byte)(v & 0xff);
  1327.                   sp += 2;
  1328.                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1329.                   *sp = (png_byte)((v >> 8) & 0xff);
  1330.                   *(sp + 1) = (png_byte)(v & 0xff);
  1331.                   sp += 2;
  1332.                   v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1333.                   *sp = (png_byte)((v >> 8) & 0xff);
  1334.                   *(sp + 1) = (png_byte)(v & 0xff);
  1335.                   sp += 4;
  1336.                }
  1337.             }
  1338.             break;
  1339.          }
  1340.          case PNG_COLOR_TYPE_GRAY_ALPHA:
  1341.          {
  1342.             if (row_info->bit_depth == 8)
  1343.             {
  1344.                sp = row;
  1345.                for (i = 0; i < row_width; i++)
  1346.                {
  1347.                   *sp = gamma_table[*sp];
  1348.                   sp += 2;
  1349.                }
  1350.             }
  1351.             else /* if (row_info->bit_depth == 16) */
  1352.             {
  1353.                sp = row;
  1354.                for (i = 0; i < row_width; i++)
  1355.                {
  1356.                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1357.                   *sp = (png_byte)((v >> 8) & 0xff);
  1358.                   *(sp + 1) = (png_byte)(v & 0xff);
  1359.                   sp += 4;
  1360.                }
  1361.             }
  1362.             break;
  1363.          }
  1364.          case PNG_COLOR_TYPE_GRAY:
  1365.          {
  1366.             if (row_info->bit_depth == 2)
  1367.             {
  1368.                sp = row;
  1369.                for (i = 0; i < row_width; i += 4)
  1370.                {
  1371.                   int a = *sp & 0xc0;
  1372.                   int b = *sp & 0x30;
  1373.                   int c = *sp & 0x0c;
  1374.                   int d = *sp & 0x03;
  1376.                   *sp = (png_byte)(
  1377.                         ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|
  1378.                         ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
  1379.                         ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
  1380.                         ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
  1381.                   sp++;
  1382.                }
  1383.             }
  1384.             if (row_info->bit_depth == 4)
  1385.             {
  1386.                sp = row;
  1387.                for (i = 0; i < row_width; i += 2)
  1388.                {
  1389.                   int msb = *sp & 0xf0;
  1390.                   int lsb = *sp & 0x0f;
  1392.                   *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
  1393.                           | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
  1394.                   sp++;
  1395.                }
  1396.             }
  1397.             else if (row_info->bit_depth == 8)
  1398.             {
  1399.                sp = row;
  1400.                for (i = 0; i < row_width; i++)
  1401.                {
  1402.                   *sp = gamma_table[*sp];
  1403.                   sp++;
  1404.                }
  1405.             }
  1406.             else if (row_info->bit_depth == 16)
  1407.             {
  1408.                sp = row;
  1409.                for (i = 0; i < row_width; i++)
  1410.                {
  1411.                   png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
  1412.                   *sp = (png_byte)((v >> 8) & 0xff);
  1413.                   *(sp + 1) = (png_byte)(v & 0xff);
  1414.                   sp += 2;
  1415.                }
  1416.             }
  1417.             break;
  1418.          }
  1419.       }
  1420.    }
  1421. }
  1422. #endif
  1424. #if defined(PNG_READ_EXPAND_SUPPORTED)
  1425. /* Expands a palette row to an RGB or RGBA row depending
  1426.  * upon whether you supply trans and num_trans.
  1427.  */
  1428. void /* PRIVATE */
  1429. png_do_expand_palette(png_row_infop row_info, png_bytep row,
  1430.    png_colorp palette, png_bytep trans, int num_trans)
  1431. {
  1432.    int shift, value;
  1433.    png_bytep sp, dp;
  1434.    png_uint_32 i;
  1435.    png_uint_32 row_width=row_info->width;
  1437.    png_debug(1, "in png_do_expand_palette");
  1438.    if (
  1439. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1440.        row != NULL && row_info != NULL &&
  1441. #endif
  1442.        row_info->color_type == PNG_COLOR_TYPE_PALETTE)
  1443.    {
  1444.       if (row_info->bit_depth < 8)
  1445.       {
  1446.          switch (row_info->bit_depth)
  1447.          {
  1448.             case 1:
  1449.             {
  1450.                sp = row + (png_size_t)((row_width - 1) >> 3);
  1451.                dp = row + (png_size_t)row_width - 1;
  1452.                shift = 7 - (int)((row_width + 7) & 0x07);
  1453.                for (i = 0; i < row_width; i++)
  1454.                {
  1455.                   if ((*sp >> shift) & 0x01)
  1456.                      *dp = 1;
  1457.                   else
  1458.                      *dp = 0;
  1459.                   if (shift == 7)
  1460.                   {
  1461.                      shift = 0;
  1462.                      sp--;
  1463.                   }
  1464.                   else
  1465.                      shift++;
  1467.                   dp--;
  1468.                }
  1469.                break;
  1470.             }
  1471.             case 2:
  1472.             {
  1473.                sp = row + (png_size_t)((row_width - 1) >> 2);
  1474.                dp = row + (png_size_t)row_width - 1;
  1475.                shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
  1476.                for (i = 0; i < row_width; i++)
  1477.                {
  1478.                   value = (*sp >> shift) & 0x03;
  1479.                   *dp = (png_byte)value;
  1480.                   if (shift == 6)
  1481.                   {
  1482.                      shift = 0;
  1483.                      sp--;
  1484.                   }
  1485.                   else
  1486.                      shift += 2;
  1488.                   dp--;
  1489.                }
  1490.                break;
  1491.             }
  1492.             case 4:
  1493.             {
  1494.                sp = row + (png_size_t)((row_width - 1) >> 1);
  1495.                dp = row + (png_size_t)row_width - 1;
  1496.                shift = (int)((row_width & 0x01) << 2);
  1497.                for (i = 0; i < row_width; i++)
  1498.                {
  1499.                   value = (*sp >> shift) & 0x0f;
  1500.                   *dp = (png_byte)value;
  1501.                   if (shift == 4)
  1502.                   {
  1503.                      shift = 0;
  1504.                      sp--;
  1505.                   }
  1506.                   else
  1507.                      shift += 4;
  1509.                   dp--;
  1510.                }
  1511.                break;
  1512.             }
  1513.          }
  1514.          row_info->bit_depth = 8;
  1515.          row_info->pixel_depth = 8;
  1516.          row_info->rowbytes = row_width;
  1517.       }
  1518.       switch (row_info->bit_depth)
  1519.       {
  1520.          case 8:
  1521.          {
  1522.             if (trans != NULL)
  1523.             {
  1524.                sp = row + (png_size_t)row_width - 1;
  1525.                dp = row + (png_size_t)(row_width << 2) - 1;
  1527.                for (i = 0; i < row_width; i++)
  1528.                {
  1529.                   if ((int)(*sp) >= num_trans)
  1530.                      *dp-- = 0xff;
  1531.                   else
  1532.                      *dp-- = trans[*sp];
  1533.                   *dp-- = palette[*sp].blue;
  1534.                   *dp-- = palette[*sp].green;
  1535.                   *dp-- = palette[*sp].red;
  1536.                   sp--;
  1537.                }
  1538.                row_info->bit_depth = 8;
  1539.                row_info->pixel_depth = 32;
  1540.                row_info->rowbytes = row_width * 4;
  1541.                row_info->color_type = 6;
  1542.                row_info->channels = 4;
  1543.             }
  1544.             else
  1545.             {
  1546.                sp = row + (png_size_t)row_width - 1;
  1547.                dp = row + (png_size_t)(row_width * 3) - 1;
  1549.                for (i = 0; i < row_width; i++)
  1550.                {
  1551.                   *dp-- = palette[*sp].blue;
  1552.                   *dp-- = palette[*sp].green;
  1553.                   *dp-- = palette[*sp].red;
  1554.                   sp--;
  1555.                }
  1556.                row_info->bit_depth = 8;
  1557.                row_info->pixel_depth = 24;
  1558.                row_info->rowbytes = row_width * 3;
  1559.                row_info->color_type = 2;
  1560.                row_info->channels = 3;
  1561.             }
  1562.             break;
  1563.          }
  1564.       }
  1565.    }
  1566. }
  1568. /* If the bit depth < 8, it is expanded to 8.  Also, if the already
  1569.  * expanded transparency value is supplied, an alpha channel is built.
  1570.  */
  1571. void /* PRIVATE */
  1572. png_do_expand(png_row_infop row_info, png_bytep row,
  1573.    png_color_16p trans_value)
  1574. {
  1575.    int shift, value;
  1576.    png_bytep sp, dp;
  1577.    png_uint_32 i;
  1578.    png_uint_32 row_width=row_info->width;
  1580.    png_debug(1, "in png_do_expand");
  1581. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1582.    if (row != NULL && row_info != NULL)
  1583. #endif
  1584.    {
  1585.       if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
  1586.       {
  1587.          png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
  1589.          if (row_info->bit_depth < 8)
  1590.          {
  1591.             switch (row_info->bit_depth)
  1592.             {
  1593.                case 1:
  1594.                {
  1595.                   gray = (png_uint_16)((gray&0x01)*0xff);
  1596.                   sp = row + (png_size_t)((row_width - 1) >> 3);
  1597.                   dp = row + (png_size_t)row_width - 1;
  1598.                   shift = 7 - (int)((row_width + 7) & 0x07);
  1599.                   for (i = 0; i < row_width; i++)
  1600.                   {
  1601.                      if ((*sp >> shift) & 0x01)
  1602.                         *dp = 0xff;
  1603.                      else
  1604.                         *dp = 0;
  1605.                      if (shift == 7)
  1606.                      {
  1607.                         shift = 0;
  1608.                         sp--;
  1609.                      }
  1610.                      else
  1611.                         shift++;
  1613.                      dp--;
  1614.                   }
  1615.                   break;
  1616.                }
  1617.                case 2:
  1618.                {
  1619.                   gray = (png_uint_16)((gray&0x03)*0x55);
  1620.                   sp = row + (png_size_t)((row_width - 1) >> 2);
  1621.                   dp = row + (png_size_t)row_width - 1;
  1622.                   shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
  1623.                   for (i = 0; i < row_width; i++)
  1624.                   {
  1625.                      value = (*sp >> shift) & 0x03;
  1626.                      *dp = (png_byte)(value | (value << 2) | (value << 4) |
  1627.                         (value << 6));
  1628.                      if (shift == 6)
  1629.                      {
  1630.                         shift = 0;
  1631.                         sp--;
  1632.                      }
  1633.                      else
  1634.                         shift += 2;
  1636.                      dp--;
  1637.                   }
  1638.                   break;
  1639.                }
  1640.                case 4:
  1641.                {
  1642.                   gray = (png_uint_16)((gray&0x0f)*0x11);
  1643.                   sp = row + (png_size_t)((row_width - 1) >> 1);
  1644.                   dp = row + (png_size_t)row_width - 1;
  1645.                   shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
  1646.                   for (i = 0; i < row_width; i++)
  1647.                   {
  1648.                      value = (*sp >> shift) & 0x0f;
  1649.                      *dp = (png_byte)(value | (value << 4));
  1650.                      if (shift == 4)
  1651.                      {
  1652.                         shift = 0;
  1653.                         sp--;
  1654.                      }
  1655.                      else
  1656.                         shift = 4;
  1658.                      dp--;
  1659.                   }
  1660.                   break;
  1661.                }
  1662.             }
  1663.             row_info->bit_depth = 8;
  1664.             row_info->pixel_depth = 8;
  1665.             row_info->rowbytes = row_width;
  1666.          }
  1668.          if (trans_value != NULL)
  1669.          {
  1670.             if (row_info->bit_depth == 8)
  1671.             {
  1672.                gray = gray & 0xff;
  1673.                sp = row + (png_size_t)row_width - 1;
  1674.                dp = row + (png_size_t)(row_width << 1) - 1;
  1675.                for (i = 0; i < row_width; i++)
  1676.                {
  1677.                   if (*sp == gray)
  1678.                      *dp-- = 0;
  1679.                   else
  1680.                      *dp-- = 0xff;
  1681.                   *dp-- = *sp--;
  1682.                }
  1683.             }
  1684.             else if (row_info->bit_depth == 16)
  1685.             {
  1686.                png_byte gray_high = (gray >> 8) & 0xff;
  1687.                png_byte gray_low = gray & 0xff;
  1688.                sp = row + row_info->rowbytes - 1;
  1689.                dp = row + (row_info->rowbytes << 1) - 1;
  1690.                for (i = 0; i < row_width; i++)
  1691.                {
  1692.                   if (*(sp - 1) == gray_high && *(sp) == gray_low) 
  1693.                   {
  1694.                      *dp-- = 0;
  1695.                      *dp-- = 0;
  1696.                   }
  1697.                   else
  1698.                   {
  1699.                      *dp-- = 0xff;
  1700.                      *dp-- = 0xff;
  1701.                   }
  1702.                   *dp-- = *sp--;
  1703.                   *dp-- = *sp--;
  1704.                }
  1705.             }
  1706.             row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
  1707.             row_info->channels = 2;
  1708.             row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
  1709.             row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
  1710.                row_width);
  1711.          }
  1712.       }
  1713.       else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
  1714.       {
  1715.          if (row_info->bit_depth == 8)
  1716.          {
  1717.             png_byte red = trans_value->red & 0xff;
  1718.             png_byte green = trans_value->green & 0xff;
  1719.             png_byte blue = trans_value->blue & 0xff;
  1720.             sp = row + (png_size_t)row_info->rowbytes - 1;
  1721.             dp = row + (png_size_t)(row_width << 2) - 1;
  1722.             for (i = 0; i < row_width; i++)
  1723.             {
  1724.                if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
  1725.                   *dp-- = 0;
  1726.                else
  1727.                   *dp-- = 0xff;
  1728.                *dp-- = *sp--;
  1729.                *dp-- = *sp--;
  1730.                *dp-- = *sp--;
  1731.             }
  1732.          }
  1733.          else if (row_info->bit_depth == 16)
  1734.          {
  1735.             png_byte red_high = (trans_value->red >> 8) & 0xff;
  1736.             png_byte green_high = (trans_value->green >> 8) & 0xff;
  1737.             png_byte blue_high = (trans_value->blue >> 8) & 0xff;
  1738.             png_byte red_low = trans_value->red & 0xff;
  1739.             png_byte green_low = trans_value->green & 0xff;
  1740.             png_byte blue_low = trans_value->blue & 0xff;
  1741.             sp = row + row_info->rowbytes - 1;
  1742.             dp = row + (png_size_t)(row_width << 3) - 1;
  1743.             for (i = 0; i < row_width; i++)
  1744.             {
  1745.                if (*(sp - 5) == red_high &&
  1746.                   *(sp - 4) == red_low &&
  1747.                   *(sp - 3) == green_high &&
  1748.                   *(sp - 2) == green_low &&
  1749.                   *(sp - 1) == blue_high &&
  1750.                   *(sp    ) == blue_low)
  1751.                {
  1752.                   *dp-- = 0;
  1753.                   *dp-- = 0;
  1754.                }
  1755.                else
  1756.                {
  1757.                   *dp-- = 0xff;
  1758.                   *dp-- = 0xff;
  1759.                }
  1760.                *dp-- = *sp--;
  1761.                *dp-- = *sp--;
  1762.                *dp-- = *sp--;
  1763.                *dp-- = *sp--;
  1764.                *dp-- = *sp--;
  1765.                *dp-- = *sp--;
  1766.             }
  1767.          }
  1768.          row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
  1769.          row_info->channels = 4;
  1770.          row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
  1771.          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  1772.       }
  1773.    }
  1774. }
  1775. #endif
  1777. #if defined(PNG_READ_DITHER_SUPPORTED)
  1778. void /* PRIVATE */
  1779. png_do_dither(png_row_infop row_info, png_bytep row,
  1780.     png_bytep palette_lookup, png_bytep dither_lookup)
  1781. {
  1782.    png_bytep sp, dp;
  1783.    png_uint_32 i;
  1784.    png_uint_32 row_width=row_info->width;
  1786.    png_debug(1, "in png_do_dither");
  1787. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1788.    if (row != NULL && row_info != NULL)
  1789. #endif
  1790.    {
  1791.       if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
  1792.          palette_lookup && row_info->bit_depth == 8)
  1793.       {
  1794.          int r, g, b, p;
  1795.          sp = row;
  1796.          dp = row;
  1797.          for (i = 0; i < row_width; i++)
  1798.          {
  1799.             r = *sp++;
  1800.             g = *sp++;
  1801.             b = *sp++;
  1803.             /* this looks real messy, but the compiler will reduce
  1804.                it down to a reasonable formula.  For example, with
  1805.                5 bits per color, we get:
  1806.                p = (((r >> 3) & 0x1f) << 10) |
  1807.                   (((g >> 3) & 0x1f) << 5) |
  1808.                   ((b >> 3) & 0x1f);
  1809.                */
  1810.             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
  1811.                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
  1812.                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
  1813.                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
  1814.                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
  1815.                (PNG_DITHER_BLUE_BITS)) |
  1816.                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
  1817.                ((1 << PNG_DITHER_BLUE_BITS) - 1));
  1819.             *dp++ = palette_lookup[p];
  1820.          }
  1821.          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
  1822.          row_info->channels = 1;
  1823.          row_info->pixel_depth = row_info->bit_depth;
  1824.          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  1825.       }
  1826.       else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
  1827.          palette_lookup != NULL && row_info->bit_depth == 8)
  1828.       {
  1829.          int r, g, b, p;
  1830.          sp = row;
  1831.          dp = row;
  1832.          for (i = 0; i < row_width; i++)
  1833.          {
  1834.             r = *sp++;
  1835.             g = *sp++;
  1836.             b = *sp++;
  1837.             sp++;
  1839.             p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
  1840.                ((1 << PNG_DITHER_RED_BITS) - 1)) <<
  1841.                (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
  1842.                (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
  1843.                ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
  1844.                (PNG_DITHER_BLUE_BITS)) |
  1845.                ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
  1846.                ((1 << PNG_DITHER_BLUE_BITS) - 1));
  1848.             *dp++ = palette_lookup[p];
  1849.          }
  1850.          row_info->color_type = PNG_COLOR_TYPE_PALETTE;
  1851.          row_info->channels = 1;
  1852.          row_info->pixel_depth = row_info->bit_depth;
  1853.          row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
  1854.       }
  1855.       else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
  1856.          dither_lookup && row_info->bit_depth == 8)
  1857.       {
  1858.          sp = row;
  1859.          for (i = 0; i < row_width; i++, sp++)
  1860.          {
  1861.             *sp = dither_lookup[*sp];
  1862.          }
  1863.       }
  1864.    }
  1865. }
  1866. #endif
  1868. #ifdef PNG_FLOATING_POINT_SUPPORTED
  1869. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1870. static PNG_CONST int png_gamma_shift[] =
  1871.    {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
  1873. /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
  1874.  * tables, we don't make a full table if we are reducing to 8-bit in
  1875.  * the future.  Note also how the gamma_16 tables are segmented so that
  1876.  * we don't need to allocate > 64K chunks for a full 16-bit table.
  1877.  */
  1878. void /* PRIVATE */
  1879. png_build_gamma_table(png_structp png_ptr)
  1880. {
  1881.   png_debug(1, "in png_build_gamma_table");
  1883.   if (png_ptr->bit_depth <= 8)
  1884.   {
  1885.      int i;
  1886.      double g;
  1888.      if (png_ptr->screen_gamma > .000001)
  1889.         g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
  1890.      else
  1891.         g = 1.0;
  1893.      png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
  1894.         (png_uint_32)256);
  1896.      for (i = 0; i < 256; i++)
  1897.      {
  1898.         png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
  1899.            g) * 255.0 + .5);
  1900.      }
  1902. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || 
  1903.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  1904.      if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
  1905.      {
  1907.         g = 1.0 / (png_ptr->gamma);
  1909.         png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
  1910.            (png_uint_32)256);
  1912.         for (i = 0; i < 256; i++)
  1913.         {
  1914.            png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
  1915.               g) * 255.0 + .5);
  1916.         }
  1919.         png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
  1920.            (png_uint_32)256);
  1922.         if (png_ptr->screen_gamma > 0.000001)
  1923.            g = 1.0 / png_ptr->screen_gamma;
  1924.         else
  1925.            g = png_ptr->gamma;   /* probably doing rgb_to_gray */
  1927.         for (i = 0; i < 256; i++)
  1928.         {
  1929.            png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
  1930.               g) * 255.0 + .5);
  1932.         }
  1933.      }
  1934. #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
  1935.   }
  1936.   else
  1937.   {
  1938.      double g;
  1939.      int i, j, shift, num;
  1940.      int sig_bit;
  1941.      png_uint_32 ig;
  1943.      if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  1944.      {
  1945.         sig_bit = (int)png_ptr->sig_bit.red;
  1946.         if ((int)png_ptr->sig_bit.green > sig_bit)
  1947.            sig_bit = png_ptr->sig_bit.green;
  1948.         if ((int)png_ptr->sig_bit.blue > sig_bit)
  1949.            sig_bit = png_ptr->sig_bit.blue;
  1950.      }
  1951.      else
  1952.      {
  1953.         sig_bit = (int)png_ptr->sig_bit.gray;
  1954.      }
  1956.      if (sig_bit > 0)
  1957.         shift = 16 - sig_bit;
  1958.      else
  1959.         shift = 0;
  1961.      if (png_ptr->transformations & PNG_16_TO_8)
  1962.      {
  1963.         if (shift < (16 - PNG_MAX_GAMMA_8))
  1964.            shift = (16 - PNG_MAX_GAMMA_8);
  1965.      }
  1967.      if (shift > 8)
  1968.         shift = 8;
  1969.      if (shift < 0)
  1970.         shift = 0;
  1972.      png_ptr->gamma_shift = (png_byte)shift;
  1974.      num = (1 << (8 - shift));
  1976.      if (png_ptr->screen_gamma > .000001)
  1977.         g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
  1978.      else
  1979.         g = 1.0;
  1981.      png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
  1982.         (png_uint_32)(num * png_sizeof(png_uint_16p)));
  1984.      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
  1985.      {
  1986.         double fin, fout;
  1987.         png_uint_32 last, max;
  1989.         for (i = 0; i < num; i++)
  1990.         {
  1991.            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
  1992.               (png_uint_32)(256 * png_sizeof(png_uint_16)));
  1993.         }
  1995.         g = 1.0 / g;
  1996.         last = 0;
  1997.         for (i = 0; i < 256; i++)
  1998.         {
  1999.            fout = ((double)i + 0.5) / 256.0;
  2000.            fin = pow(fout, g);
  2001.            max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
  2002.            while (last <= max)
  2003.            {
  2004.               png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
  2005.                  [(int)(last >> (8 - shift))] = (png_uint_16)(
  2006.                  (png_uint_16)i | ((png_uint_16)i << 8));
  2007.               last++;
  2008.            }
  2009.         }
  2010.         while (last < ((png_uint_32)num << 8))
  2011.         {
  2012.            png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
  2013.               [(int)(last >> (8 - shift))] = (png_uint_16)65535L;
  2014.            last++;
  2015.         }
  2016.      }
  2017.      else
  2018.      {
  2019.         for (i = 0; i < num; i++)
  2020.         {
  2021.            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
  2022.               (png_uint_32)(256 * png_sizeof(png_uint_16)));
  2024.            ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
  2025.            for (j = 0; j < 256; j++)
  2026.            {
  2027.               png_ptr->gamma_16_table[i][j] =
  2028.                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2029.                     65535.0, g) * 65535.0 + .5);
  2030.            }
  2031.         }
  2032.      }
  2034. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || 
  2035.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  2036.      if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
  2037.      {
  2039.         g = 1.0 / (png_ptr->gamma);
  2041.         png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
  2042.            (png_uint_32)(num * png_sizeof(png_uint_16p )));
  2044.         for (i = 0; i < num; i++)
  2045.         {
  2046.            png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
  2047.               (png_uint_32)(256 * png_sizeof(png_uint_16)));
  2049.            ig = (((png_uint_32)i *
  2050.               (png_uint_32)png_gamma_shift[shift]) >> 4);
  2051.            for (j = 0; j < 256; j++)
  2052.            {
  2053.               png_ptr->gamma_16_to_1[i][j] =
  2054.                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2055.                     65535.0, g) * 65535.0 + .5);
  2056.            }
  2057.         }
  2059.         if (png_ptr->screen_gamma > 0.000001)
  2060.            g = 1.0 / png_ptr->screen_gamma;
  2061.         else
  2062.            g = png_ptr->gamma;   /* probably doing rgb_to_gray */
  2064.         png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
  2065.            (png_uint_32)(num * png_sizeof(png_uint_16p)));
  2067.         for (i = 0; i < num; i++)
  2068.         {
  2069.            png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
  2070.               (png_uint_32)(256 * png_sizeof(png_uint_16)));
  2072.            ig = (((png_uint_32)i *
  2073.               (png_uint_32)png_gamma_shift[shift]) >> 4);
  2074.            for (j = 0; j < 256; j++)
  2075.            {
  2076.               png_ptr->gamma_16_from_1[i][j] =
  2077.                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
  2078.                     65535.0, g) * 65535.0 + .5);
  2079.            }
  2080.         }
  2081.      }
  2082. #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
  2083.   }
  2084. }
  2085. #endif
  2086. /* To do: install integer version of png_build_gamma_table here */
  2087. #endif
  2089. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  2090. /* undoes intrapixel differencing  */
  2091. void /* PRIVATE */
  2092. png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
  2093. {
  2094.    png_debug(1, "in png_do_read_intrapixel");
  2095.    if (
  2096. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  2097.        row != NULL && row_info != NULL &&
  2098. #endif
  2099.        (row_info->color_type & PNG_COLOR_MASK_COLOR))
  2100.    {
  2101.       int bytes_per_pixel;
  2102.       png_uint_32 row_width = row_info->width;
  2103.       if (row_info->bit_depth == 8)
  2104.       {
  2105.          png_bytep rp;
  2106.          png_uint_32 i;
  2108.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  2109.             bytes_per_pixel = 3;
  2110.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  2111.             bytes_per_pixel = 4;
  2112.          else
  2113.             return;
  2115.          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  2116.          {
  2117.             *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);
  2118.             *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);
  2119.          }
  2120.       }
  2121.       else if (row_info->bit_depth == 16)
  2122.       {
  2123.          png_bytep rp;
  2124.          png_uint_32 i;
  2126.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  2127.             bytes_per_pixel = 6;
  2128.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  2129.             bytes_per_pixel = 8;
  2130.          else
  2131.             return;
  2133.          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  2134.          {
  2135.             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
  2136.             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
  2137.             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
  2138.             png_uint_32 red  = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);
  2139.             png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);
  2140.             *(rp  ) = (png_byte)((red >> 8) & 0xff);
  2141.             *(rp+1) = (png_byte)(red & 0xff);
  2142.             *(rp+4) = (png_byte)((blue >> 8) & 0xff);
  2143.             *(rp+5) = (png_byte)(blue & 0xff);
  2144.          }
  2145.       }
  2146.    }
  2147. }
  2148. #endif /* PNG_MNG_FEATURES_SUPPORTED */
  2149. #endif /* PNG_READ_SUPPORTED */