pngwrite.c

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

            }
            break;
         case 1:
            if ((png_ptr->row_number & 7) || png_ptr->width < 5)
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
         case 2:
            if ((png_ptr->row_number & 7) != 4)
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
         case 3:
            if ((png_ptr->row_number & 3) || png_ptr->width < 3)
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
         case 4:
            if ((png_ptr->row_number & 3) != 2)
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
         case 5:
            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
         case 6:
            if (!(png_ptr->row_number & 1))
            {
               png_write_finish_row(png_ptr);
               return;
            }
            break;
      }
   }
#endif

   /* set up row info for transformations */
   png_ptr->row_info.color_type = png_ptr->color_type;
   png_ptr->row_info.width = png_ptr->usr_width;
   png_ptr->row_info.channels = png_ptr->usr_channels;
   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
      png_ptr->row_info.channels);
   png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
      (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);

   /* copy users row into buffer, leaving room for filter byte */
   png_memcpy(png_ptr->row_buf + 1, row, (png_size_t)png_ptr->row_info.rowbytes);

#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
   /* handle interlacing */
   if (png_ptr->interlaced && png_ptr->pass < 6 &&
      (png_ptr->transformations & PNG_INTERLACE))
   {
      png_do_write_interlace(&(png_ptr->row_info),
         png_ptr->row_buf + 1, png_ptr->pass);
      /* this should always get caught above, but still ... */
      if (!(png_ptr->row_info.width))
      {
         png_write_finish_row(png_ptr);
         return;
      }
   }
#endif

   /* handle other transformations */
   if (png_ptr->transformations)
      png_do_write_transformations(png_ptr);

   /* find a filter if necessary, filter the row and write it out */
   png_write_find_filter(png_ptr, &(png_ptr->row_info));
}

#if defined(PNG_WRITE_FLUSH_SUPPORTED)
/* Set the automatic flush interval or 0 to turn flushing off */
void
png_set_flush(png_structp png_ptr, int nrows)
{
   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
}

/* flush the current output buffers now */
void
png_write_flush(png_structp png_ptr)
{
   int wrote_IDAT;

   /* We have already written out all of the data */
   if (png_ptr->row_number >= png_ptr->num_rows)
     return;

   do
   {
      int ret;

      /* compress the data */
      ret = deflate(png_ptr->zstream, Z_SYNC_FLUSH);
      wrote_IDAT = 0;

      /* check for compression errors */
      if (ret != Z_OK)
      {
         if (png_ptr->zstream->msg)
            png_error(png_ptr, png_ptr->zstream->msg);
         else
            png_error(png_ptr, "zlib error");
      }

      if (!png_ptr->zstream->avail_out)
      {
         /* write the IDAT and reset the zlib output buffer */
         png_write_IDAT(png_ptr, png_ptr->zbuf,
                        png_ptr->zbuf_size);
         png_ptr->zstream->next_out = png_ptr->zbuf;
         png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
         wrote_IDAT = 1;
      }
   } while(wrote_IDAT == 1);

   /* If there is any data left to be output, write it into a new IDAT */
   if (png_ptr->zbuf_size != png_ptr->zstream->avail_out)
   {
      /* write the IDAT and reset the zlib output buffer */
      png_write_IDAT(png_ptr, png_ptr->zbuf,
                     png_ptr->zbuf_size - png_ptr->zstream->avail_out);
      png_ptr->zstream->next_out = png_ptr->zbuf;
      png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
   }
   png_ptr->flush_rows = 0;
   png_flush(png_ptr);
}
#endif /* PNG_WRITE_FLUSH_SUPPORTED */

/* free all memory used by the write */
void
png_destroy_write_struct(png_structpp png_ptr, png_infopp info_ptr)
{
   if (info_ptr && *info_ptr)
   {
      png_destroy_struct((voidp)*info_ptr);
      *info_ptr = (png_infop)NULL;
   }

   if (png_ptr && *png_ptr)
   {
      png_write_destroy(*png_ptr);
      png_destroy_struct((voidp)*png_ptr);
      *png_ptr = (png_structp)NULL;
   }
}


/* free any memory used in png struct (old) */
void
png_write_destroy(png_structp png_ptr)
{
   jmp_buf tmp_jmp; /* save jump buffer */
   png_error_ptr error_fn;
   png_error_ptr warning_fn;
   png_voidp error_ptr;

   /* free any memory zlib uses */
   deflateEnd(png_ptr->zstream);
   png_free(png_ptr, png_ptr->zstream);

   /* free our memory.  png_free checks NULL for us. */
   png_large_free(png_ptr, png_ptr->zbuf);
   png_large_free(png_ptr, png_ptr->row_buf);
   png_large_free(png_ptr, png_ptr->prev_row);
   png_large_free(png_ptr, png_ptr->sub_row);
   png_large_free(png_ptr, png_ptr->up_row);
   png_large_free(png_ptr, png_ptr->avg_row);
   png_large_free(png_ptr, png_ptr->paeth_row);

   /* reset structure */
   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));

   error_fn = png_ptr->error_fn;
   warning_fn = png_ptr->warning_fn;
   error_ptr = png_ptr->error_ptr;

   png_memset(png_ptr, 0, sizeof (png_struct));

   png_ptr->error_fn = error_fn;
   png_ptr->warning_fn = warning_fn;
   png_ptr->error_ptr = error_ptr;

   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
}

/* Allow the application to select one or more filters to use */
void
png_set_filter(png_structp png_ptr, int method, int filters)
{
   /* We allow 'method' only for future expansion of the base filter method */
   if (method == 0)
   {
      switch (filters & (PNG_ALL_FILTERS | 0x07))
      {
         case 5:
         case 6:
         case 7: png_warning(png_ptr, "Unknown custom row filter for method 0");
         case 0: png_ptr->do_filter = PNG_FILTER_NONE; break;
         case 1: png_ptr->do_filter = PNG_FILTER_SUB; break;
         case 2: png_ptr->do_filter = PNG_FILTER_UP; break;
         case 3: png_ptr->do_filter = PNG_FILTER_AVG; break;
         case 4: png_ptr->do_filter = PNG_FILTER_PAETH; break;
         default: png_ptr->do_filter = (png_byte)filters; break;
      }

      /* If we have allocated the row_buf, then we should have also allocated
       * all of the filter buffers that have been selected.
       */
      if (png_ptr->row_buf)
      {
         if (png_ptr->do_filter & PNG_FILTER_SUB && !(png_ptr->sub_row))
         {
            png_ptr->sub_row = (png_bytep )png_large_malloc(png_ptr,
               png_ptr->rowbytes + 1);
            png_ptr->sub_row[0] = 1;  /* Set the row filter type */
         }

         if (png_ptr->do_filter & PNG_FILTER_UP && !(png_ptr->up_row))
         {
            if (!(png_ptr->prev_row))
            {
               png_warning(png_ptr, "Can't to add up filter after starting");
               png_ptr->do_filter &= ~PNG_FILTER_UP;
            }
            else
            {
               png_ptr->up_row = (png_bytep )png_large_malloc(png_ptr,
                  png_ptr->rowbytes + 1);
               png_ptr->up_row[0] = 2;  /* Set the row filter type */
            }
         }

         if (png_ptr->do_filter & PNG_FILTER_AVG && !(png_ptr->avg_row))
         {
            if (!(png_ptr->prev_row))
            {
               png_warning(png_ptr, "Can't add average filter after starting");
               png_ptr->do_filter &= ~PNG_FILTER_AVG;
            }
            else
            {
               png_ptr->up_row = (png_bytep )png_large_malloc(png_ptr,
                  png_ptr->rowbytes + 1);
               png_ptr->up_row[0] = 3;  /* Set the row filter type */
            }
         }

         if (png_ptr->do_filter & PNG_FILTER_PAETH && !(png_ptr->paeth_row))
         {
            if (!(png_ptr->prev_row))
            {
               png_warning(png_ptr, "Can't add Paeth filter after starting");
               png_ptr->do_filter &= ~PNG_FILTER_PAETH;
            }
            else
            {
               png_ptr->paeth_row = (png_bytep )png_large_malloc(png_ptr,
                  png_ptr->rowbytes + 1);
               png_ptr->paeth_row[0] = 4;  /* Set the row filter type */
            }
         }

         if (png_ptr->do_filter == PNG_NO_FILTERS)
            png_ptr->do_filter = PNG_FILTER_NONE;
      }
   }
   else
     png_error(png_ptr, "Unknown custom filter method");
}

void
png_set_compression_level(png_structp png_ptr, int level)
{
   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
   png_ptr->zlib_level = level;
}

void
png_set_compression_mem_level(png_structp png_ptr, int mem_level)
{
   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
   png_ptr->zlib_mem_level = mem_level;
}

void
png_set_compression_strategy(png_structp png_ptr, int strategy)
{
   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
   png_ptr->zlib_strategy = strategy;
}

void
png_set_compression_window_bits(png_structp png_ptr, int window_bits)
{
   if (window_bits > 15)
      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
   png_ptr->zlib_window_bits = window_bits;
}

void
png_set_compression_method(png_structp png_ptr, int method)
{
   if (method != 8)
      png_warning(png_ptr, "Only compression method 8 is supported by PNG");
   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
   png_ptr->zlib_method = method;
}