pngpread.c

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

/* pngpread.c - read a png file in push mode

   libpng 1.0 beta 3 - version 0.89
   For conditions of distribution and use, see copyright notice in png.h
   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
   May 25, 1996
   */

#define PNG_INTERNAL
#include "png.h"

#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

void
png_process_data(png_structp png_ptr, png_infop info,
   png_bytep buffer, png_uint_32 buffer_size)
{
   png_push_restore_buffer(png_ptr, buffer, buffer_size);

   while (png_ptr->buffer_size)
   {
      png_process_some_data(png_ptr, info);
   }
}

void
png_process_some_data(png_structp png_ptr, png_infop info)
{
   switch (png_ptr->process_mode)
   {
      case PNG_READ_SIG_MODE:
      {
         png_push_read_sig(png_ptr);
         break;
      }
      case PNG_READ_CHUNK_MODE:
      {
         png_push_read_chunk(png_ptr, info);
         break;
      }
      case PNG_READ_IDAT_MODE:
      {
         png_push_read_IDAT(png_ptr);
         break;
      }
      case PNG_READ_PLTE_MODE:
      {
         png_push_read_PLTE(png_ptr, info);
         break;
      }
#if defined(PNG_READ_tEXt_SUPPORTED)
      case PNG_READ_tEXt_MODE:
      {
         png_push_read_tEXt(png_ptr, info);
         break;
      }
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
      case PNG_READ_zTXt_MODE:
      {
         png_push_read_zTXt(png_ptr, info);
         break;
      }
#endif
      case PNG_READ_END_MODE:
      {
         png_push_read_end(png_ptr, info);
         break;
      }
      case PNG_SKIP_MODE:
      {
         png_push_skip(png_ptr);
         break;
      }
      default:
      {
         png_ptr->buffer_size = 0;
         break;
      }
   }
}

void
png_push_read_sig(png_structp png_ptr)
{
   png_byte sig[8];

   if (png_ptr->buffer_size < 8)
   {
      png_push_save_buffer(png_ptr);
      return;
   }

   png_push_fill_buffer(png_ptr, sig, 8);

   if (png_check_sig(sig, 8))
   {
      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
   }
   else
   {
      png_error(png_ptr, "Not a PNG file");
   }
}

void
png_push_read_chunk(png_structp png_ptr, png_infop info)
{
   if (!(png_ptr->flags & PNG_FLAG_HAVE_CHUNK_HEADER))
   {
      png_byte chunk_start[8];

      if (png_ptr->buffer_size < 8)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      png_push_fill_buffer(png_ptr, chunk_start, 8);
      png_ptr->push_length = png_get_uint_32(chunk_start);
      png_memcpy(png_ptr->push_chunk_name, (png_voidp)(chunk_start + 4), 4);
      png_ptr->flags |= PNG_FLAG_HAVE_CHUNK_HEADER;
      png_reset_crc(png_ptr);
      png_calculate_crc(png_ptr, chunk_start + 4, 4);
   }

   if (!png_memcmp(png_ptr->push_chunk_name, png_IHDR, 4))
   {
      if (png_ptr->mode != PNG_BEFORE_IHDR)
         png_error(png_ptr, "Out of place IHDR");

      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      png_handle_IHDR(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
      png_ptr->mode = PNG_HAVE_IHDR;
   }
   else if (!png_memcmp(png_ptr->push_chunk_name, png_PLTE, 4))
   {
      if (png_ptr->mode != PNG_HAVE_IHDR)
         png_error(png_ptr, "Missing IHDR");

#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
         png_push_crc_skip(png_ptr, length);
      else
#else
      {
         png_push_handle_PLTE(png_ptr, png_ptr->push_length);
      }
#endif
      png_ptr->mode = PNG_HAVE_PLTE;
   }
   else if (!png_memcmp(png_ptr->push_chunk_name, png_IDAT, 4))
   {
      png_ptr->idat_size = png_ptr->push_length;
      png_ptr->mode = PNG_HAVE_IDAT;
      png_ptr->process_mode = PNG_READ_IDAT_MODE;
      png_push_have_info(png_ptr, info);
      png_ptr->zstream->avail_out = (uInt)png_ptr->irowbytes;
      png_ptr->zstream->next_out = png_ptr->row_buf;
      return;
   }
   else if (!png_memcmp(png_ptr->push_chunk_name, png_IEND, 4))
   {
      png_error(png_ptr, "No image in file");
   }
#if defined(PNG_READ_gAMA_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_gAMA, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR)
         png_error(png_ptr, "Out of place gAMA");

      png_handle_gAMA(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_sBIT_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_sBIT, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR)
         png_error(png_ptr, "Out of place sBIT");

      png_handle_sBIT(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_cHRM_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_cHRM, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR)
         png_error(png_ptr, "Out of place cHRM");

      png_handle_cHRM(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_tRNS_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_tRNS, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }
      if (png_ptr->mode != PNG_HAVE_IHDR &&
         png_ptr->mode != PNG_HAVE_PLTE)
         png_error(png_ptr, "Out of place tRNS");

      png_handle_tRNS(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_bKGD_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_bKGD, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR &&
         png_ptr->mode != PNG_HAVE_PLTE)
         png_error(png_ptr, "Out of place bKGD");

      png_handle_bKGD(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_hIST, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_PLTE)
         png_error(png_ptr, "Out of place hIST");

      png_handle_hIST(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_pHYs_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_pHYs, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR &&
         png_ptr->mode != PNG_HAVE_PLTE)
         png_error(png_ptr, "Out of place pHYs");

      png_handle_pHYs(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_oFFs_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_oFFs, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode != PNG_HAVE_IHDR &&
         png_ptr->mode != PNG_HAVE_PLTE)
         png_error(png_ptr, "Out of place oFFs");

      png_handle_oFFs(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_tIME_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_tIME, 4))
   {
      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
      {
         png_push_save_buffer(png_ptr);
         return;
      }

      if (png_ptr->mode == PNG_BEFORE_IHDR ||
         png_ptr->mode == PNG_AFTER_IEND)
         png_error(png_ptr, "Out of place tIME");

      png_handle_tIME(png_ptr, info, png_ptr->push_length);
      png_push_check_crc(png_ptr);
   }
#endif
#if defined(PNG_READ_tEXt_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_tEXt, 4))
   {
      if (png_ptr->mode == PNG_BEFORE_IHDR ||
         png_ptr->mode == PNG_AFTER_IEND)
         png_error(png_ptr, "Out of place tEXt");

      png_push_handle_tEXt(png_ptr, png_ptr->push_length);
   }
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
   else if (!png_memcmp(png_ptr->push_chunk_name, png_zTXt, 4))
   {
      if (png_ptr->mode == PNG_BEFORE_IHDR ||
         png_ptr->mode == PNG_AFTER_IEND)
         png_error(png_ptr, "Out of place zTXt");

      png_push_handle_zTXt(png_ptr, png_ptr->push_length);
   }
#endif
   else
   {
      if (png_ptr->push_chunk_name[0] <41 || png_ptr->push_chunk_name[0]> 122 ||
          (png_ptr->push_chunk_name[0]>90 && png_ptr->push_chunk_name[0]< 97) ||
          png_ptr->push_chunk_name[1] <41 || png_ptr->push_chunk_name[1]> 122 ||
          (png_ptr->push_chunk_name[1]>90 && png_ptr->push_chunk_name[1]< 97) ||
          png_ptr->push_chunk_name[2] <41 || png_ptr->push_chunk_name[2]> 122 ||
          (png_ptr->push_chunk_name[2]>90 && png_ptr->push_chunk_name[2]< 97) ||
          png_ptr->push_chunk_name[3] <41 || png_ptr->push_chunk_name[3]> 122 ||
          (png_ptr->push_chunk_name[3]>90 && png_ptr->push_chunk_name[3]< 97))
      {
         char msg[200];

         sprintf(msg, "Invalid chunk type 0x%02X 0x%02X 0x%02X 0x%02X",
            png_ptr->push_chunk_name[0], png_ptr->push_chunk_name[1],
            png_ptr->push_chunk_name[2], png_ptr->push_chunk_name[3]);
         png_error(png_ptr, msg);
      }

      if ((png_ptr->push_chunk_name[0] & 0x20) == 0)
      {
         char msg[200];

         sprintf(msg, "Unknown critical chunk %c%c%c%c",
            png_ptr->push_chunk_name[0], png_ptr->push_chunk_name[1],
            png_ptr->push_chunk_name[2], png_ptr->push_chunk_name[3]);
         png_error(png_ptr, msg);
      }

      png_push_crc_skip(png_ptr, png_ptr->push_length);
   }
   png_ptr->flags &= ~PNG_FLAG_HAVE_CHUNK_HEADER;
}

void
png_push_check_crc(png_structp png_ptr)
{
   png_byte crc_buf[4];
   png_uint_32 crc;

   png_push_fill_buffer(png_ptr, crc_buf, 4);
   crc = png_get_uint_32(crc_buf);
   if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
      (png_ptr->crc & 0xffffffffL))
      png_error(png_ptr, "Bad CRC value");
}

void
png_push_crc_skip(png_structp png_ptr, png_uint_32 length)
{
   png_ptr->process_mode = PNG_SKIP_MODE;
   png_ptr->skip_length = length;
}

void
png_push_skip(png_structp png_ptr)
{
   if (png_ptr->skip_length && png_ptr->save_buffer_size)
   {
      png_uint_32 save_size;

      if (png_ptr->skip_length < png_ptr->save_buffer_size)
         save_size = png_ptr->skip_length;
      else
         save_size = png_ptr->save_buffer_size;

      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

      png_ptr->skip_length -= save_size;
      png_ptr->buffer_size -= save_size;
      png_ptr->save_buffer_size -= save_size;
      png_ptr->save_buffer_ptr += (png_size_t)save_size;
   }
   if (png_ptr->skip_length && png_ptr->current_buffer_size)
   {
      png_uint_32 save_size;

      if (png_ptr->skip_length < png_ptr->current_buffer_size)
         save_size = png_ptr->skip_length;
      else
         save_size = png_ptr->current_buffer_size;

      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

      png_ptr->skip_length -= save_size;
      png_ptr->buffer_size -= save_size;
      png_ptr->current_buffer_size -= save_size;
      png_ptr->current_buffer_ptr += (png_size_t)save_size;
   }
   if (!png_ptr->skip_length)
   {
      if (png_ptr->buffer_size < 4)
      {
         png_push_save_buffer(png_ptr);
         return;
      }
      png_push_check_crc(png_ptr);
      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
   }
}

void