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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
pngrtran.c
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：145k
源码类别：

对话框与窗口

开发平台：

Visual C++

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