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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
pngrtran.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：141k
源码类别：

打印编程

开发平台：

Visual C++

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