Imported from libpng-0.96.tar

pngtest.c

@@ -1,14 +1,21 @@
 
 /* pngtest.c - a simple test program to test libpng
 
-   libpng 1.0 beta 4 - version 0.90
+   libpng 1.0 beta 6 - version 0.96
    For conditions of distribution and use, see copyright notice in png.h
    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
-   January 10, 1997
-*/
+   Copyright (c) 1996, 1997 Andreas Dilger
+   May 12, 1997
+   */
 
 #include <stdio.h>
 #include <stdlib.h>
+
+/* Makes pngtest verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#define PNG_DEBUG 0
+#endif
+
 #include "png.h"
 
 #ifdef __TURBOC__
@@ -30,23 +37,21 @@ char *outname = "pngout.png";
 
 char inbuf[256], outbuf[256];
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
    FILE *fpin, *fpout;
-   png_structp read_ptr;
-   png_structp write_ptr;
-   png_infop info_ptr;
-   png_infop end_info;
+   png_structp read_ptr, write_ptr;
+   png_infop read_info_ptr, write_info_ptr, end_info_ptr;
    png_bytep row_buf;
-   png_byte *near_row_buf;
-   png_uint_32 rowbytes;
    png_uint_32 y;
-   int channels, num_pass, pass;
+   png_uint_32 width, height;
+   int num_pass, pass;
+   int bit_depth, color_type;
 #ifdef USE_FAR_KEYWORD
    jmp_buf jmpbuf;
 #endif   
    row_buf = (png_bytep)NULL;
-   near_row_buf = (png_byte *)NULL;
 
    fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
 
@@ -70,28 +75,30 @@ int main(int argc, char *argv[])
      exit(1);
    }
 
-   fpin = fopen(inname, "rb");
-   if (!fpin)
+   if ((fpin = fopen(inname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find input file %s\n", inname);
       return 1;
    }
 
-   fpout = fopen(outname, "wb");
-   if (!fpout)
+   if ((fpout = fopen(outname, "wb")) == NULL)
    {
       fprintf(STDERR, "Could not open output file %s\n", outname);
       fclose(fpin);
       return 1;
    }
 
+   png_debug(0, "Allocating read and write structures\n");
    read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
-      (png_error_ptr)NULL,  (png_error_ptr)NULL);
+      (png_error_ptr)NULL, (png_error_ptr)NULL);
    write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
       (png_error_ptr)NULL, (png_error_ptr)NULL);
-   info_ptr = png_create_info_struct(read_ptr);
-   end_info = png_create_info_struct(read_ptr);
+   png_debug(0, "Allocating read_info, write_info and end_info structures\n");
+   read_info_ptr = png_create_info_struct(read_ptr);
+   write_info_ptr = png_create_info_struct(read_ptr);
+   end_info_ptr = png_create_info_struct(read_ptr);
 
+   png_debug(0, "Setting jmpbuf for read struct\n");
 #ifdef USE_FAR_KEYWORD
    if (setjmp(jmpbuf))
 #else
@@ -99,12 +106,14 @@ int main(int argc, char *argv[])
 #endif
    {
       fprintf(STDERR, "libpng read error\n");
-      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
-      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+      png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
+
+   png_debug(0, "Setting jmpbuf for write struct\n");
 #ifdef USE_FAR_KEYWORD
    png_memcpy(read_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
    if (setjmp(jmpbuf))
@@ -113,92 +122,227 @@ int main(int argc, char *argv[])
 #endif
    {
       fprintf(STDERR, "libpng write error\n");
-      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
-      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+      png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
+
 #ifdef USE_FAR_KEYWORD
    png_memcpy(write_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
 #endif
+   png_debug(0, "Initializing input and output streams\n");
    png_init_io(read_ptr, fpin);
    png_init_io(write_ptr, fpout);
 
-   png_read_info(read_ptr, info_ptr);
-   png_write_info(write_ptr, info_ptr);
+   png_debug(0, "Reading info struct\n");
+   png_read_info(read_ptr, read_info_ptr);
 
-   if ((info_ptr->color_type & PNG_COLOR_TYPE_PALETTE)==PNG_COLOR_TYPE_PALETTE)
-      channels = 1;
-   else
-      channels = 3;
-   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
-      channels++;
+   png_debug(0, "Transferring info struct\n");
+   {
+      int interlace_type, compression_type, filter_type;
 
-   rowbytes = ((info_ptr->width * info_ptr->bit_depth * channels + 7) >> 3);
-   near_row_buf = (png_byte *)malloc((size_t)rowbytes);
-   row_buf = (png_bytep)near_row_buf;
-   if (!row_buf)
+      if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
+          &color_type, &interlace_type, &compression_type, &filter_type))
+      {
+         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
+            color_type, interlace_type, compression_type, filter_type);
+      }
+   }
+#if defined(PNG_READ_bKGD_SUPPORTED) && defined(PNG_WRITE_bKGD_SUPPORTED)
+   {
+      png_color_16p background;
+
+      if (png_get_bKGD(read_ptr, read_info_ptr, &background))
+      {
+         png_set_bKGD(write_ptr, write_info_ptr, background);
+      }
+   }
+#endif
+#if defined(PNG_READ_cHRM_SUPPORTED) && defined(PNG_WRITE_cHRM_SUPPORTED)
+   {
+      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
+
+      if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
+         &red_y, &green_x, &green_y, &blue_x, &blue_y))
+      {
+         png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
+            red_y, green_x, green_y, blue_x, blue_y);
+      }
+   }
+#endif
+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_WRITE_gAMA_SUPPORTED)
+   {
+      double gamma;
+
+      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
+      {
+         png_set_gAMA(write_ptr, write_info_ptr, gamma);
+      }
+   }
+#endif
+#if defined(PNG_READ_hIST_SUPPORTED) && defined(PNG_WRITE_hIST_SUPPORTED)
+   {
+      png_uint_16p hist;
+
+      if (png_get_hIST(read_ptr, read_info_ptr, &hist))
+      {
+         png_set_hIST(write_ptr, write_info_ptr, hist);
+      }
+   }
+#endif
+#if defined(PNG_READ_oFFs_SUPPORTED) && defined(PNG_WRITE_oFFs_SUPPORTED)
+   {
+      png_uint_32 offset_x, offset_y;
+      int unit_type;
+
+      if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type))
+      {
+         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
+      }
+   }
+#endif
+#if defined(PNG_READ_pCAL_SUPPORTED) && defined(PNG_WRITE_pCAL_SUPPORTED)
+   {
+      png_charp purpose, units;
+      png_charpp params;
+      png_int_32 X0, X1;
+      int type, nparams;
+
+      if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
+         &nparams, &units, &params))
+      {
+         png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
+            nparams, units, params);
+      }
+   }
+#endif
+#if defined(PNG_READ_pHYs_SUPPORTED) && defined(PNG_WRITE_pHYs_SUPPORTED)
+   {
+      png_uint_32 res_x, res_y;
+      int unit_type;
+
+      if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
+      {
+         png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
+      }
+   }
+#endif
+   {
+      png_colorp palette;
+      int num_palette;
+
+      if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
+      {
+         png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
+      }
+   }
+#if defined(PNG_READ_sBIT_SUPPORTED) && defined(PNG_WRITE_sBIT_SUPPORTED)
+   {
+      png_color_8p sig_bit;
+
+      if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
+      {
+         png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
+      }
+   }
+#endif
+#if (defined(PNG_READ_tEXt_SUPPORTED) && defined(PNG_WRITE_tEXt_SUPPORTED)) || \
+    (defined(PNG_READ_zTXt_SUPPORTED) && defined(PNG_WRITE_zTXt_SUPPORTED))
+   {
+      png_textp text_ptr;
+      int num_text;
+
+      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
+      {
+         png_debug1(0, "Handling %d tEXt/zTXt chunks\n", num_text);
+         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
+      }
+   }
+#endif
+#if defined(PNG_READ_tIME_SUPPORTED) && defined(PNG_WRITE_tIME_SUPPORTED)
+   {
+      png_timep mod_time;
+
+      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
+      {
+         png_set_tIME(write_ptr, write_info_ptr, mod_time);
+      }
+   }
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED) && defined(PNG_WRITE_tRNS_SUPPORTED)
+   {
+      png_bytep trans;
+      int num_trans;
+      png_color_16p trans_values;
+
+      if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,
+         &trans_values))
+      {
+         png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
+            trans_values);
+      }
+   }
+#endif
+
+   png_debug(0, "\nWriting info struct\n");
+   png_write_info(write_ptr, write_info_ptr);
+
+   row_buf = (png_bytep)png_malloc(read_ptr, 
+      png_get_rowbytes(read_ptr, read_info_ptr));
+   if (row_buf == NULL)
    {
       fprintf(STDERR, "No memory to allocate row buffer\n");
-      png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
-      png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
+      png_destroy_read_struct(&read_ptr, &read_info_ptr, (png_infopp)NULL);
+      png_destroy_write_struct(&write_ptr, &write_info_ptr);
       fclose(fpin);
       fclose(fpout);
       return 1;
    }
 
-   if (info_ptr->interlace_type)
-   {
-      num_pass = png_set_interlace_handling(read_ptr);
-      num_pass = png_set_interlace_handling(write_ptr);
-   }
-   else
-   {
-      num_pass = 1;
-   }
+   num_pass = png_set_interlace_handling(read_ptr);
+   png_set_interlace_handling(write_ptr);
 
    for (pass = 0; pass < num_pass; pass++)
    {
-      for (y = 0; y < info_ptr->height; y++)
+      for (y = 0; y < height; y++)
       {
-#ifdef TESTING
-         fprintf(STDERR, "Processing line #%ld\n", y);
-#endif
-         png_read_rows(read_ptr, (png_bytepp)&row_buf, (png_bytepp)0, 1);
+         png_read_rows(read_ptr, (png_bytepp)&row_buf, (png_bytepp)NULL, 1);
          png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
       }
    }
 
-   png_read_end(read_ptr, end_info);
-   png_write_end(write_ptr, end_info);
+   png_debug(0, "Reading and writing end_info data\n");
+   png_read_end(read_ptr, end_info_ptr);
+   png_write_end(write_ptr, end_info_ptr);
 
-   png_destroy_read_struct(&read_ptr, &info_ptr, &end_info);
-   png_destroy_write_struct(&write_ptr, (png_infopp)NULL);
+   png_debug(0, "Destroying data structs\n");
+   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
+   png_destroy_write_struct(&write_ptr, &write_info_ptr);
 
    fclose(fpin);
    fclose(fpout);
 
-   free((png_byte *)near_row_buf);
+   png_free(read_ptr, row_buf);
 
-   fpin = fopen(inname, "rb");
-
-   if (!fpin)
+   png_debug(0, "Opening files for comparison\n");
+   if ((fpin = fopen(inname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find file %s\n", inname);
       return 1;
    }
 
-   fpout = fopen(outname, "rb");
-   if (!fpout)
+   if ((fpout = fopen(outname, "rb")) == NULL)
    {
       fprintf(STDERR, "Could not find file %s\n", outname);
       fclose(fpin);
       return 1;
    }
+
    while (1)
    {
-      int num_in, num_out;
+      png_size_t num_in, num_out;
 
       num_in = fread(inbuf, 1, 1, fpin);
       num_out = fread(outbuf, 1, 1, fpout);
@@ -215,7 +359,7 @@ int main(int argc, char *argv[])
       if (!num_in)
          break;
 
-      if (memcmp(inbuf, outbuf, num_in))
+      if (png_memcmp(inbuf, outbuf, num_in))
       {
          fprintf(STDERR, "Files %s and %s are different\n", inname, outname);
          fclose(fpin);