pngrtran.c

一套图像处理程序,支持三种图像文件格式,我调试过了,很好用

         g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
         b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));

         for (ir = 0; ir < num_red; ir++)
         {
            int dr, index_r;

            dr = abs(ir - r);
            index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
            for (ig = 0; ig < num_green; ig++)
            {
               int dg, dt, dm, index_g;

               dg = abs(ig - g);
               dt = dr + dg;
               dm = ((dr > dg) ? dr : dg);
               index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
               for (ib = 0; ib < num_blue; ib++)
               {
                  int index, db, dmax, d;

                  index = index_g | ib;
                  db = abs(ib - b);
                  dmax = ((dm > db) ? dm : db);
                  d = dmax + dt + db;

                  if (d < distance[index])
                  {
                     distance[index] = (png_byte)d;
                     png_ptr->palette_lookup[index] = (png_byte)i;
                  }
               }
            }
         }
      }

      png_large_free(png_ptr, distance);
   }
}
#endif

#if defined(PNG_READ_GAMMA_SUPPORTED)
/* transform the image from the file_gamma to the screen_gamma */
void
png_set_gamma(png_structp png_ptr, double screen_gamma,
   double file_gamma)
{
   png_ptr->transformations |= PNG_GAMMA;
   png_ptr->gamma = (float)file_gamma;
   png_ptr->display_gamma = (float)screen_gamma;
}
#endif

#if defined(PNG_READ_EXPAND_SUPPORTED)
/* expand paletted images to rgb, expand grayscale images of
   less then 8 bit depth to 8 bit depth, and expand tRNS chunks
   to alpha channels */
void
png_set_expand(png_structp png_ptr)
{
   png_ptr->transformations |= PNG_EXPAND;
}
#endif

#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
void
png_set_gray_to_rgb(png_structp png_ptr)
{
   png_ptr->transformations |= PNG_GRAY_TO_RGB;
}
#endif

/* initialize everything needed for the read.  This includes modifying
   the palette */
void
png_init_read_transformations(png_structp png_ptr)
{
   int color_type;

   color_type = png_ptr->color_type;

#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
   if (png_ptr->transformations & PNG_BACKGROUND_EXPAND)
   {
      if (color_type == PNG_COLOR_TYPE_GRAY)
      {
         /* expand background chunk. */
         switch (png_ptr->bit_depth)
         {
            case 1:
               png_ptr->background.gray *= (png_uint_16)0xff;
               png_ptr->background.red = png_ptr->background.green =
               png_ptr->background.blue = png_ptr->background.gray;
               break;
            case 2:
               png_ptr->background.gray *= (png_uint_16)0x55;
               png_ptr->background.red = png_ptr->background.green =
               png_ptr->background.blue = png_ptr->background.gray;
               break;
            case 4:
               png_ptr->background.gray *= (png_uint_16)0x11;
               png_ptr->background.red = png_ptr->background.green =
               png_ptr->background.blue = png_ptr->background.gray;
               break;
            case 8:
            case 16:
               png_ptr->background.red = png_ptr->background.green =
               png_ptr->background.blue = png_ptr->background.gray;
               break;
         }
      }
      else if (color_type == PNG_COLOR_TYPE_PALETTE)
      {
         png_ptr->background.red   =
            png_ptr->palette[png_ptr->background.index].red;
         png_ptr->background.green =
            png_ptr->palette[png_ptr->background.index].green;
         png_ptr->background.blue  =
            png_ptr->palette[png_ptr->background.index].blue;
      }
   }
#endif

#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   png_ptr->background_1 = png_ptr->background;
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED)
   if (png_ptr->transformations & PNG_GAMMA)
   {
      png_build_gamma_table(png_ptr);
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
      if (png_ptr->transformations & PNG_BACKGROUND)
      {
         if (color_type == PNG_COLOR_TYPE_PALETTE)
         {
            int num_palette, i;
            png_color back, back_1;
            png_colorp palette;

            palette = png_ptr->palette;
            num_palette = png_ptr->num_palette;

            back.red = png_ptr->gamma_table[png_ptr->background.red];
            back.green = png_ptr->gamma_table[png_ptr->background.green];
            back.blue = png_ptr->gamma_table[png_ptr->background.blue];

            back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
            back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
            back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

            for (i = 0; i < num_palette; i++)
            {
               if (i < (int)png_ptr->num_trans)
               {
                  if (png_ptr->trans[i] == 0)
                  {
                     palette[i] = back;
                  }
                  else if (png_ptr->trans[i] != 0xff)
                  {
                     int v, w;

                     v = png_ptr->gamma_to_1[palette[i].red];
                     w = (int)(((png_uint_32)(v) *
                        (png_uint_32)(png_ptr->trans[i]) +
                        (png_uint_32)(back_1.red) *
                        (png_uint_32)(255 - png_ptr->trans[i]) +
                        127) / 255);
                     palette[i].red = png_ptr->gamma_from_1[w];

                     v = png_ptr->gamma_to_1[palette[i].green];
                     w = (int)(((png_uint_32)(v) *
                        (png_uint_32)(png_ptr->trans[i]) +
                        (png_uint_32)(back_1.green) *
                        (png_uint_32)(255 - png_ptr->trans[i]) +
                        127) / 255);
                     palette[i].green = png_ptr->gamma_from_1[w];

                     v = png_ptr->gamma_to_1[palette[i].blue];
                     w = (int)(((png_uint_32)(v) *
                        (png_uint_32)(png_ptr->trans[i]) +
                        (png_uint_32)(back_1.blue) *
                        (png_uint_32)(255 - png_ptr->trans[i]) +
                        127) / 255);
                     palette[i].blue = png_ptr->gamma_from_1[w];
                  }
               }
               else
               {
                  palette[i].red = png_ptr->gamma_table[palette[i].red];
                  palette[i].green = png_ptr->gamma_table[palette[i].green];
                  palette[i].blue = png_ptr->gamma_table[palette[i].blue];
               }
            }
         }
         else if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN)
         {
            double g, gs, m;

            m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
            g = 1.0;
            gs = 1.0;

            switch (png_ptr->background_gamma_type)
            {
               case PNG_BACKGROUND_GAMMA_SCREEN:
                  g = (png_ptr->display_gamma);
                  gs = 1.0;
                  break;
               case PNG_BACKGROUND_GAMMA_FILE:
                  g = 1.0 / (png_ptr->gamma);
                  gs = 1.0 / (png_ptr->gamma * png_ptr->display_gamma);
                  break;
               case PNG_BACKGROUND_GAMMA_UNIQUE:
                  g = 1.0 / (png_ptr->background_gamma);
                  gs = 1.0 / (png_ptr->background_gamma *
                     png_ptr->display_gamma);
                  break;
            }

            if (color_type & PNG_COLOR_MASK_COLOR)
            {
               png_ptr->background_1.red = (png_uint_16)(pow(
                  (double)png_ptr->background.red / m, g) * m + .5);
               png_ptr->background_1.green = (png_uint_16)(pow(
                  (double)png_ptr->background.green / m, g) * m + .5);
               png_ptr->background_1.blue = (png_uint_16)(pow(
                  (double)png_ptr->background.blue / m, g) * m + .5);
               png_ptr->background.red = (png_uint_16)(pow(
                  (double)png_ptr->background.red / m, gs) * m + .5);
               png_ptr->background.green = (png_uint_16)(pow(
                  (double)png_ptr->background.green / m, gs) * m + .5);
               png_ptr->background.blue = (png_uint_16)(pow(
                  (double)png_ptr->background.blue / m, gs) * m + .5);
            }
            else
            {
               png_ptr->background_1.gray = (png_uint_16)(pow(
                  (double)png_ptr->background.gray / m, g) * m + .5);
               png_ptr->background.gray = (png_uint_16)(pow(
                  (double)png_ptr->background.gray / m, gs) * m + .5);
            }
         }
      }
      else
#endif
      if (color_type == PNG_COLOR_TYPE_PALETTE)
      {
         int num_palette, i;
         png_colorp palette;

         palette = png_ptr->palette;
         num_palette = png_ptr->num_palette;

         for (i = 0; i < num_palette; i++)
         {
            palette[i].red = png_ptr->gamma_table[palette[i].red];
            palette[i].green = png_ptr->gamma_table[palette[i].green];
            palette[i].blue = png_ptr->gamma_table[palette[i].blue];
         }
      }
   }
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   else
#endif
#endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   if (png_ptr->transformations & PNG_BACKGROUND &&
       color_type == PNG_COLOR_TYPE_PALETTE)
   {
      int i;
      png_color back;
      png_colorp palette;

      palette = png_ptr->palette;
      back.red   = (png_byte)png_ptr->background.red;
      back.green = (png_byte)png_ptr->background.green;
      back.blue  = (png_byte)png_ptr->background.blue;

      for (i = 0; i < png_ptr->num_trans; i++)
      {
         if (png_ptr->trans[i] == 0)
         {
            palette[i] = back;
         }
         else if (png_ptr->trans[i] != 0xff)
         {
            palette[i].red = (png_byte)((
               (png_uint_32)(palette[i].red) *
               (png_uint_32)(png_ptr->trans[i]) +
               (png_uint_32)(back.red) *
               (png_uint_32)(255 - png_ptr->trans[i]) +
               127) / 255);
            palette[i].green = (png_byte)((
               (png_uint_32)(palette[i].green) *
               (png_uint_32)(png_ptr->trans[i]) +
               (png_uint_32)(back.green) *
               (png_uint_32)(255 - png_ptr->trans[i]) +
               127) / 255);
            palette[i].blue = (png_byte)((
               (png_uint_32)(palette[i].blue) *
               (png_uint_32)(png_ptr->trans[i]) +
               (png_uint_32)(back.blue) *
               (png_uint_32)(255 - png_ptr->trans[i]) +
               127) / 255);
         }
      }
   }
#endif

#if defined(PNG_READ_SHIFT_SUPPORTED)
   if ((png_ptr->transformations & PNG_SHIFT) &&
      color_type == PNG_COLOR_TYPE_PALETTE)
   {
      png_uint_16 i;
      int sr, sg, sb;

      sr = 8 - png_ptr->sig_bit.red;
      if (sr < 0 || sr > 8)
         sr = 0;
      sg = 8 - png_ptr->sig_bit.green;
      if (sg < 0 || sg > 8)
         sg = 0;
      sb = 8 - png_ptr->sig_bit.blue;
      if (sb < 0 || sb > 8)
         sb = 0;
      for (i = 0; i < png_ptr->num_palette; i++)
      {
         png_ptr->palette[i].red >>= sr;
         png_ptr->palette[i].green >>= sg;
         png_ptr->palette[i].blue >>= sb;
      }
   }
#endif
}

/* modify the info structure to reflect the transformations.  The
   info should be updated so a png file could be written with it,
   assuming the transformations result in valid png data */
void
png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
{
#if defined(PNG_READ_EXPAND_SUPPORTED)
   if ((png_ptr->transformations & PNG_EXPAND) &&
      info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
   {
      if (png_ptr->num_trans)
         info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
      else
         info_ptr->color_type = PNG_COLOR_TYPE_RGB;
      info_ptr->bit_depth = 8;
      info_ptr->num_trans = 0;
   }
   else if (png_ptr->transformations & PNG_EXPAND)
   {
      if (png_ptr->num_trans)
         info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
      if (info_ptr->bit_depth < 8)
         info_ptr->bit_depth = 8;
      info_ptr->num_trans = 0;
   }
#endif

#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   if (png_ptr->transformations & PNG_BACKGROUND)
   {
      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
      info_ptr->num_trans = 0;
      info_ptr->background = png_ptr->background;
   }
#endif

#if defined(PNG_READ_16_TO_8_SUPPORTED)
   if ((png_ptr->transformations & PNG_16_TO_8) && info_ptr->bit_depth == 16)
      info_ptr->bit_depth = 8;
#endif

#if defined(PNG_READ_DITHER_SUPPORTED)
   if (png_ptr->transformations & PNG_DITHER)
   {
      if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
         (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
         png_ptr->palette_lookup && info_ptr->bit_depth == 8)
      {
         info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
      }
   }
#endif