/* makepng.c */

#define _ISOC99_SOURCE

/* Copyright: */

#define COPYRIGHT "\251 2013,2015 John Cunningham Bowler"

/*

 * Last changed in libpng 1.6.20 [November 24, 2015]

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 * Make a test PNG image.  The arguments are as follows:

 *

 *    makepng [--sRGB|--linear|--1.8] [--tRNS] [--nofilters] \

 *       color-type bit-depth [file-name]

 *

 * The color-type may be numeric (and must match the numbers used by the PNG

 * specification) or one of the format names listed below.  The bit-depth is the

 * component bit depth, or the pixel bit-depth for a color-mapped image.

 *

 * Without any options no color-space information is written, with the options

 * an sRGB or the appropriate gAMA chunk is written.  "1.8" refers to the

 * display system used on older Apple computers to correct for high ambient

 * light levels in the viewing environment; it applies a transform of

 * approximately value^(1/1.45) to the color values and so a gAMA chunk of 65909

 * is written (1.45/2.2).

 *

 * The image data is generated internally.  Unless --color is given the images

 * used are as follows:

 *

 * 1 channel: a square image with a diamond, the least luminous colors are on

 *    the edge of the image, the most luminous in the center.

 *

 * 2 channels: the color channel increases in luminosity from top to bottom, the

 *    alpha channel increases in opacity from left to right.

 *

 * 3 channels: linear combinations of, from the top-left corner clockwise,

 *    black, green, white, red.

 *

 * 4 channels: linear combinations of, from the top-left corner clockwise,

 *    transparent, red, green, blue.

 *

 * For color-mapped images a four channel color-map is used and if --tRNS is

 * given the PNG file has a tRNS chunk, as follows:

 *

 * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white

 * 2-bit: entry 0: transparent-green

 *        entry 1: 40%-red

 *        entry 2: 80%-blue

 *        entry 3: opaque-white

 * 4-bit: the 16 combinations of the 2-bit case

 * 8-bit: the 256 combinations of the 4-bit case

 *

 * The palette always has 2^bit-depth entries and the tRNS chunk one fewer.  The

 * image is the 1-channel diamond, but using palette index, not luminosity.

 *

 * For formats other than color-mapped ones if --tRNS is specified a tRNS chunk

 * is generated with all channels equal to the low bits of 0x0101.

 *

 * Image size is determined by the final pixel depth in bits, i.e. channels x

 * bit-depth, as follows:

 *

 * 8 bits or less:    64x64

 * 16 bits:           256x256

 * More than 16 bits: 1024x1024

 *

 * Row filtering is the libpng default but may be turned off (the 'none' filter

 * is used on every row) with the --nofilters option.

 *

 * The images are not interlaced.

 *

 * If file-name is given then the PNG is written to that file, else it is

 * written to stdout.  Notice that stdout is not supported on systems where, by

 * default, it assumes text output; this program makes no attempt to change the

 * text mode of stdout!

 *

 *    makepng --color=<color> ...</color>

 *

 * If --color is given then the whole image has that color, color-mapped images

 * will have exactly one palette entry and all image files with be 16x16 in

 * size.  The color value is 1 to 4 decimal numbers as appropriate for the color

 * type.

 *

 *    makepng --small ...

 *

 * If --small is given the images are no larger than required to include every

 * possible pixel value for the format.

 *

 * For formats with pixels 8 bits or fewer in size the images consist of a

 * single row with 2^pixel-depth pixels, one of every possible value.

 *

 * For formats with 16-bit pixels a 256x256 image is generated containing every

 * possible pixel value.

 *

 * For larger pixel sizes a 256x256 image is generated where the first row

 * consists of each pixel that has identical byte values throughout the pixel

 * followed by rows where the byte values differ within the pixel.

 *

 * In all cases the pixel values are arranged in such a way that the SUB and UP

 * filters give byte sequences for maximal zlib compression.  By default (if

 * --nofilters is not given) the SUB filter is used on the first row and the UP

 * filter on all following rows.

 *

 * The --small option is meant to provide good test-case coverage, however the

 * images are not easy to examine visually.  Without the --small option the

 * images contain identical color values; the pixel values are adjusted

 * according to the gamma encoding with no gamma encoding being interpreted as

 * sRGB.

 *

 * LICENSING

 * =========

 *

 * This code is copyright of the authors, see the COPYRIGHT define above.  The

 * code is licensed as above, using the libpng license.  The code generates

 * images which are solely the product of the code; the options choose which of

 * the many possibilities to generate.  The images that result (but not the code

 * which generates them) are licensed as defined here:

 *

 * IMPORTANT: the COPYRIGHT #define must contain ISO-Latin-1 characters, the

 * IMAGE_LICENSING #define must contain UTF-8 characters.  The 'copyright'

 * symbol 0xA9U (\251) in ISO-Latin-1 encoding and 0xC20xA9 (\302\251) in UTF-8.

 */

#define IMAGE_LICENSING "Dedicated to the public domain per Creative Commons "\

    "license \"CC0 1.0\"; https://creativecommons.org/publicdomain/zero/1.0/"

#include <stddef.h> /* for offsetof */</stddef.h>

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

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

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

#include <ctype.h></ctype.h>

#include <math.h></math.h>

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

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

#include <stdint.h></stdint.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

#include <zlib.h></zlib.h>

/* Work round for GCC complaints about casting a (double) function result to

 * an unsigned:

 */

static unsigned int

flooru(double d)

{

   d = floor(d);

   return (unsigned int)d;

}

static png_byte

floorb(double d)

{

   d = floor(d);

   return (png_byte)d;

}

/* This structure is used for inserting extra chunks (the --insert argument, not

 * documented above.)

 */

typedef struct chunk_insert

{

   struct chunk_insert *next;

   void               (*insert)(png_structp, png_infop, int, png_charpp);

   int                  nparams;

   png_charp            parameters[1];

} chunk_insert;

static unsigned int

channels_of_type(int color_type)

{

   if (color_type & PNG_COLOR_MASK_PALETTE)

      return 1;

   else

   {

      int channels = 1;

      if (color_type & PNG_COLOR_MASK_COLOR)

         channels = 3;

      if (color_type & PNG_COLOR_MASK_ALPHA)

         return channels + 1;

      else

         return channels;

   }

}

static unsigned int

pixel_depth_of_type(int color_type, int bit_depth)

{

   return channels_of_type(color_type) * bit_depth;

}

static unsigned int

image_size_of_type(int color_type, int bit_depth, unsigned int *colors,

   int small)

{

   if (*colors)

      return 16;

   else

   {

      int pixel_depth = pixel_depth_of_type(color_type, bit_depth);

      if (small)

      {

         if (pixel_depth <= 8) /* there will be one row */

            return 1 << pixel_depth;

         else

            return 256;

      }

      else if (pixel_depth < 8)

         return 64;

      else if (pixel_depth > 16)

         return 1024;

      else

         return 256;

   }

}

static void

set_color(png_colorp color, png_bytep trans, unsigned int red,

   unsigned int green, unsigned int blue, unsigned int alpha,

   png_const_bytep gamma_table)

{

   color->red = gamma_table[red];

   color->green = gamma_table[green];

   color->blue = gamma_table[blue];

   *trans = (png_byte)alpha;

}

static int

generate_palette(png_colorp palette, png_bytep trans, int bit_depth,

   png_const_bytep gamma_table, unsigned int *colors)

{

   /*

    * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white

    * 2-bit: entry 0: transparent-green

    *        entry 1: 40%-red

    *        entry 2: 80%-blue

    *        entry 3: opaque-white

    * 4-bit: the 16 combinations of the 2-bit case

    * 8-bit: the 256 combinations of the 4-bit case

    */

   switch (colors[0])

   {

      default:

         fprintf(stderr, "makepng: --colors=...: invalid count %u\n",

            colors[0]);

         exit(1);

      case 1:

         set_color(palette+0, trans+0, colors[1], colors[1], colors[1], 255,

            gamma_table);

         return 1;

      case 2:

         set_color(palette+0, trans+0, colors[1], colors[1], colors[1],

            colors[2], gamma_table);

         return 1;

      case 3:

         set_color(palette+0, trans+0, colors[1], colors[2], colors[3], 255,

            gamma_table);

         return 1;

      case 4:

         set_color(palette+0, trans+0, colors[1], colors[2], colors[3],

            colors[4], gamma_table);

         return 1;

      case 0:

         if (bit_depth == 1)

         {

            set_color(palette+0, trans+0, 255, 0, 0, 0, gamma_table);

            set_color(palette+1, trans+1, 255, 255, 255, 255, gamma_table);

            return 2;

         }

         else

         {

            unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */

            unsigned int x, y;

            volatile unsigned int ip = 0;

            for (x=0; x

            {

               ip = x + (size * y);

               /* size is at most 16, so the scaled value below fits in 16 bits

                */

#              define interp(pos, c1, c2) ((pos * c1) + ((size-pos) * c2))

#              define xyinterp(x, y, c1, c2, c3, c4) (((size * size / 2) +\

                  (interp(x, c1, c2) * y + (size-y) * interp(x, c3, c4))) /\

                  (size*size))

               set_color(palette+ip, trans+ip,

                  /* color:    green, red,blue,white */

                  xyinterp(x, y,   0, 255,   0, 255),

                  xyinterp(x, y, 255,   0,   0, 255),

                  xyinterp(x, y,   0,   0, 255, 255),

                  /* alpha:        0, 102, 204, 255) */

                  xyinterp(x, y,   0, 102, 204, 255),

                  gamma_table);

            }

            return ip+1;

         }

   }

}

static void

set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,

   png_uint_32 value, png_const_bytep gamma_table, double conv)

{

   unsigned int mask = (1U << bit_depth)-1;

   x *= bit_depth;  /* Maximum x is 4*1024, maximum bit_depth is 16 */

   if (value <= mask)

   {

      png_uint_32 offset = x >> 3;

      if (offset < rowbytes && (bit_depth < 16 || offset+1 < rowbytes))

      {

         row += offset;

         switch (bit_depth)

         {

            case 1:

            case 2:

            case 4:

               /* Don't gamma correct - values get smashed */

               {

                  unsigned int shift = (8 - bit_depth) - (x & 0x7U);

                  mask <<= shift;

                  value = (value << shift) & mask;

                  *row = (png_byte)((*row & ~mask) | value);

               }

               return;

            default:

               fprintf(stderr, "makepng: bad bit depth (internal error)\n");

               exit(1);

            case 16:

               value = flooru(65535*pow(value/65535.,conv)+.5);

               *row++ = (png_byte)(value >> 8);

               *row = (png_byte)value;

               return;

            case 8:

               *row = gamma_table[value];

               return;

         }

      }

      else

      {

         fprintf(stderr, "makepng: row buffer overflow (internal error)\n");

         exit(1);

      }

   }

   else

   {

      fprintf(stderr, "makepng: component overflow (internal error)\n");

      exit(1);

   }

}

static int /* filter mask for row */

generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,

   int bit_depth, png_const_bytep gamma_table, double conv,

   unsigned int *colors, int small)

{

   int filters = 0; /* file *MASK*, 0 means the default, not NONE */

   png_uint_32 size_max =

      image_size_of_type(color_type, bit_depth, colors, small)-1;

   png_uint_32 depth_max = (1U << bit_depth)-1; /* up to 65536 */

   if (colors[0] == 0) if (small)

   {

      unsigned int pixel_depth = pixel_depth_of_type(color_type, bit_depth);

      /* For pixel depths less than 16 generate a single row containing all the

       * possible pixel values.  For 16 generate all 65536 byte pair

       * combinations in a 256x256 pixel array.

       */

      switch (pixel_depth)

      {

         case 1:

            assert(y == 0 && rowbytes == 1 && size_max == 1);

            row[0] = 0x6CU; /* binary: 01101100, only top 2 bits used */

            filters = PNG_FILTER_NONE;

            break;

         case 2:

            assert(y == 0 && rowbytes == 1 && size_max == 3);

            row[0] = 0x1BU; /* binary 00011011, all bits used */

            filters = PNG_FILTER_NONE;

            break;

         case 4:

            assert(y == 0 && rowbytes == 8 && size_max == 15);

            row[0] = 0x01U;

            row[1] = 0x23U; /* SUB gives 0x22U for all following bytes */

            row[2] = 0x45U;

            row[3] = 0x67U;

            row[4] = 0x89U;

            row[5] = 0xABU;

            row[6] = 0xCDU;

            row[7] = 0xEFU;

            filters = PNG_FILTER_SUB;

            break;

         case 8:

            /* The row will have all the pixel values in order starting with

             * '1', the SUB filter will change every byte into '1' (including

             * the last, which generates pixel value '0').  Since the SUB filter

             * has value 1 this should result in maximum compression.

             */

            assert(y == 0 && rowbytes == 256 && size_max == 255);

            for (;;)

            {

               row[size_max] = 0xFFU & (size_max+1);

               if (size_max == 0)

                  break;

               --size_max;

            }

            filters = PNG_FILTER_SUB;

            break;

         case 16:

            /* Rows are generated such that each row has a constant difference

             * between the first and second byte of each pixel and so that the

             * difference increases by 1 at each row.  The rows start with the

             * first byte value of 0 and the value increases to 255 across the

             * row.

             *

             * The difference starts at 1, so the first row is:

             *

             *     0 1 1 2 2 3 3 4 ... 254 255 255 0

             *

             * This means that running the SUB filter on the first row produces:

             *

             *   [SUB==1] 0 1 0 1 0 1...

             *

             * Then the difference is 2 on the next row, giving:

             *

             *    0 2 1 3 2 4 3 5 ... 254 0 255 1

             *

             * When the UP filter is run on this libpng produces:

             *

             *   [UP ==2] 0 1 0 1 0 1...

             *

             * And so on for all the remain rows to the final two * rows:

             *

             *    row 254: 0 255 1 0 2 1 3 2 4 3 ... 254 253 255 254

             *    row 255: 0   0 1 1 2 2 3 3 4 4 ... 254 254 255 255

             */

            assert(rowbytes == 512 && size_max == 255);

            for (;;)

            {

               row[2*size_max  ] = 0xFFU & size_max;

               row[2*size_max+1] = 0xFFU & (size_max+y+1);

               if (size_max == 0)

                  break;

               --size_max;

            }

            /* The first row must include PNG_FILTER_UP so that libpng knows we

             * need to keep it for the following row:

             */

            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);

            break;

         case 24:

         case 32:

         case 48:

         case 64:

            /* The rows are filled by an alogorithm similar to the above, in the

             * first row pixel bytes are all equal, increasing from 0 by 1 for

             * each pixel.  In the second row the bytes within a pixel are

             * incremented 1,3,5,7,... from the previous row byte.  Using an odd

             * number ensures all the possible byte values are used.

             */

            assert(size_max == 255 && rowbytes == 256*(pixel_depth>>3));

            pixel_depth >>= 3; /* now in bytes */

            while (rowbytes > 0)

            {

               const size_t pixel_index = --rowbytes/pixel_depth;

               if (y == 0)

                  row[rowbytes] = 0xFFU & pixel_index;

               else

               {

                  const size_t byte_offset =

                     rowbytes - pixel_index * pixel_depth;

                  row[rowbytes] =

                     0xFFU & (pixel_index + (byte_offset * 2*y) + 1);

               }

            }

            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);

            break;

         default:

            assert(0/*NOT REACHED*/);

      }

   }

   else switch (channels_of_type(color_type))

   {

   /* 1 channel: a square image with a diamond, the least luminous colors are on

    *    the edge of the image, the most luminous in the center.

    */

      case 1:

         {

            png_uint_32 x;

            png_uint_32 base = 2*size_max - abs(2*y-size_max);

            for (x=0; x<=size_max; ++x)

            {

               png_uint_32 luma = base - abs(2*x-size_max);

               /* 'luma' is now in the range 0..2*size_max, we need

                * 0..depth_max

                */

               luma = (luma*depth_max + size_max) / (2*size_max);

               set_value(row, rowbytes, x, bit_depth, luma, gamma_table, conv);

            }

         }

         break;

   /* 2 channels: the color channel increases in luminosity from top to bottom,

    *    the alpha channel increases in opacity from left to right.

    */

      case 2:

         {

            png_uint_32 alpha = (depth_max * y * 2 + size_max) / (2 * size_max);

            png_uint_32 x;

            for (x=0; x<=size_max; ++x)

            {

               set_value(row, rowbytes, 2*x, bit_depth,

                  (depth_max * x * 2 + size_max) / (2 * size_max), gamma_table,

                  conv);

               set_value(row, rowbytes, 2*x+1, bit_depth, alpha, gamma_table,

                  conv);

            }

         }

         break;

   /* 3 channels: linear combinations of, from the top-left corner clockwise,

    *    black, green, white, red.

    */

      case 3:

         {

            /* x0: the black->red scale (the value of the red component) at the

             *     start of the row (blue and green are 0).

             * x1: the green->white scale (the value of the red and blue

             *     components at the end of the row; green is depth_max).

             */

            png_uint_32 Y = (depth_max * y * 2 + size_max) / (2 * size_max);

            png_uint_32 x;

            /* Interpolate x/depth_max from start to end:

             *

             *        start end         difference

             * red:     Y    Y            0

             * green:   0   depth_max   depth_max

             * blue:    0    Y            Y

             */

            for (x=0; x<=size_max; ++x)

            {

               set_value(row, rowbytes, 3*x+0, bit_depth, /* red */ Y,

                     gamma_table, conv);

               set_value(row, rowbytes, 3*x+1, bit_depth, /* green */

                  (depth_max * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

               set_value(row, rowbytes, 3*x+2, bit_depth, /* blue */

                  (Y * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

            }

         }

         break;

   /* 4 channels: linear combinations of, from the top-left corner clockwise,

    *    transparent, red, green, blue.

    */

      case 4:

         {

            /* x0: the transparent->blue scale (the value of the blue and alpha

             *     components) at the start of the row (red and green are 0).

             * x1: the red->green scale (the value of the red and green

             *     components at the end of the row; blue is 0 and alpha is

             *     depth_max).

             */

            png_uint_32 Y = (depth_max * y * 2 + size_max) / (2 * size_max);

            png_uint_32 x;

            /* Interpolate x/depth_max from start to end:

             *

             *        start    end       difference

             * red:     0   depth_max-Y depth_max-Y

             * green:   0       Y             Y

             * blue:    Y       0            -Y

             * alpha:   Y    depth_max  depth_max-Y

             */

            for (x=0; x<=size_max; ++x)

            {

               set_value(row, rowbytes, 4*x+0, bit_depth, /* red */

                  ((depth_max-Y) * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

               set_value(row, rowbytes, 4*x+1, bit_depth, /* green */

                  (Y * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

               set_value(row, rowbytes, 4*x+2, bit_depth, /* blue */

                  Y - (Y * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

               set_value(row, rowbytes, 4*x+3, bit_depth, /* alpha */

                  Y + ((depth_max-Y) * x * 2 + size_max) / (2 * size_max),

                  gamma_table, conv);

            }

         }

         break;

      default:

         fprintf(stderr, "makepng: internal bad channel count\n");

         exit(2);

   }

   else if (color_type & PNG_COLOR_MASK_PALETTE)

   {

      /* Palette with fixed color: the image rows are all 0 and the image width

       * is 16.

       */

      memset(row, 0, rowbytes);

   }

   else if (colors[0] == channels_of_type(color_type))

      switch (channels_of_type(color_type))

      {

         case 1:

            {

               const png_uint_32 luma = colors[1];

               png_uint_32 x;

               for (x=0; x<=size_max; ++x)

                  set_value(row, rowbytes, x, bit_depth, luma, gamma_table,

                     conv);

            }

            break;

         case 2:

            {

               const png_uint_32 luma = colors[1];

               const png_uint_32 alpha = colors[2];

               png_uint_32 x;

               for (x=0; x

               {

                  set_value(row, rowbytes, 2*x, bit_depth, luma, gamma_table,

                     conv);

                  set_value(row, rowbytes, 2*x+1, bit_depth, alpha, gamma_table,

                     conv);

               }

            }

            break;

         case 3:

            {

               const png_uint_32 red = colors[1];

               const png_uint_32 green = colors[2];

               const png_uint_32 blue = colors[3];

               png_uint_32 x;

               for (x=0; x<=size_max; ++x)

               {

                  set_value(row, rowbytes, 3*x+0, bit_depth, red, gamma_table,

                     conv);

                  set_value(row, rowbytes, 3*x+1, bit_depth, green, gamma_table,

                     conv);

                  set_value(row, rowbytes, 3*x+2, bit_depth, blue, gamma_table,

                     conv);

               }

            }

            break;

         case 4:

            {

               const png_uint_32 red = colors[1];

               const png_uint_32 green = colors[2];

               const png_uint_32 blue = colors[3];

               const png_uint_32 alpha = colors[4];

               png_uint_32 x;

               for (x=0; x<=size_max; ++x)

               {

                  set_value(row, rowbytes, 4*x+0, bit_depth, red, gamma_table,

                     conv);

                  set_value(row, rowbytes, 4*x+1, bit_depth, green, gamma_table,

                     conv);

                  set_value(row, rowbytes, 4*x+2, bit_depth, blue, gamma_table,

                     conv);

                  set_value(row, rowbytes, 4*x+3, bit_depth, alpha, gamma_table,

                     conv);

               }

            }

         break;

         default:

            fprintf(stderr, "makepng: internal bad channel count\n");

            exit(2);

      }

   else

   {

      fprintf(stderr,

         "makepng: --color: count(%u) does not match channels(%u)\n",

         colors[0], channels_of_type(color_type));

      exit(1);

   }

   return filters;

}

static void PNGCBAPI

makepng_warning(png_structp png_ptr, png_const_charp message)

{

   const char **ep = png_get_error_ptr(png_ptr);

   const char *name;

   if (ep != NULL && *ep != NULL)

      name = *ep;

   else

      name = "makepng";

  fprintf(stderr, "%s: warning: %s\n", name, message);

}

static void PNGCBAPI

makepng_error(png_structp png_ptr, png_const_charp message)

{

   makepng_warning(png_ptr, message);

   png_longjmp(png_ptr, 1);

}

static int /* 0 on success, else an error code */

write_png(const char **name, FILE *fp, int color_type, int bit_depth,

   volatile png_fixed_point gamma, chunk_insert * volatile insert,

   unsigned int filters, unsigned int *colors, int small, int tRNS)

{

   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,

      name, makepng_error, makepng_warning);

   volatile png_infop info_ptr = NULL;

   volatile png_bytep row = NULL;

   if (png_ptr == NULL)

   {

      fprintf(stderr, "makepng: OOM allocating write structure\n");

      return 1;

   }

   if (setjmp(png_jmpbuf(png_ptr)))

   {

      png_structp nv_ptr = png_ptr;

      png_infop nv_info = info_ptr;

      png_ptr = NULL;

      info_ptr = NULL;

      png_destroy_write_struct(&nv_ptr, &nv_info);

      if (row != NULL) free(row);

      return 1;

   }

   /* Allow benign errors so that we can write PNGs with errors */

   png_set_benign_errors(png_ptr, 1/*allowed*/);

   /* Max out the text compression level in an attempt to make the license

    * small.   If --small then do the same for the IDAT.

    */

   if (small)

      png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);

   png_set_text_compression_level(png_ptr, Z_BEST_COMPRESSION);

   png_init_io(png_ptr, fp);

   info_ptr = png_create_info_struct(png_ptr);

   if (info_ptr == NULL)

      png_error(png_ptr, "OOM allocating info structure");

   {

      const unsigned int size =

         image_size_of_type(color_type, bit_depth, colors, small);

      unsigned int ysize;

      png_fixed_point real_gamma = 45455; /* For sRGB */

      png_byte gamma_table[256];

      double conv;

      /* Normally images are square, but with 'small' we want to simply generate

       * all the pixel values, or all that we reasonably can:

       */

      if (small)

      {

         const unsigned int pixel_depth =

            pixel_depth_of_type(color_type, bit_depth);

         if (pixel_depth <= 8U)

         {

            assert(size == (1U<

            ysize = 1U;

         }

         else

         {

            assert(size == 256U);

            ysize = 256U;

         }

      }

      else

         ysize = size;

      /* This function uses the libpng values used on read to carry extra

       * information about the gamma:

       */

      if (gamma == PNG_GAMMA_MAC_18)

         gamma = 65909;

      else if (gamma > 0 && gamma < 1000)

         gamma = PNG_FP_1;

      if (gamma > 0)

         real_gamma = gamma;

      {

         unsigned int i;

         if (real_gamma == 45455) for (i=0; i<256; ++i)

         {

            gamma_table[i] = (png_byte)i;

            conv = 1.;

         }

         else

         {

            /* Convert 'i' from sRGB (45455) to real_gamma, this makes

             * the images look the same regardless of the gAMA chunk.

             */

            conv = real_gamma;

            conv /= 45455;

            gamma_table[0] = 0;

            for (i=1; i<255; ++i)

               gamma_table[i] = floorb(pow(i/255.,conv) * 255 + .5);