/* pngimage.c

 *

 * Copyright (c) 2015 John Cunningham Bowler

 *

 * Last changed in libpng 1.6.20 [December 3, 2015]

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 * Test the png_read_png and png_write_png interfaces.  Given a PNG file load it

 * using png_read_png and then write with png_write_png.  Test all possible

 * transforms.

 */

#include <stdarg.h></stdarg.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#include <errno.h></errno.h>

#include <stdio.h></stdio.h>

#include <assert.h></assert.h>

#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)

#  include <config.h></config.h>

#endif

/* Define the following to use this test against your installed libpng, rather

 * than the one being built here:

 */

#ifdef PNG_FREESTANDING_TESTS

#  include <png.h></png.h>

#else

#  include "../../png.h"

#endif

#ifndef PNG_SETJMP_SUPPORTED

#  include <setjmp.h> /* because png.h did *not* include this */</setjmp.h>

#endif

#if defined(PNG_INFO_IMAGE_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)\

    && (defined(PNG_READ_PNG_SUPPORTED) || PNG_LIBPNG_VER < 10700)

/* If a transform is valid on both read and write this implies that if the

 * transform is applied to read it must also be applied on write to produce

 * meaningful data.  This is because these transforms when performed on read

 * produce data with a memory format that does not correspond to a PNG format.

 *

 * Most of these transforms are invertible; after applying the transform on

 * write the result is the original PNG data that would have would have been

 * read if no transform were applied.

 *

 * The exception is _SHIFT, which destroys the low order bits marked as not

 * significant in a PNG with the sBIT chunk.

 *

 * The following table lists, for each transform, the conditions under which it

 * is expected to do anything.  Conditions are defined as follows:

 *

 * 1) Color mask bits required - simply a mask to AND with color_type; one of

 *    these must be present for the transform to fire, except that 0 means

 *    'always'.

 * 2) Color mask bits which must be absent - another mask - none of these must

 *    be present.

 * 3) Bit depths - a mask of component bit depths for the transform to fire.

 * 4) 'read' - the transform works in png_read_png.

 * 5) 'write' - the transform works in png_write_png.

 * 6) PNG_INFO_chunk; a mask of the chunks that must be present for the

 *    transform to fire.  All must be present - the requirement is that

 *    png_get_valid() & mask == mask, so if mask is 0 there is no requirement.

 *

 * The condition refers to the original image state - if multiple transforms are

 * used together it is possible to cause a transform that wouldn't fire on the

 * original image to fire.

 */

static struct transform_info

{

   const char *name;

   int         transform;

   png_uint_32 valid_chunks;

#     define CHUNK_NONE 0

#     define CHUNK_sBIT PNG_INFO_sBIT

#     define CHUNK_tRNS PNG_INFO_tRNS

   png_byte    color_mask_required;

   png_byte    color_mask_absent;

#     define COLOR_MASK_X   0

#     define COLOR_MASK_P   PNG_COLOR_MASK_PALETTE

#     define COLOR_MASK_C   PNG_COLOR_MASK_COLOR

#     define COLOR_MASK_A   PNG_COLOR_MASK_ALPHA

#     define COLOR_MASK_ALL (PALETTE+COLOR+ALPHA)  /* absent = gray, no alpha */

   png_byte    bit_depths;

#     define BD_ALL  (1 + 2 + 4 + 8 + 16)

#     define BD_PAL  (1 + 2 + 4 + 8)

#     define BD_LOW  (1 + 2 + 4)

#     define BD_16   16

#     define BD_TRUE (8+16) /* i.e. true-color depths */

   png_byte    when;

#     define TRANSFORM_R  1

#     define TRANSFORM_W  2

#     define TRANSFORM_RW 3

   png_byte    tested; /* the transform was tested somewhere */

} transform_info[] =

{

   /* List ALL the PNG_TRANSFORM_ macros here.  Check for support using the READ

    * macros; even if the transform is supported on write it cannot be tested

    * without the read support.

    */

#  define T(name,chunk,cm_required,cm_absent,bd,when)\

   {  #name, PNG_TRANSFORM_ ## name, CHUNK_ ## chunk,\

      COLOR_MASK_ ## cm_required, COLOR_MASK_ ## cm_absent, BD_ ## bd,\

      TRANSFORM_ ## when, 0/*!tested*/ }

#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED

   T(STRIP_16,            NONE, X,   X,   16,  R),

      /* drops the bottom 8 bits when bit depth is 16 */

#endif

#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED

   T(STRIP_ALPHA,         NONE, A,   X,  ALL,  R),

      /* removes the alpha channel if present */

#endif

#ifdef PNG_WRITE_PACK_SUPPORTED

#  define TRANSFORM_RW_PACK TRANSFORM_RW

#else

#  define TRANSFORM_RW_PACK TRANSFORM_R

#endif

#ifdef PNG_READ_PACK_SUPPORTED

   T(PACKING,             NONE, X,   X,  LOW, RW_PACK),

      /* unpacks low-bit-depth components into 1 byte per component on read,

       * reverses this on write.

       */

#endif

#ifdef PNG_WRITE_PACKSWAP_SUPPORTED

#  define TRANSFORM_RW_PACKSWAP TRANSFORM_RW

#else

#  define TRANSFORM_RW_PACKSWAP TRANSFORM_R

#endif

#ifdef PNG_READ_PACKSWAP_SUPPORTED

   T(PACKSWAP,            NONE, X,   X,  LOW, RW_PACKSWAP),

      /* reverses the order of low-bit-depth components packed into a byte */

#endif

#ifdef PNG_READ_EXPAND_SUPPORTED

   T(EXPAND,              NONE, P,   X,  ALL,  R),

      /* expands PLTE PNG files to RGB (no tRNS) or RGBA (tRNS) *

       * Note that the 'EXPAND' transform does lots of different things: */

   T(EXPAND,              NONE, X,   C,  ALL,  R),

      /* expands grayscale PNG files to RGB, or RGBA */

   T(EXPAND,              tRNS, X,   A,  ALL,  R),

      /* expands the tRNS chunk in files without alpha */

#endif

#ifdef PNG_WRITE_INVERT_SUPPORTED

#  define TRANSFORM_RW_INVERT TRANSFORM_RW

#else

#  define TRANSFORM_RW_INVERT TRANSFORM_R

#endif

#ifdef PNG_READ_INVERT_SUPPORTED

   T(INVERT_MONO,         NONE, X,   C,  ALL, RW_INVERT),

      /* converts gray-scale components to 1..0 from 0..1 */

#endif

#ifdef PNG_WRITE_SHIFT_SUPPORTED

#  define TRANSFORM_RW_SHIFT TRANSFORM_RW

#else

#  define TRANSFORM_RW_SHIFT TRANSFORM_R

#endif

#ifdef PNG_READ_SHIFT_SUPPORTED

   T(SHIFT,               sBIT, X,   X,  ALL, RW_SHIFT),

      /* reduces component values to the original range based on the sBIT chunk,

       * this is only partially reversible - the low bits are lost and cannot be

       * recovered on write.  In fact write code replicates the bits to generate

       * new low-order bits.

       */

#endif

#ifdef PNG_WRITE_BGR_SUPPORTED

#  define TRANSFORM_RW_BGR TRANSFORM_RW

#else

#  define TRANSFORM_RW_BGR TRANSFORM_R

#endif

#ifdef PNG_READ_BGR_SUPPORTED

   T(BGR,                 NONE, C,   P, TRUE, RW_BGR),

      /* reverses the rgb component values of true-color pixels */

#endif

#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

#  define TRANSFORM_RW_SWAP_ALPHA TRANSFORM_RW

#else

#  define TRANSFORM_RW_SWAP_ALPHA TRANSFORM_R

#endif

#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED

   T(SWAP_ALPHA,          NONE, A,   X, TRUE, RW_SWAP_ALPHA),

      /* swaps the alpha channel of RGBA or GA pixels to the front - ARGB or

       * AG, on write reverses the process.

       */

#endif

#ifdef PNG_WRITE_SWAP_SUPPORTED

#  define TRANSFORM_RW_SWAP TRANSFORM_RW

#else

#  define TRANSFORM_RW_SWAP TRANSFORM_R

#endif

#ifdef PNG_READ_SWAP_SUPPORTED

   T(SWAP_ENDIAN,         NONE, X,   P,   16, RW_SWAP),

      /* byte-swaps 16-bit component values */

#endif

#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

#  define TRANSFORM_RW_INVERT_ALPHA TRANSFORM_RW

#else

#  define TRANSFORM_RW_INVERT_ALPHA TRANSFORM_R

#endif

#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED

   T(INVERT_ALPHA,        NONE, A,   X, TRUE, RW_INVERT_ALPHA),

      /* converts an alpha channel from 0..1 to 1..0 */

#endif

#ifdef PNG_WRITE_FILLER_SUPPORTED

   T(STRIP_FILLER_BEFORE, NONE, A,   P, TRUE,  W), /* 'A' for a filler! */

      /* on write skips a leading filler channel; testing requires data with a

       * filler channel so this is produced from RGBA or GA images by removing

       * the 'alpha' flag from the color type in place.

       */

   T(STRIP_FILLER_AFTER,  NONE, A,   P, TRUE,  W),

      /* on write strips a trailing filler channel */

#endif

#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED

   T(GRAY_TO_RGB,         NONE, X,   C,  ALL,  R),

      /* expands grayscale images to RGB, also causes the palette part of

       * 'EXPAND' to happen.  Low bit depth grayscale images are expanded to

       * 8-bits per component and no attempt is made to convert the image to a

       * palette image.  While this transform is partially reversible

       * png_write_png does not currently support this.

       */

   T(GRAY_TO_RGB,         NONE, P,   X,  ALL,  R),

      /* The 'palette' side effect mentioned above; a bit bogus but this is the

       * way the libpng code works.

       */

#endif

#ifdef PNG_READ_EXPAND_16_SUPPORTED

   T(EXPAND_16,           NONE, X,   X,  PAL,  R),

      /* expands images to 16-bits per component, as a side effect expands

       * palette images to RGB and expands the tRNS chunk if present, so it can

       * modify 16-bit per component images as well:

       */

   T(EXPAND_16,           tRNS, X,   A,   16,  R),

      /* side effect of EXPAND_16 - expands the tRNS chunk in an RGB or G 16-bit

       * image.

       */

#endif

#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED

   T(SCALE_16,            NONE, X,   X,   16,  R),

      /* scales 16-bit components to 8-bits. */

#endif

   { NULL /*name*/, 0, 0, 0, 0, 0, 0, 0/*!tested*/ }

#undef T

};

#define ARRAY_SIZE(a) ((sizeof a)/(sizeof a[0]))

#define TTABLE_SIZE ARRAY_SIZE(transform_info)

/* Some combinations of options that should be reversible are not; these cases

 * are bugs.

 */

static int known_bad_combos[][2] =

{

   /* problem, antidote */

   { PNG_TRANSFORM_SHIFT | PNG_TRANSFORM_INVERT_ALPHA, 0/*antidote*/ }

};

static int

is_combo(int transforms)

{

   return transforms & (transforms-1); /* non-zero if more than one set bit */

}

static int

first_transform(int transforms)

{

   return transforms & -transforms; /* lowest set bit */

}

static int

is_bad_combo(int transforms)

{

   unsigned int i;

   for (i=0; i

   {

      int combo = known_bad_combos[i][0];

      if ((combo & transforms) == combo &&

         (transforms & known_bad_combos[i][1]) == 0)

         return 1;

   }

   return 0; /* combo is ok */

}

static const char *

transform_name(int t)

   /* The name, if 't' has multiple bits set the name of the lowest set bit is

    * returned.

    */

{

   unsigned int i;

   t &= -t; /* first set bit */

   for (i=0; i

   {

      if ((transform_info[i].transform & t) != 0)

         return transform_info[i].name;

   }

   return "invalid transform";

}

/* Variables calculated by validate_T below and used to record all the supported

 * transforms.  Need (unsigned int) here because of the places where these

 * values are used (unsigned compares in the 'exhaustive' iterator.)

 */

static unsigned int read_transforms, write_transforms, rw_transforms;

static void

validate_T(void)

   /* Validate the above table - this just builds the above values */

{

   unsigned int i;

   for (i=0; i

   {

      if (transform_info[i].when & TRANSFORM_R)

         read_transforms |= transform_info[i].transform;

      if (transform_info[i].when & TRANSFORM_W)

         write_transforms |= transform_info[i].transform;

   }

   /* Reversible transforms are those which are supported on both read and

    * write.

    */

   rw_transforms = read_transforms & write_transforms;

}

/* FILE DATA HANDLING

 *    The original file is cached in memory.  During write the output file is

 *    written to memory.

 *

 *    In both cases the file data is held in a linked list of buffers - not all

 *    of these are in use at any time.

 */

#define NEW(type) ((type *)malloc(sizeof (type)))

#define DELETE(ptr) (free(ptr))

struct buffer_list

{

   struct buffer_list *next;         /* next buffer in list */

   png_byte            buffer[1024]; /* the actual buffer */

};

struct buffer

{

   struct buffer_list  *last;       /* last buffer in use */

   size_t               end_count;  /* bytes in the last buffer */

   struct buffer_list  *current;    /* current buffer being read */

   size_t               read_count; /* count of bytes read from current */

   struct buffer_list   first;      /* the very first buffer */

};

static void

buffer_init(struct buffer *buffer)

   /* Call this only once for a given buffer */

{

   buffer->first.next = NULL;

   buffer->last = NULL;

   buffer->current = NULL;

}

static void

buffer_destroy_list(struct buffer_list *list)

{

   if (list != NULL)

   {

      struct buffer_list *next = list->next;

      DELETE(list);

      buffer_destroy_list(next);

   }

}

static void

buffer_destroy(struct buffer *buffer)

{

   struct buffer_list *list = buffer->first.next;

   buffer_init(buffer);

   buffer_destroy_list(list);

}

#ifdef PNG_WRITE_SUPPORTED

static void

buffer_start_write(struct buffer *buffer)

{

   buffer->last = &buffer->first;

   buffer->end_count = 0;

   buffer->current = NULL;

}

#endif

static void

buffer_start_read(struct buffer *buffer)

{

   buffer->current = &buffer->first;

   buffer->read_count = 0;

}

#ifdef ENOMEM /* required by POSIX 1003.1 */

#  define MEMORY ENOMEM

#else

#  define MEMORY ERANGE /* required by ANSI-C */

#endif

static struct buffer *

get_buffer(png_structp pp)

   /* Used from libpng callbacks to get the current buffer */

{

   return (struct buffer*)png_get_io_ptr(pp);

}

static struct buffer_list *

buffer_extend(struct buffer_list *current)

{

   struct buffer_list *add;

   assert(current->next == NULL);

   add = NEW(struct buffer_list);

   if (add == NULL)

      return NULL;

   add->next = NULL;

   current->next = add;

   return add;

}

/* Load a buffer from a file; does the equivalent of buffer_start_write.  On a

 * read error returns an errno value, else returns 0.

 */

static int

buffer_from_file(struct buffer *buffer, FILE *fp)

{

   struct buffer_list *last = &buffer->first;

   size_t count = 0;

   for (;;)

   {

      size_t r = fread(last->buffer+count, 1/*size*/,

         (sizeof last->buffer)-count, fp);

      if (r > 0)

      {

         count += r;

         if (count >= sizeof last->buffer)

         {

            assert(count == sizeof last->buffer);

            count = 0;

            if (last->next == NULL)

            {

               last = buffer_extend(last);

               if (last == NULL)

                  return MEMORY;

            }

            else

               last = last->next;

         }

      }

      else /* fread failed - probably end of file */

      {

         if (feof(fp))

         {

            buffer->last = last;

            buffer->end_count = count;

            return 0; /* no error */

         }

         /* Some kind of funky error; errno should be non-zero */

         return errno == 0 ? ERANGE : errno;

      }

   }

}

/* This structure is used to control the test of a single file. */

typedef enum

{

   VERBOSE,        /* switches on all messages */

   INFORMATION,

   WARNINGS,       /* switches on warnings */

   LIBPNG_WARNING,

   APP_WARNING,

   ERRORS,         /* just errors */

   APP_FAIL,       /* continuable error - no need to longjmp */

   LIBPNG_ERROR,   /* this and higher cause a longjmp */

   LIBPNG_BUG,     /* erroneous behavior in libpng */

   APP_ERROR,      /* such as out-of-memory in a callback */

   QUIET,          /* no normal messages */

   USER_ERROR,     /* such as file-not-found */

   INTERNAL_ERROR

} error_level;

#define LEVEL_MASK      0xf   /* where the level is in 'options' */

#define EXHAUSTIVE      0x010 /* Test all combinations of active options */

#define STRICT          0x020 /* Fail on warnings as well as errors */

#define LOG             0x040 /* Log pass/fail to stdout */

#define CONTINUE        0x080 /* Continue on APP_FAIL errors */

#define SKIP_BUGS       0x100 /* Skip over known bugs */

#define LOG_SKIPPED     0x200 /* Log skipped bugs */

#define FIND_BAD_COMBOS 0x400 /* Attempt to deduce bad combos */

#define LIST_COMBOS     0x800 /* List combos by name */

/* Result masks apply to the result bits in the 'results' field below; these

 * bits are simple 1U<

 * warnings (--relaxes) or nothing worse than information (--strict)

 */

#define RESULT_STRICT(r)   (((r) & ~((1U<

#define RESULT_RELAXED(r)  (((r) & ~((1U<

struct display

{

   jmp_buf        error_return;      /* Where to go to on error */

   const char    *filename;          /* The name of the original file */

   const char    *operation;         /* Operation being performed */

   int            transforms;        /* Transform used in operation */

   png_uint_32    options;           /* See display_log below */

   png_uint_32    results;           /* A mask of errors seen */

   png_structp    original_pp;       /* used on the original read */

   png_infop      original_ip;       /* set by the original read */

   png_size_t     original_rowbytes; /* of the original rows: */

   png_bytepp     original_rows;     /* from the original read */

   /* Original chunks valid */

   png_uint_32    chunks;

   /* Original IHDR information */

   png_uint_32    width;

   png_uint_32    height;

   int            bit_depth;

   int            color_type;

   int            interlace_method;

   int            compression_method;

   int            filter_method;

   /* Derived information for the original image. */

   int            active_transforms;  /* transforms that do something on read */

   int            ignored_transforms; /* transforms that should do nothing */

   /* Used on a read, both the original read and when validating a written

    * image.

    */

   png_structp    read_pp;

   png_infop      read_ip;

#  ifdef PNG_WRITE_SUPPORTED

      /* Used to write a new image (the original info_ptr is used) */

      png_structp   write_pp;

      struct buffer written_file;   /* where the file gets written */

#  endif

   struct buffer  original_file;     /* Data read from the original file */

};

static void

display_init(struct display *dp)

   /* Call this only once right at the start to initialize the control

    * structure, the (struct buffer) lists are maintained across calls - the

    * memory is not freed.

    */

{

   memset(dp, 0, sizeof *dp);

   dp->options = WARNINGS; /* default to !verbose, !quiet */

   dp->filename = NULL;

   dp->operation = NULL;

   dp->original_pp = NULL;

   dp->original_ip = NULL;

   dp->original_rows = NULL;

   dp->read_pp = NULL;

   dp->read_ip = NULL;

   buffer_init(&dp->original_file);

#  ifdef PNG_WRITE_SUPPORTED

      dp->write_pp = NULL;

      buffer_init(&dp->written_file);

#  endif

}

static void

display_clean_read(struct display *dp)

{

   if (dp->read_pp != NULL)

      png_destroy_read_struct(&dp->read_pp, &dp->read_ip, NULL);

}

#ifdef PNG_WRITE_SUPPORTED

static void

display_clean_write(struct display *dp)

{

      if (dp->write_pp != NULL)

         png_destroy_write_struct(&dp->write_pp, NULL);

}

#endif

static void

display_clean(struct display *dp)

{

#  ifdef PNG_WRITE_SUPPORTED

      display_clean_write(dp);

#  endif

   display_clean_read(dp);

   dp->original_rowbytes = 0;

   dp->original_rows = NULL;

   dp->chunks = 0;

   png_destroy_read_struct(&dp->original_pp, &dp->original_ip, NULL);

   /* leave the filename for error detection */

   dp->results = 0; /* reset for next time */

}

static void

display_destroy(struct display *dp)

{

    /* Release any memory held in the display. */

#  ifdef PNG_WRITE_SUPPORTED

      buffer_destroy(&dp->written_file);

#  endif

   buffer_destroy(&dp->original_file);

}

static struct display *

get_dp(png_structp pp)

   /* The display pointer is always stored in the png_struct error pointer */

{

   struct display *dp = (struct display*)png_get_error_ptr(pp);

   if (dp == NULL)

   {

      fprintf(stderr, "pngimage: internal error (no display)\n");

      exit(99); /* prevents a crash */

   }

   return dp;

}

/* error handling */

#ifdef __GNUC__

#  define VGATTR __attribute__((__format__ (__printf__,3,4)))

   /* Required to quiet GNUC warnings when the compiler sees a stdarg function

    * that calls one of the stdio v APIs.

    */

#else

#  define VGATTR

#endif

static void VGATTR

display_log(struct display *dp, error_level level, const char *fmt, ...)

   /* 'level' is as above, fmt is a stdio style format string.  This routine

    * does not return if level is above LIBPNG_WARNING

    */

{

   dp->results |= 1U << level;

   if (level > (error_level)(dp->options & LEVEL_MASK))

   {

      const char *lp;

      va_list ap;

      switch (level)

      {

         case INFORMATION:    lp = "information"; break;

         case LIBPNG_WARNING: lp = "warning(libpng)"; break;

         case APP_WARNING:    lp = "warning(pngimage)"; break;

         case APP_FAIL:       lp = "error(continuable)"; break;

         case LIBPNG_ERROR:   lp = "error(libpng)"; break;

         case LIBPNG_BUG:     lp = "bug(libpng)"; break;

         case APP_ERROR:      lp = "error(pngimage)"; break;

         case USER_ERROR:     lp = "error(user)"; break;

         case INTERNAL_ERROR: /* anything unexpected is an internal error: */

         case VERBOSE: case WARNINGS: case ERRORS: case QUIET:

         default:             lp = "bug(pngimage)"; break;

      }

      fprintf(stderr, "%s: %s: %s",

         dp->filename != NULL ? dp->filename : "<stdin>", lp, dp->operation);</stdin>

      if (dp->transforms != 0)

      {

         int tr = dp->transforms;

         if (is_combo(tr))

         {

            if (dp->options & LIST_COMBOS)

            {

               int trx = tr;

               fprintf(stderr, "(");

               if (trx)

               {

                  int start = 0;

                  while (trx)

                  {

                     int trz = trx & -trx;

                     if (start) fprintf(stderr, "+");

                     fprintf(stderr, "%s", transform_name(trz));

                     start = 1;

                     trx &= ~trz;

                  }

               }

               else

                  fprintf(stderr, "-");

               fprintf(stderr, ")");

            }

            else

               fprintf(stderr, "(0x%x)", tr);

         }

         else

            fprintf(stderr, "(%s)", transform_name(tr));

      }

      fprintf(stderr, ": ");

      va_start(ap, fmt);

      vfprintf(stderr, fmt, ap);

      va_end(ap);

      fputc('\n', stderr);

   }

   /* else do not output any message */

   /* Errors cause this routine to exit to the fail code */

   if (level > APP_FAIL || (level > ERRORS && !(dp->options & CONTINUE)))

      longjmp(dp->error_return, level);

}

/* error handler callbacks for libpng */

static void PNGCBAPI

display_warning(png_structp pp, png_const_charp warning)

{

   display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);

}

static void PNGCBAPI

display_error(png_structp pp, png_const_charp error)

{

   struct display *dp = get_dp(pp);

   display_log(dp, LIBPNG_ERROR, "%s", error);

}

static void

display_cache_file(struct display *dp, const char *filename)

   /* Does the initial cache of the file. */

{

   FILE *fp;

   int ret;

   dp->filename = filename;

   if (filename != NULL)

   {

      fp = fopen(filename, "rb");

      if (fp == NULL)

         display_log(dp, USER_ERROR, "open failed: %s", strerror(errno));

   }

   else

      fp = stdin;

   ret = buffer_from_file(&dp->original_file, fp);

   fclose(fp);

   if (ret != 0)

      display_log(dp, APP_ERROR, "read failed: %s", strerror(ret));

}

static void

buffer_read(struct display *dp, struct buffer *bp, png_bytep data,

   png_size_t size)

{

   struct buffer_list *last = bp->current;

   size_t read_count = bp->read_count;

   while (size > 0)

   {

      size_t avail;

      if (last == NULL ||

         (last == bp->last && read_count >= bp->end_count))

      {

         display_log(dp, USER_ERROR, "file truncated (%lu bytes)",

            (unsigned long)size);

         /*NOTREACHED*/

         break;

      }

      else if (read_count >= sizeof last->buffer)

      {

         /* Move to the next buffer: */

         last = last->next;

         read_count = 0;

         bp->current = last; /* Avoid update outside the loop */

         /* And do a sanity check (the EOF case is caught above) */

         if (last == NULL)

         {

            display_log(dp, INTERNAL_ERROR, "damaged buffer list");

            /*NOTREACHED*/

            break;

         }

      }

      avail = (sizeof last->buffer) - read_count;

      if (avail > size)

         avail = size;

      memcpy(data, last->buffer + read_count, avail);

      read_count += avail;

      size -= avail;

      data += avail;

   }

   bp->read_count = read_count;

}

static void PNGCBAPI

read_function(png_structp pp, png_bytep data, png_size_t size)

{

   buffer_read(get_dp(pp), get_buffer(pp), data, size);

}

static void

read_png(struct display *dp, struct buffer *bp, const char *operation,

   int transforms)

{

   png_structp pp;

   png_infop   ip;

   /* This cleans out any previous read and sets operation and transforms to

    * empty.

    */

   display_clean_read(dp);

   if (operation != NULL) /* else this is a verify and do not overwrite info */

   {

      dp->operation = operation;

      dp->transforms = transforms;

   }

   dp->read_pp = pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,

      display_error, display_warning);

   if (pp == NULL)

      display_log(dp, LIBPNG_ERROR, "failed to create read struct");

   /* The png_read_png API requires us to make the info struct, but it does the

    * call to png_read_info.

    */

   dp->read_ip = ip = png_create_info_struct(pp);

   if (ip == NULL)

      display_log(dp, LIBPNG_ERROR, "failed to create info struct");

#  ifdef PNG_SET_USER_LIMITS_SUPPORTED

      /* Remove the user limits, if any */

      png_set_user_limits(pp, 0x7fffffff, 0x7fffffff);

#  endif

   /* Set the IO handling */