COSMOS core  1.0.2 (beta)
Comprehensive Open-architecture Solution for Mission Operations Systems
Classes | Macros | Typedefs | Functions | Variables
pngtest.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "png.h"
#include "thirdparty/zlib/zlib.h"
Include dependency graph for pngtest.c:

Classes

struct  pngtest_error_parameters
 
struct  user_chunk_data
 

Macros

#define _POSIX_SOURCE   1
 
#define STDERR   stdout /* For DOS */
 
#define FCLOSE(file)   fclose(file)
 
#define PNG_DEBUG   0
 
#define pngtest_debug(m)   ((void)0)
 
#define pngtest_debug1(m, p1)   ((void)0)
 
#define pngtest_debug2(m, p1, p2)   ((void)0)
 
#define SINGLE_ROWBUF_ALLOC   /* Makes buffer overruns easier to nail */
 
#define PNG_tIME_STRING_LENGTH   29
 
#define MEMZERO(var)   ((void)memset(&var, 0, sizeof var))
 
#define have_sTER   0x01
 
#define have_vpAg   0x02
 
#define before_PLTE   0x10
 
#define before_IDAT   0x20
 
#define after_IDAT   0x40
 

Typedefs

typedef png_libpng_version_1_6_16 Your_png_h_is_not_version_1_6_16
 

Functions

static void read_row_callback (png_structp png_ptr, png_uint_32 row_number, int pass)
 
static void write_row_callback (png_structp png_ptr, png_uint_32 row_number, int pass)
 
static void count_filters (png_structp png_ptr, png_row_infop row_info, png_bytep data)
 
static void count_zero_samples (png_structp png_ptr, png_row_infop row_info, png_bytep data)
 
static void pngtest_warning (png_structp png_ptr, png_const_charp message)
 
static void pngtest_error (png_structp png_ptr, png_const_charp message)
 
static void init_callback_info (png_const_infop info_ptr)
 
static int set_location (png_structp png_ptr, struct user_chunk_data *data, int what)
 
static int read_user_chunk_callback (png_struct *png_ptr, png_unknown_chunkp chunk)
 
static void write_sTER_chunk (png_structp write_ptr)
 
static void write_vpAg_chunk (png_structp write_ptr)
 
static void write_chunks (png_structp write_ptr, int location)
 
static void pngtest_check_text_support (png_const_structp png_ptr, png_textp text_ptr, int num_text)
 
static int test_one_file (const char *inname, const char *outname)
 
int main (int argc, char *argv[])
 

Variables

static int tIME_chunk_present = 0
 
static char tIME_string [29] = "tIME chunk is not present"
 
static int verbose = 0
 
static int strict = 0
 
static int relaxed = 0
 
static int unsupported_chunks = 0
 
static int error_count = 0
 
static int warning_count = 0
 
static int status_pass = 1
 
static int status_dots_requested = 0
 
static int status_dots = 1
 
static png_uint_32 filters_used [256]
 
static png_uint_32 zero_samples
 
static struct user_chunk_data user_chunk_data
 
static const char * inname = "pngtest.png"
 
static const char * outname = "pngout.png"
 

Macro Definition Documentation

#define _POSIX_SOURCE   1
#define STDERR   stdout /* For DOS */
#define FCLOSE (   file)    fclose(file)
#define PNG_DEBUG   0
#define pngtest_debug (   m)    ((void)0)
#define pngtest_debug1 (   m,
  p1 
)    ((void)0)
#define pngtest_debug2 (   m,
  p1,
  p2 
)    ((void)0)
#define SINGLE_ROWBUF_ALLOC   /* Makes buffer overruns easier to nail */
#define PNG_tIME_STRING_LENGTH   29
#define MEMZERO (   var)    ((void)memset(&var, 0, sizeof var))
#define have_sTER   0x01
#define have_vpAg   0x02
#define before_PLTE   0x10
#define before_IDAT   0x20
#define after_IDAT   0x40

Typedef Documentation

typedef png_libpng_version_1_6_16 Your_png_h_is_not_version_1_6_16

Function Documentation

static void read_row_callback ( png_structp  png_ptr,
png_uint_32  row_number,
int  pass 
)
static
153 {
154  if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
155  return;
156 
157  if (status_pass != pass)
158  {
159  fprintf(stdout, "\n Pass %d: ", pass);
160  status_pass = pass;
161  status_dots = 31;
162  }
163 
164  status_dots--;
165 
166  if (status_dots == 0)
167  {
168  fprintf(stdout, "\n ");
169  status_dots=30;
170  }
171 
172  fprintf(stdout, "r");
173 }
PNG_UINT_31_MAX
#define PNG_UINT_31_MAX
Definition: png.h:790
status_dots
static int status_dots
Definition: pngtest.c:149
status_pass
static int status_pass
Definition: pngtest.c:147
static void write_row_callback ( png_structp  png_ptr,
png_uint_32  row_number,
int  pass 
)
static
178 {
179  if (png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7)
180  return;
181 
182  fprintf(stdout, "w");
183 }
PNG_UINT_31_MAX
#define PNG_UINT_31_MAX
Definition: png.h:790
static void count_filters ( png_structp  png_ptr,
png_row_infop  row_info,
png_bytep  data 
)
static
195 {
196  if (png_ptr != NULL && row_info != NULL)
197  ++filters_used[*(data - 1)];
198 }
filters_used
static png_uint_32 filters_used[256]
Definition: pngtest.c:192
static void count_zero_samples ( png_structp  png_ptr,
png_row_infop  row_info,
png_bytep  data 
)
static
210 {
211  png_bytep dp = data;
212  if (png_ptr == NULL)
213  return;
214 
215  /* Contents of row_info:
216  * png_uint_32 width width of row
217  * png_uint_32 rowbytes number of bytes in row
218  * png_byte color_type color type of pixels
219  * png_byte bit_depth bit depth of samples
220  * png_byte channels number of channels (1-4)
221  * png_byte pixel_depth bits per pixel (depth*channels)
222  */
223 
224  /* Counts the number of zero samples (or zero pixels if color_type is 3 */
225 
226  if (row_info->color_type == 0 || row_info->color_type == 3)
227  {
228  int pos = 0;
229  png_uint_32 n, nstop;
230 
231  for (n = 0, nstop=row_info->width; n<nstop; n++)
232  {
233  if (row_info->bit_depth == 1)
234  {
235  if (((*dp << pos++ ) & 0x80) == 0)
236  zero_samples++;
237 
238  if (pos == 8)
239  {
240  pos = 0;
241  dp++;
242  }
243  }
244 
245  if (row_info->bit_depth == 2)
246  {
247  if (((*dp << (pos+=2)) & 0xc0) == 0)
248  zero_samples++;
249 
250  if (pos == 8)
251  {
252  pos = 0;
253  dp++;
254  }
255  }
256 
257  if (row_info->bit_depth == 4)
258  {
259  if (((*dp << (pos+=4)) & 0xf0) == 0)
260  zero_samples++;
261 
262  if (pos == 8)
263  {
264  pos = 0;
265  dp++;
266  }
267  }
268 
269  if (row_info->bit_depth == 8)
270  if (*dp++ == 0)
271  zero_samples++;
272 
273  if (row_info->bit_depth == 16)
274  {
275  if ((*dp | *(dp+1)) == 0)
276  zero_samples++;
277  dp+=2;
278  }
279  }
280  }
281  else /* Other color types */
282  {
283  png_uint_32 n, nstop;
284  int channel;
285  int color_channels = row_info->channels;
286  if (row_info->color_type > 3)
287  color_channels--;
288 
289  for (n = 0, nstop=row_info->width; n<nstop; n++)
290  {
291  for (channel = 0; channel < color_channels; channel++)
292  {
293  if (row_info->bit_depth == 8)
294  if (*dp++ == 0)
295  zero_samples++;
296 
297  if (row_info->bit_depth == 16)
298  {
299  if ((*dp | *(dp+1)) == 0)
300  zero_samples++;
301 
302  dp+=2;
303  }
304  }
305  if (row_info->color_type > 3)
306  {
307  dp++;
308  if (row_info->bit_depth == 16)
309  dp++;
310  }
311  }
312  }
313 }
zero_samples
static png_uint_32 zero_samples
Definition: pngtest.c:206
png_bytep
png_byte * png_bytep
Definition: pngconf.h:600
png_row_info_struct::width
png_uint_32 width
Definition: png.h:896
png_row_info_struct::color_type
png_byte color_type
Definition: png.h:898
png_row_info_struct::channels
png_byte channels
Definition: png.h:900
png_row_info_struct::bit_depth
png_byte bit_depth
Definition: png.h:899
static void pngtest_warning ( png_structp  png_ptr,
png_const_charp  message 
)
static
437 {
438  PNG_CONST char *name = "UNKNOWN (ERROR!)";
439  pngtest_error_parameters *test =
440  (pngtest_error_parameters*)png_get_error_ptr(png_ptr);
441 
442  ++warning_count;
443 
444  if (test != NULL && test->file_name != NULL)
445  name = test->file_name;
446 
447  fprintf(STDERR, "%s: libpng warning: %s\n", name, message);
448 }
pngtest_error_parameters
Definition: pngtest.c:430
warning_count
static int warning_count
Definition: pngtest.c:128
pngtest_error_parameters::file_name
const char * file_name
Definition: pngtest.c:432
PNG_CONST
#define PNG_CONST
Definition: pngconf.h:86
test
void test()
Definition: testprofiler.c:34
message
uint8_t message[300]
Definition: kpc9612p_send.cpp:36
name
string name
Definition: cubesat2obj.cpp:6
STDERR
#define STDERR
Definition: pngtest.c:42
png_get_error_ptr
PNG_IMPEXP png_voidp() png_get_error_ptr(png_const_structrp png_ptr)
Definition: pngerror.c:856
static void pngtest_error ( png_structp  png_ptr,
png_const_charp  message 
)
static
457 {
458  ++error_count;
459 
460  pngtest_warning(png_ptr, message);
461  /* We can return because png_error calls the default handler, which is
462  * actually OK in this case.
463  */
464 }
error_count
static int error_count
Definition: pngtest.c:127
message
uint8_t message[300]
Definition: kpc9612p_send.cpp:36
pngtest_warning
static void pngtest_warning(png_structp png_ptr, png_const_charp message)
Definition: pngtest.c:436
static void init_callback_info ( png_const_infop  info_ptr)
static
637 {
638  MEMZERO(user_chunk_data);
639  user_chunk_data.info_ptr = info_ptr;
640 }
user_chunk_data::info_ptr
png_const_infop info_ptr
Definition: pngtest.c:620
user_chunk_data
Definition: pngtest.c:618
MEMZERO
#define MEMZERO(var)
Definition: pngtest.c:144
static int set_location ( png_structp  png_ptr,
struct user_chunk_data *  data,
int  what 
)
static
644 {
645  int location;
646 
647  if ((data->location[0] & what) != 0 || (data->location[1] & what) != 0)
648  return 0; /* already have one of these */
649 
650  /* Find where we are (the code below zeroes info_ptr to indicate that the
651  * chunks before the first IDAT have been read.)
652  */
653  if (data->info_ptr == NULL) /* after IDAT */
654  location = what | after_IDAT;
655 
656  else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE) != 0)
657  location = what | before_IDAT;
658 
659  else
660  location = what | before_PLTE;
661 
662  if (data->location[0] == 0)
663  data->location[0] = location;
664 
665  else
666  data->location[1] = location;
667 
668  return 1; /* handled */
669 }
before_PLTE
#define before_PLTE
Definition: pngtest.c:631
user_chunk_data::location
int location[2]
Definition: pngtest.c:624
png_get_valid
PNG_IMPEXP png_uint_32() png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 flag)
Definition: pngget.c:20
user_chunk_data::info_ptr
png_const_infop info_ptr
Definition: pngtest.c:620
before_IDAT
#define before_IDAT
Definition: pngtest.c:632
PNG_INFO_PLTE
#define PNG_INFO_PLTE
Definition: png.h:876
after_IDAT
#define after_IDAT
Definition: pngtest.c:633
static int read_user_chunk_callback ( png_struct *  png_ptr,
png_unknown_chunkp  chunk 
)
static
673 {
674  struct user_chunk_data *my_user_chunk_data =
675  (struct user_chunk_data*)png_get_user_chunk_ptr(png_ptr);
676 
677  if (my_user_chunk_data == NULL)
678  png_error(png_ptr, "lost user chunk pointer");
679 
680  /* Return one of the following:
681  * return (-n); chunk had an error
682  * return (0); did not recognize
683  * return (n); success
684  *
685  * The unknown chunk structure contains the chunk data:
686  * png_byte name[5];
687  * png_byte *data;
688  * png_size_t size;
689  *
690  * Note that libpng has already taken care of the CRC handling.
691  */
692 
693  if (chunk->name[0] == 115 && chunk->name[1] == 84 && /* s T */
694  chunk->name[2] == 69 && chunk->name[3] == 82) /* E R */
695  {
696  /* Found sTER chunk */
697  if (chunk->size != 1)
698  return (-1); /* Error return */
699 
700  if (chunk->data[0] != 0 && chunk->data[0] != 1)
701  return (-1); /* Invalid mode */
702 
703  if (set_location(png_ptr, my_user_chunk_data, have_sTER) != 0)
704  {
705  my_user_chunk_data->sTER_mode=chunk->data[0];
706  return (1);
707  }
708 
709  else
710  return (0); /* duplicate sTER - give it to libpng */
711  }
712 
713  if (chunk->name[0] != 118 || chunk->name[1] != 112 || /* v p */
714  chunk->name[2] != 65 || chunk->name[3] != 103) /* A g */
715  return (0); /* Did not recognize */
716 
717  /* Found ImageMagick vpAg chunk */
718 
719  if (chunk->size != 9)
720  return (-1); /* Error return */
721 
722  if (set_location(png_ptr, my_user_chunk_data, have_vpAg) == 0)
723  return (0); /* duplicate vpAg */
724 
725  my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data);
726  my_user_chunk_data->vpAg_height = png_get_uint_31(png_ptr, chunk->data + 4);
727  my_user_chunk_data->vpAg_units = chunk->data[8];
728 
729  return (1);
730 }
user_chunk_data::vpAg_height
png_uint_32 vpAg_height
Definition: pngtest.c:621
user_chunk_data::sTER_mode
png_byte sTER_mode
Definition: pngtest.c:623
user_chunk_data::vpAg_units
png_byte vpAg_units
Definition: pngtest.c:622
have_vpAg
#define have_vpAg
Definition: pngtest.c:630
png_unknown_chunk_t::name
png_byte name[5]
Definition: png.h:765
user_chunk_data
Definition: pngtest.c:618
have_sTER
#define have_sTER
Definition: pngtest.c:629
png_get_user_chunk_ptr
PNG_IMPEXP png_voidp() png_get_user_chunk_ptr(png_const_structrp png_ptr)
Definition: pngget.c:1126
set_location
static int set_location(png_structp png_ptr, struct user_chunk_data *data, int what)
Definition: pngtest.c:643
png_get_uint_31
PNG_IMPEXP png_uint_32() png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf)
Definition: pngrutil.c:22
png_error
PNG_IMPEXP void() png_error(png_const_structrp png_ptr, png_const_charp error_message)
Definition: pngerror.c:40
png_unknown_chunk_t::data
png_byte * data
Definition: png.h:766
user_chunk_data::vpAg_width
png_uint_32 vpAg_width
Definition: pngtest.c:621
png_unknown_chunk_t::size
png_size_t size
Definition: png.h:767
static void write_sTER_chunk ( png_structp  write_ptr)
static
735 {
736  png_byte sTER[5] = {115, 84, 69, 82, '\0'};
737 
738  if (verbose != 0)
739  fprintf(STDERR, "\n stereo mode = %d\n", user_chunk_data.sTER_mode);
740 
741  png_write_chunk(write_ptr, sTER, &user_chunk_data.sTER_mode, 1);
742 }
user_chunk_data::sTER_mode
png_byte sTER_mode
Definition: pngtest.c:623
user_chunk_data
Definition: pngtest.c:618
STDERR
#define STDERR
Definition: pngtest.c:42
png_write_chunk
PNG_IMPEXP void() png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_name, png_const_bytep data, png_size_t length)
Definition: pngwutil.c:193
verbose
static int verbose
Definition: pngtest.c:123
static void write_vpAg_chunk ( png_structp  write_ptr)
static
746 {
747  png_byte vpAg[5] = {118, 112, 65, 103, '\0'};
748 
749  png_byte vpag_chunk_data[9];
750 
751  if (verbose != 0)
752  fprintf(STDERR, " vpAg = %lu x %lu, units = %d\n",
753  (unsigned long)user_chunk_data.vpAg_width,
754  (unsigned long)user_chunk_data.vpAg_height,
755  user_chunk_data.vpAg_units);
756 
757  png_save_uint_32(vpag_chunk_data, user_chunk_data.vpAg_width);
758  png_save_uint_32(vpag_chunk_data + 4, user_chunk_data.vpAg_height);
759  vpag_chunk_data[8] = user_chunk_data.vpAg_units;
760  png_write_chunk(write_ptr, vpAg, vpag_chunk_data, 9);
761 }
user_chunk_data::vpAg_height
png_uint_32 vpAg_height
Definition: pngtest.c:621
user_chunk_data::vpAg_units
png_byte vpAg_units
Definition: pngtest.c:622
user_chunk_data
Definition: pngtest.c:618
STDERR
#define STDERR
Definition: pngtest.c:42
png_write_chunk
PNG_IMPEXP void() png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_name, png_const_bytep data, png_size_t length)
Definition: pngwutil.c:193
png_save_uint_32
PNG_IMPEXP void() png_save_uint_32(png_bytep buf, png_uint_32 i)
Definition: pngwutil.c:24
verbose
static int verbose
Definition: pngtest.c:123
user_chunk_data::vpAg_width
png_uint_32 vpAg_width
Definition: pngtest.c:621
static void write_chunks ( png_structp  write_ptr,
int  location 
)
static
765 {
766  int i;
767 
768  /* Notice that this preserves the original chunk order, however chunks
769  * intercepted by the callback will be written *after* chunks passed to
770  * libpng. This will actually reverse a pair of sTER chunks or a pair of
771  * vpAg chunks, resulting in an error later. This is not worth worrying
772  * about - the chunks should not be duplicated!
773  */
774  for (i=0; i<2; ++i)
775  {
776  if (user_chunk_data.location[i] == (location | have_sTER))
777  write_sTER_chunk(write_ptr);
778 
779  else if (user_chunk_data.location[i] == (location | have_vpAg))
780  write_vpAg_chunk(write_ptr);
781  }
782 }
i
int i
Definition: rw_test.cpp:37
user_chunk_data::location
int location[2]
Definition: pngtest.c:624
have_vpAg
#define have_vpAg
Definition: pngtest.c:630
user_chunk_data
Definition: pngtest.c:618
have_sTER
#define have_sTER
Definition: pngtest.c:629
write_vpAg_chunk
static void write_vpAg_chunk(png_structp write_ptr)
Definition: pngtest.c:745
write_sTER_chunk
static void write_sTER_chunk(png_structp write_ptr)
Definition: pngtest.c:734
static void pngtest_check_text_support ( png_const_structp  png_ptr,
png_textp  text_ptr,
int  num_text 
)
static
797 {
798  while (num_text > 0)
799  {
800  switch (text_ptr[--num_text].compression)
801  {
802  case PNG_TEXT_COMPRESSION_NONE:
803  break;
804 
805  case PNG_TEXT_COMPRESSION_zTXt:
806 # ifndef PNG_WRITE_zTXt_SUPPORTED
807  ++unsupported_chunks;
808 # endif
809  break;
810 
811  case PNG_ITXT_COMPRESSION_NONE:
812  case PNG_ITXT_COMPRESSION_zTXt:
813 # ifndef PNG_WRITE_iTXt_SUPPORTED
814  ++unsupported_chunks;
815 # endif
816  break;
817 
818  default:
819  /* This is an error */
820  png_error(png_ptr, "invalid text chunk compression field");
821  break;
822  }
823  }
824 }
unsupported_chunks
static int unsupported_chunks
Definition: pngtest.c:126
PNG_ITXT_COMPRESSION_zTXt
#define PNG_ITXT_COMPRESSION_zTXt
Definition: png.h:732
PNG_TEXT_COMPRESSION_zTXt
#define PNG_TEXT_COMPRESSION_zTXt
Definition: png.h:730
PNG_TEXT_COMPRESSION_NONE
#define PNG_TEXT_COMPRESSION_NONE
Definition: png.h:729
PNG_ITXT_COMPRESSION_NONE
#define PNG_ITXT_COMPRESSION_NONE
Definition: png.h:731
png_error
PNG_IMPEXP void() png_error(png_const_structrp png_ptr, png_const_charp error_message)
Definition: pngerror.c:40
static int test_one_file ( const char *  inname,
const char *  outname 
)
static
831 {
832  static png_FILE_p fpin;
833  static png_FILE_p fpout; /* "static" prevents setjmp corruption */
834  pngtest_error_parameters error_parameters;
835  png_structp read_ptr;
836  png_infop read_info_ptr, end_info_ptr;
837 #ifdef PNG_WRITE_SUPPORTED
838  png_structp write_ptr;
839  png_infop write_info_ptr;
840  png_infop write_end_info_ptr;
841  int interlace_preserved = 1;
842 #else
843  png_structp write_ptr = NULL;
844  png_infop write_info_ptr = NULL;
845  png_infop write_end_info_ptr = NULL;
846 #endif
847  png_bytep row_buf;
848  png_uint_32 y;
849  png_uint_32 width, height;
850  int num_pass = 1, pass;
851  int bit_depth, color_type;
852 
853  row_buf = NULL;
854  error_parameters.file_name = inname;
855 
856  if ((fpin = fopen(inname, "rb")) == NULL)
857  {
858  fprintf(STDERR, "Could not find input file %s\n", inname);
859  return (1);
860  }
861 
862  if ((fpout = fopen(outname, "wb")) == NULL)
863  {
864  fprintf(STDERR, "Could not open output file %s\n", outname);
865  FCLOSE(fpin);
866  return (1);
867  }
868 
869  pngtest_debug("Allocating read and write structures");
870 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
871  read_ptr =
872  png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL,
873  NULL, NULL, NULL, png_debug_malloc, png_debug_free);
874 #else
875  read_ptr =
876  png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
877 #endif
878  png_set_error_fn(read_ptr, &error_parameters, pngtest_error,
879  pngtest_warning);
880 
881 #ifdef PNG_WRITE_SUPPORTED
882 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
883  write_ptr =
884  png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL,
885  NULL, NULL, NULL, png_debug_malloc, png_debug_free);
886 #else
887  write_ptr =
888  png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
889 #endif
890  png_set_error_fn(write_ptr, &error_parameters, pngtest_error,
891  pngtest_warning);
892 #endif
893  pngtest_debug("Allocating read_info, write_info and end_info structures");
894  read_info_ptr = png_create_info_struct(read_ptr);
895  end_info_ptr = png_create_info_struct(read_ptr);
896 #ifdef PNG_WRITE_SUPPORTED
897  write_info_ptr = png_create_info_struct(write_ptr);
898  write_end_info_ptr = png_create_info_struct(write_ptr);
899 #endif
900 
901 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
902  init_callback_info(read_info_ptr);
903  png_set_read_user_chunk_fn(read_ptr, &user_chunk_data,
904  read_user_chunk_callback);
905 #endif
906 
907 #ifdef PNG_SETJMP_SUPPORTED
908  pngtest_debug("Setting jmpbuf for read struct");
909  if (setjmp(png_jmpbuf(read_ptr)))
910  {
911  fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);
912  png_free(read_ptr, row_buf);
913  row_buf = NULL;
914  png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
915 #ifdef PNG_WRITE_SUPPORTED
916  png_destroy_info_struct(write_ptr, &write_end_info_ptr);
917  png_destroy_write_struct(&write_ptr, &write_info_ptr);
918 #endif
919  FCLOSE(fpin);
920  FCLOSE(fpout);
921  return (1);
922  }
923 
924 #ifdef PNG_WRITE_SUPPORTED
925  pngtest_debug("Setting jmpbuf for write struct");
926 
927  if (setjmp(png_jmpbuf(write_ptr)))
928  {
929  fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);
930  png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
931  png_destroy_info_struct(write_ptr, &write_end_info_ptr);
932 #ifdef PNG_WRITE_SUPPORTED
933  png_destroy_write_struct(&write_ptr, &write_info_ptr);
934 #endif
935  FCLOSE(fpin);
936  FCLOSE(fpout);
937  return (1);
938  }
939 #endif
940 #endif
941 
942  if (strict != 0)
943  {
944  /* Treat png_benign_error() as errors on read */
945  png_set_benign_errors(read_ptr, 0);
946 
947 #ifdef PNG_WRITE_SUPPORTED
948  /* Treat them as errors on write */
949  png_set_benign_errors(write_ptr, 0);
950 #endif
951 
952  /* if strict is not set, then app warnings and errors are treated as
953  * warnings in release builds, but not in unstable builds; this can be
954  * changed with '--relaxed'.
955  */
956  }
957 
958  else if (relaxed != 0)
959  {
960  /* Allow application (pngtest) errors and warnings to pass */
961  png_set_benign_errors(read_ptr, 1);
962 
963 #ifdef PNG_WRITE_SUPPORTED
964  png_set_benign_errors(write_ptr, 1);
965 #endif
966  }
967 
968  pngtest_debug("Initializing input and output streams");
969 #ifdef PNG_STDIO_SUPPORTED
970  png_init_io(read_ptr, fpin);
971 # ifdef PNG_WRITE_SUPPORTED
972  png_init_io(write_ptr, fpout);
973 # endif
974 #else
975  png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
976 # ifdef PNG_WRITE_SUPPORTED
977  png_set_write_fn(write_ptr, (png_voidp)fpout, pngtest_write_data,
978 # ifdef PNG_WRITE_FLUSH_SUPPORTED
979  pngtest_flush);
980 # else
981  NULL);
982 # endif
983 # endif
984 #endif
985 
986  if (status_dots_requested == 1)
987  {
988 #ifdef PNG_WRITE_SUPPORTED
989  png_set_write_status_fn(write_ptr, write_row_callback);
990 #endif
991  png_set_read_status_fn(read_ptr, read_row_callback);
992  }
993 
994  else
995  {
996 #ifdef PNG_WRITE_SUPPORTED
997  png_set_write_status_fn(write_ptr, NULL);
998 #endif
999  png_set_read_status_fn(read_ptr, NULL);
1000  }
1001 
1002 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1003  {
1004  int i;
1005 
1006  for (i = 0; i<256; i++)
1007  filters_used[i] = 0;
1008 
1009  png_set_read_user_transform_fn(read_ptr, count_filters);
1010  }
1011 #endif
1012 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1013  zero_samples = 0;
1014  png_set_write_user_transform_fn(write_ptr, count_zero_samples);
1015 #endif
1016 
1017 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
1018  /* Preserve all the unknown chunks, if possible. If this is disabled then,
1019  * even if the png_{get,set}_unknown_chunks stuff is enabled, we can't use
1020  * libpng to *save* the unknown chunks on read (because we can't switch the
1021  * save option on!)
1022  *
1023  * Notice that if SET_UNKNOWN_CHUNKS is *not* supported read will discard all
1024  * unknown chunks and write will write them all.
1025  */
1026 #ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
1027  png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,
1028  NULL, 0);
1029 #endif
1030 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1031  png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS,
1032  NULL, 0);
1033 #endif
1034 #endif
1035 
1036  pngtest_debug("Reading info struct");
1037  png_read_info(read_ptr, read_info_ptr);
1038 
1039 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1040  /* This is a bit of a hack; there is no obvious way in the callback function
1041  * to determine that the chunks before the first IDAT have been read, so
1042  * remove the info_ptr (which is only used to determine position relative to
1043  * PLTE) here to indicate that we are after the IDAT.
1044  */
1045  user_chunk_data.info_ptr = NULL;
1046 #endif
1047 
1048  pngtest_debug("Transferring info struct");
1049  {
1050  int interlace_type, compression_type, filter_type;
1051 
1052  if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
1053  &color_type, &interlace_type, &compression_type, &filter_type) != 0)
1054  {
1055  png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
1056  color_type, interlace_type, compression_type, filter_type);
1057 #ifndef PNG_READ_INTERLACING_SUPPORTED
1058  /* num_pass will not be set below, set it here if the image is
1059  * interlaced: what happens is that write interlacing is *not* turned
1060  * on an the partial interlaced rows are written directly.
1061  */
1062  switch (interlace_type)
1063  {
1064  case PNG_INTERLACE_NONE:
1065  num_pass = 1;
1066  break;
1067 
1068  case PNG_INTERLACE_ADAM7:
1069  num_pass = 7;
1070  break;
1071 
1072  default:
1073  png_error(read_ptr, "invalid interlace type");
1074  /*NOT REACHED*/
1075  }
1076 #endif
1077  }
1078  }
1079 #ifdef PNG_FIXED_POINT_SUPPORTED
1080 #ifdef PNG_cHRM_SUPPORTED
1081  {
1082  png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
1083  blue_y;
1084 
1085  if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,
1086  &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
1087  {
1088  png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
1089  red_y, green_x, green_y, blue_x, blue_y);
1090  }
1091  }
1092 #endif
1093 #ifdef PNG_gAMA_SUPPORTED
1094  {
1095  png_fixed_point gamma;
1096 
1097  if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma) != 0)
1098  png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
1099  }
1100 #endif
1101 #else /* Use floating point versions */
1102 #ifdef PNG_FLOATING_POINT_SUPPORTED
1103 #ifdef PNG_cHRM_SUPPORTED
1104  {
1105  double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,
1106  blue_y;
1107 
1108  if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
1109  &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
1110  {
1111  png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
1112  red_y, green_x, green_y, blue_x, blue_y);
1113  }
1114  }
1115 #endif
1116 #ifdef PNG_gAMA_SUPPORTED
1117  {
1118  double gamma;
1119 
1120  if (png_get_gAMA(read_ptr, read_info_ptr, &gamma) != 0)
1121  png_set_gAMA(write_ptr, write_info_ptr, gamma);
1122  }
1123 #endif
1124 #endif /* Floating point */
1125 #endif /* Fixed point */
1126 #ifdef PNG_iCCP_SUPPORTED
1127  {
1128  png_charp name;
1129  png_bytep profile;
1130  png_uint_32 proflen;
1131  int compression_type;
1132 
1133  if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
1134  &profile, &proflen) != 0)
1135  {
1136  png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
1137  profile, proflen);
1138  }
1139  }
1140 #endif
1141 #ifdef PNG_sRGB_SUPPORTED
1142  {
1143  int intent;
1144 
1145  if (png_get_sRGB(read_ptr, read_info_ptr, &intent) != 0)
1146  png_set_sRGB(write_ptr, write_info_ptr, intent);
1147  }
1148 #endif
1149  {
1150  png_colorp palette;
1151  int num_palette;
1152 
1153  if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette) != 0)
1154  png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
1155  }
1156 #ifdef PNG_bKGD_SUPPORTED
1157  {
1158  png_color_16p background;
1159 
1160  if (png_get_bKGD(read_ptr, read_info_ptr, &background) != 0)
1161  {
1162  png_set_bKGD(write_ptr, write_info_ptr, background);
1163  }
1164  }
1165 #endif
1166 #ifdef PNG_hIST_SUPPORTED
1167  {
1168  png_uint_16p hist;
1169 
1170  if (png_get_hIST(read_ptr, read_info_ptr, &hist) != 0)
1171  png_set_hIST(write_ptr, write_info_ptr, hist);
1172  }
1173 #endif
1174 #ifdef PNG_oFFs_SUPPORTED
1175  {
1176  png_int_32 offset_x, offset_y;
1177  int unit_type;
1178 
1179  if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
1180  &unit_type) != 0)
1181  {
1182  png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
1183  }
1184  }
1185 #endif
1186 #ifdef PNG_pCAL_SUPPORTED
1187  {
1188  png_charp purpose, units;
1189  png_charpp params;
1190  png_int_32 X0, X1;
1191  int type, nparams;
1192 
1193  if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
1194  &nparams, &units, &params) != 0)
1195  {
1196  png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
1197  nparams, units, params);
1198  }
1199  }
1200 #endif
1201 #ifdef PNG_pHYs_SUPPORTED
1202  {
1203  png_uint_32 res_x, res_y;
1204  int unit_type;
1205 
1206  if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y,
1207  &unit_type) != 0)
1208  png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
1209  }
1210 #endif
1211 #ifdef PNG_sBIT_SUPPORTED
1212  {
1213  png_color_8p sig_bit;
1214 
1215  if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit) != 0)
1216  png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
1217  }
1218 #endif
1219 #ifdef PNG_sCAL_SUPPORTED
1220 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
1221  defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
1222  {
1223  int unit;
1224  double scal_width, scal_height;
1225 
1226  if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
1227  &scal_height) != 0)
1228  {
1229  png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
1230  }
1231  }
1232 #else
1233 #ifdef PNG_FIXED_POINT_SUPPORTED
1234  {
1235  int unit;
1236  png_charp scal_width, scal_height;
1237 
1238  if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
1239  &scal_height) != 0)
1240  {
1241  png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,
1242  scal_height);
1243  }
1244  }
1245 #endif
1246 #endif
1247 #endif
1248 #ifdef PNG_TEXT_SUPPORTED
1249  {
1250  png_textp text_ptr;
1251  int num_text;
1252 
1253  if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
1254  {
1255  pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
1256 
1257  pngtest_check_text_support(read_ptr, text_ptr, num_text);
1258 
1259  if (verbose != 0)
1260  {
1261  int i;
1262 
1263  printf("\n");
1264  for (i=0; i<num_text; i++)
1265  {
1266  printf(" Text compression[%d]=%d\n",
1267  i, text_ptr[i].compression);
1268  }
1269  }
1270 
1271  png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
1272  }
1273  }
1274 #endif
1275 #ifdef PNG_tIME_SUPPORTED
1276  {
1277  png_timep mod_time;
1278 
1279  if (png_get_tIME(read_ptr, read_info_ptr, &mod_time) != 0)
1280  {
1281  png_set_tIME(write_ptr, write_info_ptr, mod_time);
1282 #ifdef PNG_TIME_RFC1123_SUPPORTED
1283  if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
1284  tIME_string[(sizeof tIME_string) - 1] = '\0';
1285 
1286  else
1287  {
1288  strncpy(tIME_string, "*** invalid time ***", (sizeof tIME_string));
1289  tIME_string[(sizeof tIME_string) - 1] = '\0';
1290  }
1291 
1292  tIME_chunk_present++;
1293 #endif /* TIME_RFC1123 */
1294  }
1295  }
1296 #endif
1297 #ifdef PNG_tRNS_SUPPORTED
1298  {
1299  png_bytep trans_alpha;
1300  int num_trans;
1301  png_color_16p trans_color;
1302 
1303  if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,
1304  &trans_color) != 0)
1305  {
1306  int sample_max = (1 << bit_depth);
1307  /* libpng doesn't reject a tRNS chunk with out-of-range samples */
1308  if (!((color_type == PNG_COLOR_TYPE_GRAY &&
1309  (int)trans_color->gray > sample_max) ||
1310  (color_type == PNG_COLOR_TYPE_RGB &&
1311  ((int)trans_color->red > sample_max ||
1312  (int)trans_color->green > sample_max ||
1313  (int)trans_color->blue > sample_max))))
1314  png_set_tRNS(write_ptr, write_info_ptr, trans_alpha, num_trans,
1315  trans_color);
1316  }
1317  }
1318 #endif
1319 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1320  {
1321  png_unknown_chunkp unknowns;
1322  int num_unknowns = png_get_unknown_chunks(read_ptr, read_info_ptr,
1323  &unknowns);
1324 
1325  if (num_unknowns != 0)
1326  {
1327  png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,
1328  num_unknowns);
1329 #if PNG_LIBPNG_VER < 10600
1330  /* Copy the locations from the read_info_ptr. The automatically
1331  * generated locations in write_end_info_ptr are wrong prior to 1.6.0
1332  * because they are reset from the write pointer (removed in 1.6.0).
1333  */
1334  {
1335  int i;
1336  for (i = 0; i < num_unknowns; i++)
1337  png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,
1338  unknowns[i].location);
1339  }
1340 #endif
1341  }
1342  }
1343 #endif
1344 
1345 #ifdef PNG_WRITE_SUPPORTED
1346  pngtest_debug("Writing info struct");
1347 
1348  /* Write the info in two steps so that if we write the 'unknown' chunks here
1349  * they go to the correct place.
1350  */
1351  png_write_info_before_PLTE(write_ptr, write_info_ptr);
1352 
1353  write_chunks(write_ptr, before_PLTE); /* before PLTE */
1354 
1355  png_write_info(write_ptr, write_info_ptr);
1356 
1357  write_chunks(write_ptr, before_IDAT); /* after PLTE */
1358 #endif
1359 
1360 #ifdef SINGLE_ROWBUF_ALLOC
1361  pngtest_debug("Allocating row buffer...");
1362  row_buf = (png_bytep)png_malloc(read_ptr,
1363  png_get_rowbytes(read_ptr, read_info_ptr));
1364 
1365  pngtest_debug1("\t0x%08lx", (unsigned long)row_buf);
1366 #endif /* SINGLE_ROWBUF_ALLOC */
1367  pngtest_debug("Writing row data");
1368 
1369 #ifdef PNG_READ_INTERLACING_SUPPORTED
1370  num_pass = png_set_interlace_handling(read_ptr);
1371  if (png_set_interlace_handling(write_ptr) != num_pass)
1372  png_error(write_ptr, "png_set_interlace_handling: inconsistent num_pass");
1373 #endif
1374 
1375 #ifdef PNGTEST_TIMING
1376  t_stop = (float)clock();
1377  t_misc += (t_stop - t_start);
1378  t_start = t_stop;
1379 #endif
1380  for (pass = 0; pass < num_pass; pass++)
1381  {
1382  pngtest_debug1("Writing row data for pass %d", pass);
1383  for (y = 0; y < height; y++)
1384  {
1385 #ifndef SINGLE_ROWBUF_ALLOC
1386  pngtest_debug2("Allocating row buffer (pass %d, y = %u)...", pass, y);
1387 
1388  row_buf = (png_bytep)png_malloc(read_ptr,
1389  png_get_rowbytes(read_ptr, read_info_ptr));
1390 
1391  pngtest_debug2("\t0x%08lx (%lu bytes)", (unsigned long)row_buf,
1392  (unsigned long)png_get_rowbytes(read_ptr, read_info_ptr));
1393 
1394 #endif /* !SINGLE_ROWBUF_ALLOC */
1395  png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1);
1396 
1397 #ifdef PNG_WRITE_SUPPORTED
1398 #ifdef PNGTEST_TIMING
1399  t_stop = (float)clock();
1400  t_decode += (t_stop - t_start);
1401  t_start = t_stop;
1402 #endif
1403  png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
1404 #ifdef PNGTEST_TIMING
1405  t_stop = (float)clock();
1406  t_encode += (t_stop - t_start);
1407  t_start = t_stop;
1408 #endif
1409 #endif /* WRITE */
1410 
1411 #ifndef SINGLE_ROWBUF_ALLOC
1412  pngtest_debug2("Freeing row buffer (pass %d, y = %u)", pass, y);
1413  png_free(read_ptr, row_buf);
1414  row_buf = NULL;
1415 #endif /* !SINGLE_ROWBUF_ALLOC */
1416  }
1417  }
1418 
1419 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1420 # ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
1421  png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);
1422 # endif
1423 # ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1424  png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);
1425 # endif
1426 #endif
1427 
1428  pngtest_debug("Reading and writing end_info data");
1429 
1430  png_read_end(read_ptr, end_info_ptr);
1431 #ifdef PNG_TEXT_SUPPORTED
1432  {
1433  png_textp text_ptr;
1434  int num_text;
1435 
1436  if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)
1437  {
1438  pngtest_debug1("Handling %d iTXt/tEXt/zTXt chunks", num_text);
1439 
1440  pngtest_check_text_support(read_ptr, text_ptr, num_text);
1441 
1442  if (verbose != 0)
1443  {
1444  int i;
1445 
1446  printf("\n");
1447  for (i=0; i<num_text; i++)
1448  {
1449  printf(" Text compression[%d]=%d\n",
1450  i, text_ptr[i].compression);
1451  }
1452  }
1453 
1454  png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);
1455  }
1456  }
1457 #endif
1458 #ifdef PNG_tIME_SUPPORTED
1459  {
1460  png_timep mod_time;
1461 
1462  if (png_get_tIME(read_ptr, end_info_ptr, &mod_time) != 0)
1463  {
1464  png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
1465 #ifdef PNG_TIME_RFC1123_SUPPORTED
1466  if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
1467  tIME_string[(sizeof tIME_string) - 1] = '\0';
1468 
1469  else
1470  {
1471  strncpy(tIME_string, "*** invalid time ***", sizeof tIME_string);
1472  tIME_string[(sizeof tIME_string)-1] = '\0';
1473  }
1474 
1475  tIME_chunk_present++;
1476 #endif /* TIME_RFC1123 */
1477  }
1478  }
1479 #endif
1480 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
1481  {
1482  png_unknown_chunkp unknowns;
1483  int num_unknowns = png_get_unknown_chunks(read_ptr, end_info_ptr,
1484  &unknowns);
1485 
1486  if (num_unknowns != 0)
1487  {
1488  png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,
1489  num_unknowns);
1490 #if PNG_LIBPNG_VER < 10600
1491  /* Copy the locations from the read_info_ptr. The automatically
1492  * generated locations in write_end_info_ptr are wrong prior to 1.6.0
1493  * because they are reset from the write pointer (removed in 1.6.0).
1494  */
1495  {
1496  int i;
1497  for (i = 0; i < num_unknowns; i++)
1498  png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,
1499  unknowns[i].location);
1500  }
1501 #endif
1502  }
1503  }
1504 #endif
1505 
1506 #ifdef PNG_WRITE_SUPPORTED
1507 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1508  /* Normally one would use Z_DEFAULT_STRATEGY for text compression.
1509  * This is here just to make pngtest replicate the results from libpng
1510  * versions prior to 1.5.4, and to test this new API.
1511  */
1512  png_set_text_compression_strategy(write_ptr, Z_FILTERED);
1513 #endif
1514 
1515  /* When the unknown vpAg/sTER chunks are written by pngtest the only way to
1516  * do it is to write them *before* calling png_write_end. When unknown
1517  * chunks are written by libpng, however, they are written just before IEND.
1518  * There seems to be no way round this, however vpAg/sTER are not expected
1519  * after IDAT.
1520  */
1521  write_chunks(write_ptr, after_IDAT);
1522 
1523  png_write_end(write_ptr, write_end_info_ptr);
1524 #endif
1525 
1526 #ifdef PNG_EASY_ACCESS_SUPPORTED
1527  if (verbose != 0)
1528  {
1529  png_uint_32 iwidth, iheight;
1530  iwidth = png_get_image_width(write_ptr, write_info_ptr);
1531  iheight = png_get_image_height(write_ptr, write_info_ptr);
1532  fprintf(STDERR, "\n Image width = %lu, height = %lu\n",
1533  (unsigned long)iwidth, (unsigned long)iheight);
1534  }
1535 #endif
1536 
1537  pngtest_debug("Destroying data structs");
1538 #ifdef SINGLE_ROWBUF_ALLOC
1539  pngtest_debug("destroying row_buf for read_ptr");
1540  png_free(read_ptr, row_buf);
1541  row_buf = NULL;
1542 #endif /* SINGLE_ROWBUF_ALLOC */
1543  pngtest_debug("destroying read_ptr, read_info_ptr, end_info_ptr");
1544  png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
1545 #ifdef PNG_WRITE_SUPPORTED
1546  pngtest_debug("destroying write_end_info_ptr");
1547  png_destroy_info_struct(write_ptr, &write_end_info_ptr);
1548  pngtest_debug("destroying write_ptr, write_info_ptr");
1549  png_destroy_write_struct(&write_ptr, &write_info_ptr);
1550 #endif
1551  pngtest_debug("Destruction complete.");
1552 
1553  FCLOSE(fpin);
1554  FCLOSE(fpout);
1555 
1556  /* Summarize any warnings or errors and in 'strict' mode fail the test.
1557  * Unsupported chunks can result in warnings, in that case ignore the strict
1558  * setting, otherwise fail the test on warnings as well as errors.
1559  */
1560  if (error_count > 0)
1561  {
1562  /* We don't really expect to get here because of the setjmp handling
1563  * above, but this is safe.
1564  */
1565  fprintf(STDERR, "\n %s: %d libpng errors found (%d warnings)",
1566  inname, error_count, warning_count);
1567 
1568  if (strict != 0)
1569  return (1);
1570  }
1571 
1572 # ifdef PNG_WRITE_SUPPORTED
1573  /* If there we no write support nothing was written! */
1574  else if (unsupported_chunks > 0)
1575  {
1576  fprintf(STDERR, "\n %s: unsupported chunks (%d)%s",
1577  inname, unsupported_chunks, strict ? ": IGNORED --strict!" : "");
1578  }
1579 # endif
1580 
1581  else if (warning_count > 0)
1582  {
1583  fprintf(STDERR, "\n %s: %d libpng warnings found",
1584  inname, warning_count);
1585 
1586  if (strict != 0)
1587  return (1);
1588  }
1589 
1590  pngtest_debug("Opening files for comparison");
1591  if ((fpin = fopen(inname, "rb")) == NULL)
1592  {
1593  fprintf(STDERR, "Could not find file %s\n", inname);
1594  return (1);
1595  }
1596 
1597  if ((fpout = fopen(outname, "rb")) == NULL)
1598  {
1599  fprintf(STDERR, "Could not find file %s\n", outname);
1600  FCLOSE(fpin);
1601  return (1);
1602  }
1603 
1604 #ifdef PNG_WRITE_SUPPORTED /* else nothing was written */
1605  if (interlace_preserved != 0) /* else the files will be changed */
1606  {
1607  for (;;)
1608  {
1609  static int wrote_question = 0;
1610  png_size_t num_in, num_out;
1611  char inbuf[256], outbuf[256];
1612 
1613  num_in = fread(inbuf, 1, sizeof inbuf, fpin);
1614  num_out = fread(outbuf, 1, sizeof outbuf, fpout);
1615 
1616  if (num_in != num_out)
1617  {
1618  fprintf(STDERR, "\nFiles %s and %s are of a different size\n",
1619  inname, outname);
1620 
1621  if (wrote_question == 0 && unsupported_chunks == 0)
1622  {
1623  fprintf(STDERR,
1624  " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1625  inname, PNG_ZBUF_SIZE);
1626  fprintf(STDERR,
1627  "\n filtering heuristic (libpng default), compression");
1628  fprintf(STDERR,
1629  " level (zlib default),\n and zlib version (%s)?\n\n",
1630  ZLIB_VERSION);
1631  wrote_question = 1;
1632  }
1633 
1634  FCLOSE(fpin);
1635  FCLOSE(fpout);
1636 
1637  if (strict != 0 && unsupported_chunks == 0)
1638  return (1);
1639 
1640  else
1641  return (0);
1642  }
1643 
1644  if (num_in == 0)
1645  break;
1646 
1647  if (memcmp(inbuf, outbuf, num_in))
1648  {
1649  fprintf(STDERR, "\nFiles %s and %s are different\n", inname,
1650  outname);
1651 
1652  if (wrote_question == 0 && unsupported_chunks == 0)
1653  {
1654  fprintf(STDERR,
1655  " Was %s written with the same maximum IDAT chunk size (%d bytes),",
1656  inname, PNG_ZBUF_SIZE);
1657  fprintf(STDERR,
1658  "\n filtering heuristic (libpng default), compression");
1659  fprintf(STDERR,
1660  " level (zlib default),\n and zlib version (%s)?\n\n",
1661  ZLIB_VERSION);
1662  wrote_question = 1;
1663  }
1664 
1665  FCLOSE(fpin);
1666  FCLOSE(fpout);
1667 
1668  /* NOTE: the unsupported_chunks escape is permitted here because
1669  * unsupported text chunk compression will result in the compression
1670  * mode being changed (to NONE) yet, in the test case, the result
1671  * can be exactly the same size!
1672  */
1673  if (strict != 0 && unsupported_chunks == 0)
1674  return (1);
1675 
1676  else
1677  return (0);
1678  }
1679  }
1680  }
1681 #endif /* WRITE */
1682 
1683  FCLOSE(fpin);
1684  FCLOSE(fpout);
1685 
1686  return (0);
1687 }
png_write_info_before_PLTE
PNG_IMPEXP void() png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
Definition: pngwrite.c:84
png_get_image_width
PNG_IMPEXP png_uint_32() png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)
Definition: pngget.c:52
before_PLTE
#define before_PLTE
Definition: pngtest.c:631
png_malloc
PNG_IMPEXP png_voidp() png_malloc(png_const_structrp png_ptr, png_alloc_size_t size)
Definition: pngmem.c:169
png_get_sCAL_s
PNG_IMPEXP png_uint_32() png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, png_charpp swidth, png_charpp sheight)
Definition: pngget.c:924
png_get_tIME
PNG_IMPEXP png_uint_32() png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr, png_timep *mod_time)
Definition: pngget.c:1039
png_set_pCAL
PNG_IMPEXP void() png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)
Definition: pngset.c:264
strict
static int strict
Definition: pngtest.c:124
png_voidp
void * png_voidp
Definition: pngconf.h:598
png_set_sCAL_s
PNG_IMPEXP void() png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr, int unit, png_const_charp swidth, png_const_charp sheight)
Definition: pngset.c:365
png_create_read_struct_2
PNG_IMPEXP png_structp() png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)
Definition: pngread.c:43
png_set_gAMA_fixed
PNG_IMPEXP void() png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr, png_fixed_point int_file_gamma)
Definition: pngset.c:139
png_read_info
PNG_IMPEXP void() png_read_info(png_structrp png_ptr, png_inforp info_ptr)
Definition: pngread.c:92
png_get_pHYs
PNG_IMPEXP png_uint_32() png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
Definition: pngget.c:942
error_count
static int error_count
Definition: pngtest.c:127
pngtest_error_parameters
Definition: pngtest.c:430
pngtest_debug1
#define pngtest_debug1(m, p1)
Definition: pngtest.c:96
inputfile.y
y
Definition: inputfile.py:6
png_read_end
PNG_IMPEXP void() png_read_end(png_structrp png_ptr, png_inforp info_ptr)
Definition: pngread.c:757
pngtest_error
static void pngtest_error(png_structp png_ptr, png_const_charp message)
Definition: pngtest.c:456
png_get_IHDR
PNG_IMPEXP png_uint_32() png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, int *interlace_method, int *compression_method, int *filter_method)
Definition: pngget.c:795
png_set_sRGB
PNG_IMPEXP void() png_set_sRGB(png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)
Definition: pngset.c:580
i
int i
Definition: rw_test.cpp:37
png_get_iCCP
PNG_IMPEXP png_uint_32() png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, png_charpp name, int *compression_type, png_bytepp profile, png_uint_32 *proflen)
Definition: pngget.c:736
png_set_cHRM_fixed
PNG_IMPEXP void() png_set_cHRM_fixed(png_const_structrp png_ptr, png_inforp info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, png_fixed_point int_blue_y)
Definition: pngset.c:40
png_set_read_status_fn
PNG_IMPEXP void() png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
Definition: pngread.c:1011
PNG_INTERLACE_NONE
#define PNG_INTERLACE_NONE
Definition: png.h:828
zero_samples
static png_uint_32 zero_samples
Definition: pngtest.c:206
PNG_COLOR_TYPE_RGB
#define PNG_COLOR_TYPE_RGB
Definition: png.h:811
unsupported_chunks
static int unsupported_chunks
Definition: pngtest.c:126
png_get_sBIT
PNG_IMPEXP png_uint_32() png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, png_color_8p *sig_bit)
Definition: pngget.c:995
png_set_IHDR
PNG_IMPEXP void() png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_method, int compression_method, int filter_method)
Definition: pngset.c:206
inname
static const char * inname
Definition: pngtest.c:1694
png_get_bKGD
PNG_IMPEXP png_uint_32() png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, png_color_16p *background)
Definition: pngget.c:488
PNG_INTERLACE_ADAM7
#define PNG_INTERLACE_ADAM7
Definition: png.h:829
png_color_16_struct::blue
png_uint_16 blue
Definition: png.h:634
png_bytep
png_byte * png_bytep
Definition: pngconf.h:600
png_set_PLTE
PNG_IMPEXP void() png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_const_colorp palette, int num_palette)
Definition: pngset.c:505
png_color_16_struct::gray
png_uint_16 gray
Definition: png.h:635
png_get_unknown_chunks
PNG_IMPEXP int() png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, png_unknown_chunkpp entries)
Definition: pngget.c:1103
png_get_gAMA
PNG_IMPEXP png_uint_32() png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, double *file_gamma)
Definition: pngget.c:697
PNG_LIBPNG_VER_STRING
#define PNG_LIBPNG_VER_STRING
Definition: png.h:426
png_set_write_fn
PNG_IMPEXP void() png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
Definition: pngwio.c:122
png_set_write_status_fn
PNG_IMPEXP void() png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn)
Definition: pngwrite.c:1534
png_set_tRNS
PNG_IMPEXP void() png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color)
Definition: pngset.c:917
png_charp
char * png_charp
Definition: pngconf.h:610
png_set_keep_unknown_chunks
PNG_IMPEXP void() png_set_keep_unknown_chunks(png_structrp png_ptr, int keep, png_const_bytep chunk_list, int num_chunks)
Definition: pngset.c:1282
png_bytepp
png_byte ** png_bytepp
Definition: pngconf.h:627
png_set_unknown_chunk_location
PNG_IMPEXP void() png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)
Definition: pngset.c:1209
png_struct_def
Definition: pngstruct.h:144
user_chunk_data::location
int location[2]
Definition: pngtest.c:624
png_set_tIME
PNG_IMPEXP void() png_set_tIME(png_const_structrp png_ptr, png_inforp info_ptr, png_const_timep mod_time)
Definition: pngset.c:892
png_get_cHRM_fixed
PNG_IMPEXP png_uint_32() png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_white_x, png_fixed_point *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)
Definition: pngget.c:641
Z_FILTERED
#define Z_FILTERED
Definition: zlib.h:192
png_set_gAMA
PNG_IMPEXP void() png_set_gAMA(png_const_structrp png_ptr, png_inforp info_ptr, double file_gamma)
Definition: pngset.c:153
png_read_rows
PNG_IMPEXP void() png_read_rows(png_structrp png_ptr, png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)
Definition: pngread.c:636
png_set_pHYs
PNG_IMPEXP void() png_set_pHYs(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)
Definition: pngset.c:489
png_create_write_struct
PNG_IMPEXP png_structp() png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
Definition: pngwrite.c:482
png_jmpbuf
#define png_jmpbuf(png_ptr)
Definition: png.h:1090
png_destroy_read_struct
PNG_IMPEXP void() png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)
Definition: pngread.c:985
intent
png_uint_16 intent
Definition: png.c:2177
png_info_def
Definition: pnginfo.h:56
png_create_write_struct_2
PNG_IMPEXP png_structp() png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)
Definition: pngwrite.c:496
status_dots_requested
static int status_dots_requested
Definition: pngtest.c:148
png_free_data
void png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask, int num)
Definition: png.c:442
png_get_tRNS
PNG_IMPEXP png_uint_32() png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
Definition: pngget.c:1057
user_chunk_data::info_ptr
png_const_infop info_ptr
Definition: pngtest.c:620
png_get_image_height
PNG_IMPEXP png_uint_32() png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)
Definition: pngget.c:61
png_set_unknown_chunks
PNG_IMPEXP void() png_set_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
Definition: pngset.c:1113
pngtest_debug
#define pngtest_debug(m)
Definition: pngtest.c:95
png_set_write_user_transform_fn
PNG_IMPEXP void() png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr write_user_transform_fn)
Definition: pngwrite.c:1544
png_unknown_chunk_t
Definition: png.h:763
png_get_sCAL
PNG_IMPEXP png_uint_32() png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, double *width, double *height)
Definition: pngget.c:908
warning_count
static int warning_count
Definition: pngtest.c:128
png_set_read_user_transform_fn
PNG_IMPEXP void() png_set_read_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr read_user_transform_fn)
Definition: pngrtran.c:1057
png_color_16_struct::green
png_uint_16 green
Definition: png.h:633
png_write_end
PNG_IMPEXP void() png_write_end(png_structrp png_ptr, png_inforp info_ptr)
Definition: pngwrite.c:347
PNG_HANDLE_CHUNK_ALWAYS
#define PNG_HANDLE_CHUNK_ALWAYS
Definition: png.h:2500
png_get_gAMA_fixed
PNG_IMPEXP png_uint_32() png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_file_gamma)
Definition: pngget.c:678
png_set_cHRM
PNG_IMPEXP void() png_set_cHRM(png_const_structrp png_ptr, png_inforp info_ptr, double white_x, double white_y, double red_x, double red_y, double green_x, double green_y, double blue_x, double blue_y)
Definition: pngset.c:102
pngtest_error_parameters::file_name
const char * file_name
Definition: pngtest.c:432
png_text_struct
Definition: png.h:703
png_create_info_struct
png_infop png_create_info_struct(png_const_structrp png_ptr)
Definition: png.c:327
count_filters
static void count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)
Definition: pngtest.c:194
pngtest_check_text_support
static void pngtest_check_text_support(png_const_structp png_ptr, png_textp text_ptr, int num_text)
Definition: pngtest.c:795
user_chunk_data
Definition: pngtest.c:618
PNG_COLOR_TYPE_GRAY
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:809
png_set_error_fn
PNG_IMPEXP void() png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)
Definition: pngerror.c:835
png_get_sRGB
PNG_IMPEXP png_uint_32() png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr, int *file_srgb_intent)
Definition: pngget.c:718
png_set_sBIT
PNG_IMPEXP void() png_set_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, png_const_color_8p sig_bit)
Definition: pngset.c:565
name
string name
Definition: cubesat2obj.cpp:6
png_get_text
PNG_IMPEXP int() png_get_text(png_const_structrp png_ptr, png_inforp info_ptr, png_textp *text_ptr, int *num_text)
Definition: pngget.c:1013
png_get_rowbytes
PNG_IMPEXP png_size_t() png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)
Definition: pngget.c:30
png_set_oFFs
PNG_IMPEXP void() png_set_oFFs(png_const_structrp png_ptr, png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, int unit_type)
Definition: pngset.c:247
png_set_hIST
PNG_IMPEXP void() png_set_hIST(png_const_structrp png_ptr, png_inforp info_ptr, png_const_uint_16p hist)
Definition: pngset.c:163
png_charpp
char ** png_charpp
Definition: pngconf.h:633
png_time_struct
Definition: png.h:741
PNG_FREE_UNKN
#define PNG_FREE_UNKN
Definition: png.h:1919
png_create_read_struct
PNG_IMPEXP png_structp() png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
Definition: pngread.c:27
png_color_struct
Definition: png.h:619
png_set_text
PNG_IMPEXP void() png_set_text(png_const_structrp png_ptr, png_inforp info_ptr, png_const_textp text_ptr, int num_text)
Definition: pngset.c:688
png_set_interlace_handling
PNG_IMPEXP int() png_set_interlace_handling(png_structrp png_ptr)
Definition: pngtrans.c:99
png_init_io
void png_init_io(png_structrp png_ptr, png_FILE_p fp)
Definition: png.c:658
before_IDAT
#define before_IDAT
Definition: pngtest.c:632
png_write_info
PNG_IMPEXP void() png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
Definition: pngwrite.c:191
png_set_benign_errors
PNG_IMPEXP void() png_set_benign_errors(png_structrp png_ptr, int allowed)
Definition: pngset.c:1570
write_row_callback
static void write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
Definition: pngtest.c:177
png_color_8_struct
Definition: png.h:641
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:40
write_chunks
static void write_chunks(png_structp write_ptr, int location)
Definition: pngtest.c:764
STDERR
#define STDERR
Definition: pngtest.c:42
png_set_text_compression_strategy
PNG_IMPEXP void() png_set_text_compression_strategy(png_structrp png_ptr, int strategy)
Definition: pngwrite.c:1483
filters_used
static png_uint_32 filters_used[256]
Definition: pngtest.c:192
png_set_read_fn
PNG_IMPEXP void() png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn)
Definition: pngrio.c:87
png_convert_to_rfc1123_buffer
int png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
Definition: png.c:691
png_write_rows
PNG_IMPEXP void() png_write_rows(png_structrp png_ptr, png_bytepp row, png_uint_32 num_rows)
Definition: pngwrite.c:562
png_set_bKGD
PNG_IMPEXP void() png_set_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, png_const_color_16p background)
Definition: pngset.c:25
png_set_sCAL
PNG_IMPEXP void() png_set_sCAL(png_const_structrp png_ptr, png_inforp info_ptr, int unit, double width, double height)
Definition: pngset.c:430
png_uint_16p
png_uint_16 * png_uint_16p
Definition: pngconf.h:606
after_IDAT
#define after_IDAT
Definition: pngtest.c:633
png_set_iCCP
PNG_IMPEXP void() png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, png_const_charp name, int compression_type, png_const_bytep profile, png_uint_32 proflen)
Definition: pngset.c:615
png_get_hIST
PNG_IMPEXP png_uint_32() png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_16p *hist)
Definition: pngget.c:778
init_callback_info
static void init_callback_info(png_const_infop info_ptr)
Definition: pngtest.c:636
png_get_oFFs
PNG_IMPEXP png_uint_32() png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
Definition: pngget.c:834
FCLOSE
#define FCLOSE(file)
Definition: pngtest.c:79
png_destroy_write_struct
PNG_IMPEXP void() png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
Definition: pngwrite.c:979
png_fixed_point
png_int_32 png_fixed_point
Definition: pngconf.h:595
png_get_pCAL
PNG_IMPEXP png_uint_32() png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, png_charp *units, png_charpp *params)
Definition: pngget.c:855
PNG_WRITE_FLUSH_SUPPORTED
#define PNG_WRITE_FLUSH_SUPPORTED
Definition: pnglibconf.h:135
count_zero_samples
static void count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
Definition: pngtest.c:209
read_row_callback
static void read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
Definition: pngtest.c:152
png_free
PNG_IMPEXP void() png_free(png_const_structrp png_ptr, png_voidp ptr)
Definition: pngmem.c:229
png_set_read_user_chunk_fn
PNG_IMPEXP void() png_set_read_user_chunk_fn(png_structrp png_ptr, png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)
Definition: pngset.c:1437
png_error
PNG_IMPEXP void() png_error(png_const_structrp png_ptr, png_const_charp error_message)
Definition: pngerror.c:40
PNG_ZBUF_SIZE
#define PNG_ZBUF_SIZE
Definition: pnglibconf.h:202
png_size_t
size_t png_size_t
Definition: pngconf.h:543
png_get_cHRM
PNG_IMPEXP png_uint_32() png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, double *red_y, double *green_x, double *green_y, double *blue_x, double *blue_y)
Definition: pngget.c:512
relaxed
static int relaxed
Definition: pngtest.c:125
read_user_chunk_callback
static int read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
Definition: pngtest.c:672
outname
static const char * outname
Definition: pngtest.c:1695
png_color_16_struct::red
png_uint_16 red
Definition: png.h:632
verbose
static int verbose
Definition: pngtest.c:123
png_color_16_struct
Definition: png.h:629
pngtest_warning
static void pngtest_warning(png_structp png_ptr, png_const_charp message)
Definition: pngtest.c:436
tIME_chunk_present
static int tIME_chunk_present
Definition: pngtest.c:119
pngtest_debug2
#define pngtest_debug2(m, p1, p2)
Definition: pngtest.c:97
png_get_PLTE
PNG_IMPEXP png_uint_32() png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr, png_colorp *palette, int *num_palette)
Definition: pngget.c:976
tIME_string
static char tIME_string[29]
Definition: pngtest.c:120
png_destroy_info_struct
void png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
Definition: png.c:359
int main ( int  argc,
char *  argv[] 
)
1700 {
1701  int multiple = 0;
1702  int ierror = 0;
1703 
1704  fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
1705  fprintf(STDERR, " with zlib version %s\n", ZLIB_VERSION);
1706  fprintf(STDERR, "%s", png_get_copyright(NULL));
1707  /* Show the version of libpng used in building the library */
1708  fprintf(STDERR, " library (%lu):%s",
1709  (unsigned long)png_access_version_number(),
1710  png_get_header_version(NULL));
1711 
1712  /* Show the version of libpng used in building the application */
1713  fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,
1714  PNG_HEADER_VERSION_STRING);
1715 
1716  /* Do some consistency checking on the memory allocation settings, I'm
1717  * not sure this matters, but it is nice to know, the first of these
1718  * tests should be impossible because of the way the macros are set
1719  * in pngconf.h
1720  */
1721 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1722  fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");
1723 #endif
1724  /* I think the following can happen. */
1725 #if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)
1726  fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");
1727 #endif
1728 
1729  if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
1730  {
1731  fprintf(STDERR,
1732  "Warning: versions are different between png.h and png.c\n");
1733  fprintf(STDERR, " png.h version: %s\n", PNG_LIBPNG_VER_STRING);
1734  fprintf(STDERR, " png.c version: %s\n\n", png_libpng_ver);
1735  ++ierror;
1736  }
1737 
1738  if (argc > 1)
1739  {
1740  if (strcmp(argv[1], "-m") == 0)
1741  {
1742  multiple = 1;
1743  status_dots_requested = 0;
1744  }
1745 
1746  else if (strcmp(argv[1], "-mv") == 0 ||
1747  strcmp(argv[1], "-vm") == 0 )
1748  {
1749  multiple = 1;
1750  verbose = 1;
1751  status_dots_requested = 1;
1752  }
1753 
1754  else if (strcmp(argv[1], "-v") == 0)
1755  {
1756  verbose = 1;
1757  status_dots_requested = 1;
1758  inname = argv[2];
1759  }
1760 
1761  else if (strcmp(argv[1], "--strict") == 0)
1762  {
1763  status_dots_requested = 0;
1764  verbose = 1;
1765  inname = argv[2];
1766  strict++;
1767  relaxed = 0;
1768  }
1769 
1770  else if (strcmp(argv[1], "--relaxed") == 0)
1771  {
1772  status_dots_requested = 0;
1773  verbose = 1;
1774  inname = argv[2];
1775  strict = 0;
1776  relaxed++;
1777  }
1778 
1779  else
1780  {
1781  inname = argv[1];
1782  status_dots_requested = 0;
1783  }
1784  }
1785 
1786  if (multiple == 0 && argc == 3 + verbose)
1787  outname = argv[2 + verbose];
1788 
1789  if ((multiple == 0 && argc > 3 + verbose) ||
1790  (multiple != 0 && argc < 2))
1791  {
1792  fprintf(STDERR,
1793  "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",
1794  argv[0], argv[0]);
1795  fprintf(STDERR,
1796  " reads/writes one PNG file (without -m) or multiple files (-m)\n");
1797  fprintf(STDERR,
1798  " with -m %s is used as a temporary file\n", outname);
1799  exit(1);
1800  }
1801 
1802  if (multiple != 0)
1803  {
1804  int i;
1805 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1806  int allocation_now = current_allocation;
1807 #endif
1808  for (i=2; i<argc; ++i)
1809  {
1810  int kerror;
1811  fprintf(STDERR, "\n Testing %s:", argv[i]);
1812 #if PNG_DEBUG > 0
1813  fprintf(STDERR, "\n");
1814 #endif
1815  kerror = test_one_file(argv[i], outname);
1816  if (kerror == 0)
1817  {
1818 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1819  int k;
1820 #endif
1821 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1822  fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1823  (unsigned long)zero_samples);
1824 #else
1825  fprintf(STDERR, " PASS\n");
1826 #endif
1827 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1828  for (k = 0; k<256; k++)
1829  if (filters_used[k] != 0)
1830  fprintf(STDERR, " Filter %d was used %lu times\n",
1831  k, (unsigned long)filters_used[k]);
1832 #endif
1833 #ifdef PNG_TIME_RFC1123_SUPPORTED
1834  if (tIME_chunk_present != 0)
1835  fprintf(STDERR, " tIME = %s\n", tIME_string);
1836 
1837  tIME_chunk_present = 0;
1838 #endif /* TIME_RFC1123 */
1839  }
1840 
1841  else
1842  {
1843  fprintf(STDERR, " FAIL\n");
1844  ierror += kerror;
1845  }
1846 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1847  if (allocation_now != current_allocation)
1848  fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1849  current_allocation - allocation_now);
1850 
1851  if (current_allocation != 0)
1852  {
1853  memory_infop pinfo = pinformation;
1854 
1855  fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
1856  current_allocation);
1857 
1858  while (pinfo != NULL)
1859  {
1860  fprintf(STDERR, " %lu bytes at %p\n",
1861  (unsigned long)pinfo->size,
1862  pinfo->pointer);
1863  pinfo = pinfo->next;
1864  }
1865  }
1866 #endif
1867  }
1868 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1869  fprintf(STDERR, " Current memory allocation: %10d bytes\n",
1870  current_allocation);
1871  fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
1872  maximum_allocation);
1873  fprintf(STDERR, " Total memory allocation: %10d bytes\n",
1874  total_allocation);
1875  fprintf(STDERR, " Number of allocations: %10d\n",
1876  num_allocations);
1877 #endif
1878  }
1879 
1880  else
1881  {
1882  int i;
1883  for (i = 0; i<3; ++i)
1884  {
1885  int kerror;
1886 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1887  int allocation_now = current_allocation;
1888 #endif
1889  if (i == 1)
1890  status_dots_requested = 1;
1891 
1892  else if (verbose == 0)
1893  status_dots_requested = 0;
1894 
1895  if (i == 0 || verbose == 1 || ierror != 0)
1896  {
1897  fprintf(STDERR, "\n Testing %s:", inname);
1898 #if PNG_DEBUG > 0
1899  fprintf(STDERR, "\n");
1900 #endif
1901  }
1902 
1903  kerror = test_one_file(inname, outname);
1904 
1905  if (kerror == 0)
1906  {
1907  if (verbose == 1 || i == 2)
1908  {
1909 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1910  int k;
1911 #endif
1912 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1913  fprintf(STDERR, "\n PASS (%lu zero samples)\n",
1914  (unsigned long)zero_samples);
1915 #else
1916  fprintf(STDERR, " PASS\n");
1917 #endif
1918 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1919  for (k = 0; k<256; k++)
1920  if (filters_used[k] != 0)
1921  fprintf(STDERR, " Filter %d was used %lu times\n",
1922  k, (unsigned long)filters_used[k]);
1923 #endif
1924 #ifdef PNG_TIME_RFC1123_SUPPORTED
1925  if (tIME_chunk_present != 0)
1926  fprintf(STDERR, " tIME = %s\n", tIME_string);
1927 #endif /* TIME_RFC1123 */
1928  }
1929  }
1930 
1931  else
1932  {
1933  if (verbose == 0 && i != 2)
1934  {
1935  fprintf(STDERR, "\n Testing %s:", inname);
1936 #if PNG_DEBUG > 0
1937  fprintf(STDERR, "\n");
1938 #endif
1939  }
1940 
1941  fprintf(STDERR, " FAIL\n");
1942  ierror += kerror;
1943  }
1944 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1945  if (allocation_now != current_allocation)
1946  fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",
1947  current_allocation - allocation_now);
1948 
1949  if (current_allocation != 0)
1950  {
1951  memory_infop pinfo = pinformation;
1952 
1953  fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",
1954  current_allocation);
1955 
1956  while (pinfo != NULL)
1957  {
1958  fprintf(STDERR, " %lu bytes at %p\n",
1959  (unsigned long)pinfo->size, pinfo->pointer);
1960  pinfo = pinfo->next;
1961  }
1962  }
1963 #endif
1964  }
1965 #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG
1966  fprintf(STDERR, " Current memory allocation: %10d bytes\n",
1967  current_allocation);
1968  fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",
1969  maximum_allocation);
1970  fprintf(STDERR, " Total memory allocation: %10d bytes\n",
1971  total_allocation);
1972  fprintf(STDERR, " Number of allocations: %10d\n",
1973  num_allocations);
1974 #endif
1975  }
1976 
1977 #ifdef PNGTEST_TIMING
1978  t_stop = (float)clock();
1979  t_misc += (t_stop - t_start);
1980  t_start = t_stop;
1981  fprintf(STDERR, " CPU time used = %.3f seconds",
1982  (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);
1983  fprintf(STDERR, " (decoding %.3f,\n",
1984  t_decode/(float)CLOCKS_PER_SEC);
1985  fprintf(STDERR, " encoding %.3f ,",
1986  t_encode/(float)CLOCKS_PER_SEC);
1987  fprintf(STDERR, " other %.3f seconds)\n\n",
1988  t_misc/(float)CLOCKS_PER_SEC);
1989 #endif
1990 
1991  if (ierror == 0)
1992  fprintf(STDERR, " libpng passes test\n");
1993 
1994  else
1995  fprintf(STDERR, " libpng FAILS test\n");
1996 
1997  return (int)(ierror != 0);
1998 }
strict
static int strict
Definition: pngtest.c:124
i
int i
Definition: rw_test.cpp:37
zero_samples
static png_uint_32 zero_samples
Definition: pngtest.c:206
inname
static const char * inname
Definition: pngtest.c:1694
PNG_LIBPNG_VER_STRING
#define PNG_LIBPNG_VER_STRING
Definition: png.h:426
status_dots_requested
static int status_dots_requested
Definition: pngtest.c:148
test_one_file
static int test_one_file(const char *inname, const char *outname)
Definition: pngtest.c:830
png_get_copyright
png_const_charp png_get_copyright(png_const_structrp png_ptr)
Definition: png.c:764
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:40
STDERR
#define STDERR
Definition: pngtest.c:42
filters_used
static png_uint_32 filters_used[256]
Definition: pngtest.c:192
PNG_LIBPNG_VER
#define PNG_LIBPNG_VER
Definition: png.h:467
png_access_version_number
png_uint_32 png_access_version_number(void)
Definition: png.c:944
PNG_HEADER_VERSION_STRING
#define PNG_HEADER_VERSION_STRING
Definition: png.h:427
png_get_header_version
png_const_charp png_get_header_version(png_const_structrp png_ptr)
Definition: png.c:810
relaxed
static int relaxed
Definition: pngtest.c:125
outname
static const char * outname
Definition: pngtest.c:1695
png_libpng_ver
#define png_libpng_ver
Definition: png.h:520
verbose
static int verbose
Definition: pngtest.c:123
tIME_chunk_present
static int tIME_chunk_present
Definition: pngtest.c:119
tIME_string
static char tIME_string[29]
Definition: pngtest.c:120

Variable Documentation

int tIME_chunk_present = 0
static
char tIME_string[29] = "tIME chunk is not present"
static
int verbose = 0
static
int strict = 0
static
int relaxed = 0
static
int unsupported_chunks = 0
static
int error_count = 0
static
int warning_count = 0
static
int status_pass = 1
static
int status_dots_requested = 0
static
int status_dots = 1
static
png_uint_32 filters_used[256]
static
png_uint_32 zero_samples
static
struct user_chunk_data user_chunk_data
static
const char* inname = "pngtest.png"
static
const char* outname = "pngout.png"
static