1 

     2 /* pngwutil.c - utilities to write a PNG file

     3  *

     4  * Last changed in libpng 1.2.30 [August 15, 2008]

     5  * For conditions of distribution and use, see copyright notice in png.h

     6  * Copyright (c) 1998-2008 Glenn Randers-Pehrson

     7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

     8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

     9  */

    10 

    11 #define PNG_INTERNAL

    12 #include "png.h"

    13 #ifdef PNG_WRITE_SUPPORTED

    14 

    15 /* Place a 32-bit number into a buffer in PNG byte order.  We work

    16  * with unsigned numbers for convenience, although one supported

    17  * ancillary chunk uses signed (two's complement) numbers.

    18  */

    19 void PNGAPI

    20 png_save_uint_32(png_bytep buf, png_uint_32 i)

    21 {

    22    buf[0] = (png_byte)((i >> 24) & 0xff);

    23    buf[1] = (png_byte)((i >> 16) & 0xff);

    24    buf[2] = (png_byte)((i >> 8) & 0xff);

    25    buf[3] = (png_byte)(i & 0xff);

    26 }

    27 

    28 /* The png_save_int_32 function assumes integers are stored in two's

    29  * complement format.  If this isn't the case, then this routine needs to

    30  * be modified to write data in two's complement format.

    31  */

    32 void PNGAPI

    33 png_save_int_32(png_bytep buf, png_int_32 i)

    34 {

    35    buf[0] = (png_byte)((i >> 24) & 0xff);

    36    buf[1] = (png_byte)((i >> 16) & 0xff);

    37    buf[2] = (png_byte)((i >> 8) & 0xff);

    38    buf[3] = (png_byte)(i & 0xff);

    39 }

    40 

    41 /* Place a 16-bit number into a buffer in PNG byte order.

    42  * The parameter is declared unsigned int, not png_uint_16,

    43  * just to avoid potential problems on pre-ANSI C compilers.

    44  */

    45 void PNGAPI

    46 png_save_uint_16(png_bytep buf, unsigned int i)

    47 {

    48    buf[0] = (png_byte)((i >> 8) & 0xff);

    49    buf[1] = (png_byte)(i & 0xff);

    50 }

    51 

    52 /* Simple function to write the signature.  If we have already written

    53  * the magic bytes of the signature, or more likely, the PNG stream is

    54  * being embedded into another stream and doesn't need its own signature,

    55  * we should call png_set_sig_bytes() to tell libpng how many of the

    56  * bytes have already been written.

    57  */

    58 void /* PRIVATE */

    59 png_write_sig(png_structp png_ptr)

    60 {

    61    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

    62 

    63    /* write the rest of the 8 byte signature */

    64    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

    65       (png_size_t)(8 - png_ptr->sig_bytes));

    66    if (png_ptr->sig_bytes < 3)

    67       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

    68 }

    69 

    70 /* Write a PNG chunk all at once.  The type is an array of ASCII characters

    71  * representing the chunk name.  The array must be at least 4 bytes in

    72  * length, and does not need to be null terminated.  To be safe, pass the

    73  * pre-defined chunk names here, and if you need a new one, define it

    74  * where the others are defined.  The length is the length of the data.

    75  * All the data must be present.  If that is not possible, use the

    76  * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()

    77  * functions instead.

    78  */

    79 void PNGAPI

    80 png_write_chunk(png_structp png_ptr, png_bytep chunk_name,

    81    png_bytep data, png_size_t length)

    82 {

    83    if (png_ptr == NULL) return;

    84    png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);

    85    png_write_chunk_data(png_ptr, data, (png_size_t)length);

    86    png_write_chunk_end(png_ptr);

    87 }

    88 

    89 /* Write the start of a PNG chunk.  The type is the chunk type.

    90  * The total_length is the sum of the lengths of all the data you will be

    91  * passing in png_write_chunk_data().

    92  */

    93 void PNGAPI

    94 png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,

    95    png_uint_32 length)

    96 {

    97    png_byte buf[8];

    98 

    99    png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,

   100       (unsigned long)length);

   101    if (png_ptr == NULL) return;

   102 

   103    /* write the length and the chunk name */

   104    png_save_uint_32(buf, length);

   105    png_memcpy(buf + 4, chunk_name, 4);

   106    png_write_data(png_ptr, buf, (png_size_t)8);

   107    /* put the chunk name into png_ptr->chunk_name */

   108    png_memcpy(png_ptr->chunk_name, chunk_name, 4);

   109    /* reset the crc and run it over the chunk name */

   110    png_reset_crc(png_ptr);

   111    png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);

   112 }

   113 

   114 /* Write the data of a PNG chunk started with png_write_chunk_start().

   115  * Note that multiple calls to this function are allowed, and that the

   116  * sum of the lengths from these calls *must* add up to the total_length

   117  * given to png_write_chunk_start().

   118  */

   119 void PNGAPI

   120 png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)

   121 {

   122    /* write the data, and run the CRC over it */

   123    if (png_ptr == NULL) return;

   124    if (data != NULL && length > 0)

   125    {

   126       png_write_data(png_ptr, data, length);

   127       /* update the CRC after writing the data,

   128        * in case that the user I/O routine alters it.

   129        */

   130       png_calculate_crc(png_ptr, data, length);

   131    }

   132 }

   133 

   134 /* Finish a chunk started with png_write_chunk_start(). */

   135 void PNGAPI

   136 png_write_chunk_end(png_structp png_ptr)

   137 {

   138    png_byte buf[4];

   139 

   140    if (png_ptr == NULL) return;

   141 

   142    /* write the crc in a single operation */

   143    png_save_uint_32(buf, png_ptr->crc);

   144 

   145    png_write_data(png_ptr, buf, (png_size_t)4);

   146 }

   147 

   148 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)

   149 /*

   150  * This pair of functions encapsulates the operation of (a) compressing a

   151  * text string, and (b) issuing it later as a series of chunk data writes.

   152  * The compression_state structure is shared context for these functions

   153  * set up by the caller in order to make the whole mess thread-safe.

   154  */

   155 

   156 typedef struct

   157 {

   158     char *input;   /* the uncompressed input data */

   159     int input_len;   /* its length */

   160     int num_output_ptr; /* number of output pointers used */

   161     int max_output_ptr; /* size of output_ptr */

   162     png_charpp output_ptr; /* array of pointers to output */

   163 } compression_state;

   164 

   165 /* compress given text into storage in the png_ptr structure */

   166 static int /* PRIVATE */

   167 png_text_compress(png_structp png_ptr,

   168         png_charp text, png_size_t text_len, int compression,

   169         compression_state *comp)

   170 {

   171    int ret;

   172 

   173    comp->num_output_ptr = 0;

   174    comp->max_output_ptr = 0;

   175    comp->output_ptr = NULL;

   176    comp->input = NULL;

   177    comp->input_len = 0;

   178 

   179    /* we may just want to pass the text right through */

   180    if (compression == PNG_TEXT_COMPRESSION_NONE)

   181    {

   182        comp->input = text;

   183        comp->input_len = text_len;

   184        return((int)text_len);

   185    }

   186 

   187    if (compression >= PNG_TEXT_COMPRESSION_LAST)

   188    {

   189 #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

   190       char msg[50];

   191       png_snprintf(msg, 50, "Unknown compression type %d", compression);

   192       png_warning(png_ptr, msg);

   193 #else

   194       png_warning(png_ptr, "Unknown compression type");

   195 #endif

   196    }

   197 

   198    /* We can't write the chunk until we find out how much data we have,

   199     * which means we need to run the compressor first and save the

   200     * output.  This shouldn't be a problem, as the vast majority of

   201     * comments should be reasonable, but we will set up an array of

   202     * malloc'd pointers to be sure.

   203     *

   204     * If we knew the application was well behaved, we could simplify this

   205     * greatly by assuming we can always malloc an output buffer large

   206     * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

   207     * and malloc this directly.  The only time this would be a bad idea is

   208     * if we can't malloc more than 64K and we have 64K of random input

   209     * data, or if the input string is incredibly large (although this

   210     * wouldn't cause a failure, just a slowdown due to swapping).

   211     */

   212 

   213    /* set up the compression buffers */

   214    png_ptr->zstream.avail_in = (uInt)text_len;

   215    png_ptr->zstream.next_in = (Bytef *)text;

   216    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

   217    png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;

   218 

   219    /* this is the same compression loop as in png_write_row() */

   220    do

   221    {

   222       /* compress the data */

   223       ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

   224       if (ret != Z_OK)

   225       {

   226          /* error */

   227          if (png_ptr->zstream.msg != NULL)

   228             png_error(png_ptr, png_ptr->zstream.msg);

   229          else

   230             png_error(png_ptr, "zlib error");

   231       }

   232       /* check to see if we need more room */

   233       if (!(png_ptr->zstream.avail_out))

   234       {

   235          /* make sure the output array has room */

   236          if (comp->num_output_ptr >= comp->max_output_ptr)

   237          {

   238             int old_max;

   239 

   240             old_max = comp->max_output_ptr;

   241             comp->max_output_ptr = comp->num_output_ptr + 4;

   242             if (comp->output_ptr != NULL)

   243             {

   244                png_charpp old_ptr;

   245 

   246                old_ptr = comp->output_ptr;

   247                comp->output_ptr = (png_charpp)png_malloc(png_ptr,

   248                   (png_uint_32)

   249                   (comp->max_output_ptr * png_sizeof(png_charpp)));

   250                png_memcpy(comp->output_ptr, old_ptr, old_max

   251                   * png_sizeof(png_charp));

   252                png_free(png_ptr, old_ptr);

   253             }

   254             else

   255                comp->output_ptr = (png_charpp)png_malloc(png_ptr,

   256                   (png_uint_32)

   257                   (comp->max_output_ptr * png_sizeof(png_charp)));

   258          }

   259 

   260          /* save the data */

   261          comp->output_ptr[comp->num_output_ptr] =

   262             (png_charp)png_malloc(png_ptr,

   263             (png_uint_32)png_ptr->zbuf_size);

   264          png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

   265             png_ptr->zbuf_size);

   266          comp->num_output_ptr++;

   267 

   268          /* and reset the buffer */

   269          png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

   270          png_ptr->zstream.next_out = png_ptr->zbuf;

   271       }

   272    /* continue until we don't have any more to compress */

   273    } while (png_ptr->zstream.avail_in);

   274 

   275    /* finish the compression */

   276    do

   277    {

   278       /* tell zlib we are finished */

   279       ret = deflate(&png_ptr->zstream, Z_FINISH);

   280 

   281       if (ret == Z_OK)

   282       {

   283          /* check to see if we need more room */

   284          if (!(png_ptr->zstream.avail_out))

   285          {

   286             /* check to make sure our output array has room */

   287             if (comp->num_output_ptr >= comp->max_output_ptr)

   288             {

   289                int old_max;

   290 

   291                old_max = comp->max_output_ptr;

   292                comp->max_output_ptr = comp->num_output_ptr + 4;

   293                if (comp->output_ptr != NULL)

   294                {

   295                   png_charpp old_ptr;

   296 

   297                   old_ptr = comp->output_ptr;

   298                   /* This could be optimized to realloc() */

   299                   comp->output_ptr = (png_charpp)png_malloc(png_ptr,

   300                      (png_uint_32)(comp->max_output_ptr *

   301                      png_sizeof(png_charp)));

   302                   png_memcpy(comp->output_ptr, old_ptr,

   303                      old_max * png_sizeof(png_charp));

   304                   png_free(png_ptr, old_ptr);

   305                }

   306                else

   307                   comp->output_ptr = (png_charpp)png_malloc(png_ptr,

   308                      (png_uint_32)(comp->max_output_ptr *

   309                      png_sizeof(png_charp)));

   310             }

   311 

   312             /* save off the data */

   313             comp->output_ptr[comp->num_output_ptr] =

   314                (png_charp)png_malloc(png_ptr,

   315                (png_uint_32)png_ptr->zbuf_size);

   316             png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

   317                png_ptr->zbuf_size);

   318             comp->num_output_ptr++;

   319 

   320             /* and reset the buffer pointers */

   321             png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

   322             png_ptr->zstream.next_out = png_ptr->zbuf;

   323          }

   324       }

   325       else if (ret != Z_STREAM_END)

   326       {

   327          /* we got an error */

   328          if (png_ptr->zstream.msg != NULL)

   329             png_error(png_ptr, png_ptr->zstream.msg);

   330          else

   331             png_error(png_ptr, "zlib error");

   332       }

   333    } while (ret != Z_STREAM_END);

   334 

   335    /* text length is number of buffers plus last buffer */

   336    text_len = png_ptr->zbuf_size * comp->num_output_ptr;

   337    if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)

   338       text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;

   339 

   340    return((int)text_len);

   341 }

   342 

   343 /* ship the compressed text out via chunk writes */

   344 static void /* PRIVATE */

   345 png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

   346 {

   347    int i;

   348 

   349    /* handle the no-compression case */

   350    if (comp->input)

   351    {

   352        png_write_chunk_data(png_ptr, (png_bytep)comp->input,

   353                             (png_size_t)comp->input_len);

   354        return;

   355    }

   356 

   357    /* write saved output buffers, if any */

   358    for (i = 0; i < comp->num_output_ptr; i++)

   359    {

   360       png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],

   361          (png_size_t)png_ptr->zbuf_size);

   362       png_free(png_ptr, comp->output_ptr[i]);

   363        comp->output_ptr[i]=NULL;

   364    }

   365    if (comp->max_output_ptr != 0)

   366       png_free(png_ptr, comp->output_ptr);

   367        comp->output_ptr=NULL;

   368    /* write anything left in zbuf */

   369    if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)

   370       png_write_chunk_data(png_ptr, png_ptr->zbuf,

   371          (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));

   372 

   373    /* reset zlib for another zTXt/iTXt or image data */

   374    deflateReset(&png_ptr->zstream);

   375    png_ptr->zstream.data_type = Z_BINARY;

   376 }

   377 #endif

   378 

   379 /* Write the IHDR chunk, and update the png_struct with the necessary

   380  * information.  Note that the rest of this code depends upon this

   381  * information being correct.

   382  */

   383 void /* PRIVATE */

   384 png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,

   385    int bit_depth, int color_type, int compression_type, int filter_type,

   386    int interlace_type)

   387 {

   388 #ifdef PNG_USE_LOCAL_ARRAYS

   389    PNG_IHDR;

   390 #endif

   391    int ret;

   392 

   393    png_byte buf[13]; /* buffer to store the IHDR info */

   394 

   395    png_debug(1, "in png_write_IHDR\n");

   396    /* Check that we have valid input data from the application info */

   397    switch (color_type)

   398    {

   399       case PNG_COLOR_TYPE_GRAY:

   400          switch (bit_depth)

   401          {

   402             case 1:

   403             case 2:

   404             case 4:

   405             case 8:

   406             case 16: png_ptr->channels = 1; break;

   407             default: png_error(png_ptr, "Invalid bit depth for grayscale image");

   408          }

   409          break;

   410       case PNG_COLOR_TYPE_RGB:

   411          if (bit_depth != 8 && bit_depth != 16)

   412             png_error(png_ptr, "Invalid bit depth for RGB image");

   413          png_ptr->channels = 3;

   414          break;

   415       case PNG_COLOR_TYPE_PALETTE:

   416          switch (bit_depth)

   417          {

   418             case 1:

   419             case 2:

   420             case 4:

   421             case 8: png_ptr->channels = 1; break;

   422             default: png_error(png_ptr, "Invalid bit depth for paletted image");

   423          }

   424          break;

   425       case PNG_COLOR_TYPE_GRAY_ALPHA:

   426          if (bit_depth != 8 && bit_depth != 16)

   427             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");

   428          png_ptr->channels = 2;

   429          break;

   430       case PNG_COLOR_TYPE_RGB_ALPHA:

   431          if (bit_depth != 8 && bit_depth != 16)

   432             png_error(png_ptr, "Invalid bit depth for RGBA image");

   433          png_ptr->channels = 4;

   434          break;

   435       default:

   436          png_error(png_ptr, "Invalid image color type specified");

   437    }

   438 

   439    if (compression_type != PNG_COMPRESSION_TYPE_BASE)

   440    {

   441       png_warning(png_ptr, "Invalid compression type specified");

   442       compression_type = PNG_COMPRESSION_TYPE_BASE;

   443    }

   444 

   445    /* Write filter_method 64 (intrapixel differencing) only if

   446     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

   447     * 2. Libpng did not write a PNG signature (this filter_method is only

   448     *    used in PNG datastreams that are embedded in MNG datastreams) and

   449     * 3. The application called png_permit_mng_features with a mask that

   450     *    included PNG_FLAG_MNG_FILTER_64 and

   451     * 4. The filter_method is 64 and

   452     * 5. The color_type is RGB or RGBA

   453     */

   454    if (

   455 #if defined(PNG_MNG_FEATURES_SUPPORTED)

   456       !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

   457       ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&

   458       (color_type == PNG_COLOR_TYPE_RGB ||

   459        color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

   460       (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

   461 #endif

   462       filter_type != PNG_FILTER_TYPE_BASE)

   463    {

   464       png_warning(png_ptr, "Invalid filter type specified");

   465       filter_type = PNG_FILTER_TYPE_BASE;

   466    }

   467 

   468 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   469    if (interlace_type != PNG_INTERLACE_NONE &&

   470       interlace_type != PNG_INTERLACE_ADAM7)

   471    {

   472       png_warning(png_ptr, "Invalid interlace type specified");

   473       interlace_type = PNG_INTERLACE_ADAM7;

   474    }

   475 #else

   476    interlace_type=PNG_INTERLACE_NONE;

   477 #endif

   478 

   479    /* save off the relevent information */

   480    png_ptr->bit_depth = (png_byte)bit_depth;

   481    png_ptr->color_type = (png_byte)color_type;

   482    png_ptr->interlaced = (png_byte)interlace_type;

   483 #if defined(PNG_MNG_FEATURES_SUPPORTED)

   484    png_ptr->filter_type = (png_byte)filter_type;

   485 #endif

   486    png_ptr->compression_type = (png_byte)compression_type;

   487    png_ptr->width = width;

   488    png_ptr->height = height;

   489 

   490    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

   491    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);

   492    /* set the usr info, so any transformations can modify it */

   493    png_ptr->usr_width = png_ptr->width;

   494    png_ptr->usr_bit_depth = png_ptr->bit_depth;

   495    png_ptr->usr_channels = png_ptr->channels;

   496 

   497    /* pack the header information into the buffer */

   498    png_save_uint_32(buf, width);

   499    png_save_uint_32(buf + 4, height);

   500    buf[8] = (png_byte)bit_depth;

   501    buf[9] = (png_byte)color_type;

   502    buf[10] = (png_byte)compression_type;

   503    buf[11] = (png_byte)filter_type;

   504    buf[12] = (png_byte)interlace_type;

   505 

   506    /* write the chunk */

   507    png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);

   508 

   509    /* initialize zlib with PNG info */

   510    png_ptr->zstream.zalloc = png_zalloc;

   511    png_ptr->zstream.zfree = png_zfree;

   512    png_ptr->zstream.opaque = (voidpf)png_ptr;

   513    if (!(png_ptr->do_filter))

   514    {

   515       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

   516          png_ptr->bit_depth < 8)

   517          png_ptr->do_filter = PNG_FILTER_NONE;

   518       else

   519          png_ptr->do_filter = PNG_ALL_FILTERS;

   520    }

   521    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))

   522    {

   523       if (png_ptr->do_filter != PNG_FILTER_NONE)

   524          png_ptr->zlib_strategy = Z_FILTERED;

   525       else

   526          png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

   527    }

   528    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))

   529       png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

   530    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))

   531       png_ptr->zlib_mem_level = 8;

   532    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))

   533       png_ptr->zlib_window_bits = 15;

   534    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))

   535       png_ptr->zlib_method = 8;

   536    ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

   537          png_ptr->zlib_method, png_ptr->zlib_window_bits,

   538          png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

   539    if (ret != Z_OK)

   540    {

   541       if (ret == Z_VERSION_ERROR) png_error(png_ptr,

   542           "zlib failed to initialize compressor -- version error");

   543       if (ret == Z_STREAM_ERROR) png_error(png_ptr,

   544            "zlib failed to initialize compressor -- stream error");

   545       if (ret == Z_MEM_ERROR) png_error(png_ptr,

   546            "zlib failed to initialize compressor -- mem error");

   547       png_error(png_ptr, "zlib failed to initialize compressor");

   548    }

   549    png_ptr->zstream.next_out = png_ptr->zbuf;

   550    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

   551    /* libpng is not interested in zstream.data_type */

   552    /* set it to a predefined value, to avoid its evaluation inside zlib */

   553    png_ptr->zstream.data_type = Z_BINARY;

   554 

   555    png_ptr->mode = PNG_HAVE_IHDR;

   556 }

   557 

   558 /* write the palette.  We are careful not to trust png_color to be in the

   559  * correct order for PNG, so people can redefine it to any convenient

   560  * structure.

   561  */

   562 void /* PRIVATE */

   563 png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)

   564 {

   565 #ifdef PNG_USE_LOCAL_ARRAYS

   566    PNG_PLTE;

   567 #endif

   568    png_uint_32 i;

   569    png_colorp pal_ptr;

   570    png_byte buf[3];

   571 

   572    png_debug(1, "in png_write_PLTE\n");

   573    if ((

   574 #if defined(PNG_MNG_FEATURES_SUPPORTED)

   575         !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

   576 #endif

   577         num_pal == 0) || num_pal > 256)

   578    {

   579      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

   580      {

   581         png_error(png_ptr, "Invalid number of colors in palette");

   582      }

   583      else

   584      {

   585         png_warning(png_ptr, "Invalid number of colors in palette");

   586         return;

   587      }

   588    }

   589 

   590    if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

   591    {

   592       png_warning(png_ptr,

   593         "Ignoring request to write a PLTE chunk in grayscale PNG");

   594       return;

   595    }

   596 

   597    png_ptr->num_palette = (png_uint_16)num_pal;

   598    png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);

   599 

   600    png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,

   601      (png_uint_32)(num_pal * 3));

   602 #ifndef PNG_NO_POINTER_INDEXING

   603    for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)

   604    {

   605       buf[0] = pal_ptr->red;

   606       buf[1] = pal_ptr->green;

   607       buf[2] = pal_ptr->blue;

   608       png_write_chunk_data(png_ptr, buf, (png_size_t)3);

   609    }

   610 #else

   611    /* This is a little slower but some buggy compilers need to do this instead */

   612    pal_ptr=palette;

   613    for (i = 0; i < num_pal; i++)

   614    {

   615       buf[0] = pal_ptr[i].red;

   616       buf[1] = pal_ptr[i].green;

   617       buf[2] = pal_ptr[i].blue;

   618       png_write_chunk_data(png_ptr, buf, (png_size_t)3);

   619    }

   620 #endif

   621    png_write_chunk_end(png_ptr);

   622    png_ptr->mode |= PNG_HAVE_PLTE;

   623 }

   624 

   625 /* write an IDAT chunk */

   626 void /* PRIVATE */

   627 png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)

   628 {

   629 #ifdef PNG_USE_LOCAL_ARRAYS

   630    PNG_IDAT;

   631 #endif

   632    png_debug(1, "in png_write_IDAT\n");

   633 

   634    /* Optimize the CMF field in the zlib stream. */

   635    /* This hack of the zlib stream is compliant to the stream specification. */

   636    if (!(png_ptr->mode & PNG_HAVE_IDAT) &&

   637        png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

   638    {

   639       unsigned int z_cmf = data[0];  /* zlib compression method and flags */

   640       if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)

   641       {

   642          /* Avoid memory underflows and multiplication overflows. */

   643          /* The conditions below are practically always satisfied;

   644             however, they still must be checked. */

   645          if (length >= 2 &&

   646              png_ptr->height < 16384 && png_ptr->width < 16384)

   647          {

   648             png_uint_32 uncompressed_idat_size = png_ptr->height *

   649                ((png_ptr->width *

   650                png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

   651             unsigned int z_cinfo = z_cmf >> 4;

   652             unsigned int half_z_window_size = 1 << (z_cinfo + 7);

   653             while (uncompressed_idat_size <= half_z_window_size &&

   654                    half_z_window_size >= 256)

   655             {

   656                z_cinfo--;

   657                half_z_window_size >>= 1;

   658             }

   659             z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

   660             if (data[0] != (png_byte)z_cmf)

   661             {

   662                data[0] = (png_byte)z_cmf;

   663                data[1] &= 0xe0;

   664                data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);

   665             }

   666          }

   667       }

   668       else

   669          png_error(png_ptr,

   670             "Invalid zlib compression method or flags in IDAT");

   671    }

   672 

   673    png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);

   674    png_ptr->mode |= PNG_HAVE_IDAT;

   675 }

   676 

   677 /* write an IEND chunk */

   678 void /* PRIVATE */

   679 png_write_IEND(png_structp png_ptr)

   680 {

   681 #ifdef PNG_USE_LOCAL_ARRAYS

   682    PNG_IEND;

   683 #endif

   684    png_debug(1, "in png_write_IEND\n");

   685    png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,

   686      (png_size_t)0);

   687    png_ptr->mode |= PNG_HAVE_IEND;

   688 }

   689 

   690 #if defined(PNG_WRITE_gAMA_SUPPORTED)

   691 /* write a gAMA chunk */

   692 #ifdef PNG_FLOATING_POINT_SUPPORTED

   693 void /* PRIVATE */

   694 png_write_gAMA(png_structp png_ptr, double file_gamma)

   695 {

   696 #ifdef PNG_USE_LOCAL_ARRAYS

   697    PNG_gAMA;

   698 #endif

   699    png_uint_32 igamma;

   700    png_byte buf[4];

   701 

   702    png_debug(1, "in png_write_gAMA\n");

   703    /* file_gamma is saved in 1/100,000ths */

   704    igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);

   705    png_save_uint_32(buf, igamma);

   706    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

   707 }

   708 #endif

   709 #ifdef PNG_FIXED_POINT_SUPPORTED

   710 void /* PRIVATE */

   711 png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

   712 {

   713 #ifdef PNG_USE_LOCAL_ARRAYS

   714    PNG_gAMA;

   715 #endif

   716    png_byte buf[4];

   717 

   718    png_debug(1, "in png_write_gAMA\n");

   719    /* file_gamma is saved in 1/100,000ths */

   720    png_save_uint_32(buf, (png_uint_32)file_gamma);

   721    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

   722 }

   723 #endif

   724 #endif

   725 

   726 #if defined(PNG_WRITE_sRGB_SUPPORTED)

   727 /* write a sRGB chunk */

   728 void /* PRIVATE */

   729 png_write_sRGB(png_structp png_ptr, int srgb_intent)

   730 {

   731 #ifdef PNG_USE_LOCAL_ARRAYS

   732    PNG_sRGB;

   733 #endif

   734    png_byte buf[1];

   735 

   736    png_debug(1, "in png_write_sRGB\n");

   737    if (srgb_intent >= PNG_sRGB_INTENT_LAST)

   738          png_warning(png_ptr,

   739             "Invalid sRGB rendering intent specified");

   740    buf[0]=(png_byte)srgb_intent;

   741    png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);

   742 }

   743 #endif

   744 

   745 #if defined(PNG_WRITE_iCCP_SUPPORTED)

   746 /* write an iCCP chunk */

   747 void /* PRIVATE */

   748 png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,

   749    png_charp profile, int profile_len)

   750 {

   751 #ifdef PNG_USE_LOCAL_ARRAYS

   752    PNG_iCCP;

   753 #endif

   754    png_size_t name_len;

   755    png_charp new_name;

   756    compression_state comp;

   757    int embedded_profile_len = 0;

   758 

   759    png_debug(1, "in png_write_iCCP\n");

   760 

   761    comp.num_output_ptr = 0;

   762    comp.max_output_ptr = 0;

   763    comp.output_ptr = NULL;

   764    comp.input = NULL;

   765    comp.input_len = 0;

   766 

   767    if (name == NULL || (name_len = png_check_keyword(png_ptr, name,

   768       &new_name)) == 0)

   769    {

   770       png_warning(png_ptr, "Empty keyword in iCCP chunk");

   771       return;

   772    }

   773 

   774    if (compression_type != PNG_COMPRESSION_TYPE_BASE)

   775       png_warning(png_ptr, "Unknown compression type in iCCP chunk");

   776 

   777    if (profile == NULL)

   778       profile_len = 0;

   779 

   780    if (profile_len > 3)

   781       embedded_profile_len =

   782           ((*( (png_bytep)profile    ))<<24) |

   783           ((*( (png_bytep)profile + 1))<<16) |

   784           ((*( (png_bytep)profile + 2))<< 8) |

   785           ((*( (png_bytep)profile + 3))    );

   786 

   787    if (profile_len < embedded_profile_len)

   788    {

   789       png_warning(png_ptr,

   790         "Embedded profile length too large in iCCP chunk");

   791       return;

   792    }

   793 

   794    if (profile_len > embedded_profile_len)

   795    {

   796       png_warning(png_ptr,

   797         "Truncating profile to actual length in iCCP chunk");

   798       profile_len = embedded_profile_len;

   799    }

   800 

   801    if (profile_len)

   802       profile_len = png_text_compress(png_ptr, profile,

   803         (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);

   804 

   805    /* make sure we include the NULL after the name and the compression type */

   806    png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

   807           (png_uint_32)(name_len + profile_len + 2));

   808    new_name[name_len + 1] = 0x00;

   809    png_write_chunk_data(png_ptr, (png_bytep)new_name,

   810      (png_size_t)(name_len + 2));

   811 

   812    if (profile_len)

   813       png_write_compressed_data_out(png_ptr, &comp);

   814 

   815    png_write_chunk_end(png_ptr);

   816    png_free(png_ptr, new_name);

   817 }

   818 #endif

   819 

   820 #if defined(PNG_WRITE_sPLT_SUPPORTED)

   821 /* write a sPLT chunk */

   822 void /* PRIVATE */

   823 png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)

   824 {

   825 #ifdef PNG_USE_LOCAL_ARRAYS

   826    PNG_sPLT;

   827 #endif

   828    png_size_t name_len;

   829    png_charp new_name;

   830    png_byte entrybuf[10];

   831    int entry_size = (spalette->depth == 8 ? 6 : 10);

   832    int palette_size = entry_size * spalette->nentries;

   833    png_sPLT_entryp ep;

   834 #ifdef PNG_NO_POINTER_INDEXING

   835    int i;

   836 #endif

   837 

   838    png_debug(1, "in png_write_sPLT\n");

   839    if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,

   840       spalette->name, &new_name))==0)

   841    {

   842       png_warning(png_ptr, "Empty keyword in sPLT chunk");

   843       return;

   844    }

   845 

   846    /* make sure we include the NULL after the name */

   847    png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,

   848      (png_uint_32)(name_len + 2 + palette_size));

   849    png_write_chunk_data(png_ptr, (png_bytep)new_name,

   850      (png_size_t)(name_len + 1));

   851    png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);

   852 

   853    /* loop through each palette entry, writing appropriately */

   854 #ifndef PNG_NO_POINTER_INDEXING

   855    for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)

   856    {

   857       if (spalette->depth == 8)

   858       {

   859           entrybuf[0] = (png_byte)ep->red;

   860           entrybuf[1] = (png_byte)ep->green;

   861           entrybuf[2] = (png_byte)ep->blue;

   862           entrybuf[3] = (png_byte)ep->alpha;

   863           png_save_uint_16(entrybuf + 4, ep->frequency);

   864       }

   865       else

   866       {

   867           png_save_uint_16(entrybuf + 0, ep->red);

   868           png_save_uint_16(entrybuf + 2, ep->green);

   869           png_save_uint_16(entrybuf + 4, ep->blue);

   870           png_save_uint_16(entrybuf + 6, ep->alpha);

   871           png_save_uint_16(entrybuf + 8, ep->frequency);

   872       }

   873       png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

   874    }

   875 #else

   876    ep=spalette->entries;

   877    for (i=0; i>spalette->nentries; i++)

   878    {

   879       if (spalette->depth == 8)

   880       {

   881           entrybuf[0] = (png_byte)ep[i].red;

   882           entrybuf[1] = (png_byte)ep[i].green;

   883           entrybuf[2] = (png_byte)ep[i].blue;

   884           entrybuf[3] = (png_byte)ep[i].alpha;

   885           png_save_uint_16(entrybuf + 4, ep[i].frequency);

   886       }

   887       else

   888       {

   889           png_save_uint_16(entrybuf + 0, ep[i].red);

   890           png_save_uint_16(entrybuf + 2, ep[i].green);

   891           png_save_uint_16(entrybuf + 4, ep[i].blue);

   892           png_save_uint_16(entrybuf + 6, ep[i].alpha);

   893           png_save_uint_16(entrybuf + 8, ep[i].frequency);

   894       }

   895       png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

   896    }

   897 #endif

   898 

   899    png_write_chunk_end(png_ptr);

   900    png_free(png_ptr, new_name);

   901 }

   902 #endif

   903 

   904 #if defined(PNG_WRITE_sBIT_SUPPORTED)

   905 /* write the sBIT chunk */

   906 void /* PRIVATE */

   907 png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)

   908 {

   909 #ifdef PNG_USE_LOCAL_ARRAYS

   910    PNG_sBIT;

   911 #endif

   912    png_byte buf[4];

   913    png_size_t size;

   914 

   915    png_debug(1, "in png_write_sBIT\n");

   916    /* make sure we don't depend upon the order of PNG_COLOR_8 */

   917    if (color_type & PNG_COLOR_MASK_COLOR)

   918    {

   919       png_byte maxbits;

   920 

   921       maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :

   922                 png_ptr->usr_bit_depth);

   923       if (sbit->red == 0 || sbit->red > maxbits ||

   924           sbit->green == 0 || sbit->green > maxbits ||

   925           sbit->blue == 0 || sbit->blue > maxbits)

   926       {

   927          png_warning(png_ptr, "Invalid sBIT depth specified");

   928          return;

   929       }

   930       buf[0] = sbit->red;

   931       buf[1] = sbit->green;

   932       buf[2] = sbit->blue;

   933       size = 3;

   934    }

   935    else

   936    {

   937       if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

   938       {

   939          png_warning(png_ptr, "Invalid sBIT depth specified");

   940          return;

   941       }

   942       buf[0] = sbit->gray;

   943       size = 1;

   944    }

   945 

   946    if (color_type & PNG_COLOR_MASK_ALPHA)

   947    {

   948       if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

   949       {

   950          png_warning(png_ptr, "Invalid sBIT depth specified");

   951          return;

   952       }

   953       buf[size++] = sbit->alpha;

   954    }

   955 

   956    png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);

   957 }

   958 #endif

   959 

   960 #if defined(PNG_WRITE_cHRM_SUPPORTED)

   961 /* write the cHRM chunk */

   962 #ifdef PNG_FLOATING_POINT_SUPPORTED

   963 void /* PRIVATE */

   964 png_write_cHRM(png_structp png_ptr, double white_x, double white_y,

   965    double red_x, double red_y, double green_x, double green_y,

   966    double blue_x, double blue_y)

   967 {

   968 #ifdef PNG_USE_LOCAL_ARRAYS

   969    PNG_cHRM;

   970 #endif

   971    png_byte buf[32];

   972    png_uint_32 itemp;

   973 

   974    png_debug(1, "in png_write_cHRM\n");

   975    /* each value is saved in 1/100,000ths */

   976    if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||

   977        white_x + white_y > 1.0)

   978    {

   979       png_warning(png_ptr, "Invalid cHRM white point specified");

   980 #if !defined(PNG_NO_CONSOLE_IO)

   981       fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);

   982 #endif

   983       return;

   984    }

   985    itemp = (png_uint_32)(white_x * 100000.0 + 0.5);

   986    png_save_uint_32(buf, itemp);

   987    itemp = (png_uint_32)(white_y * 100000.0 + 0.5);

   988    png_save_uint_32(buf + 4, itemp);

   989 

   990    if (red_x < 0 ||  red_y < 0 || red_x + red_y > 1.0)

   991    {

   992       png_warning(png_ptr, "Invalid cHRM red point specified");

   993       return;

   994    }

   995    itemp = (png_uint_32)(red_x * 100000.0 + 0.5);

   996    png_save_uint_32(buf + 8, itemp);

   997    itemp = (png_uint_32)(red_y * 100000.0 + 0.5);

   998    png_save_uint_32(buf + 12, itemp);

   999 

  1000    if (green_x < 0 || green_y < 0 || green_x + green_y > 1.0)

  1001    {

  1002       png_warning(png_ptr, "Invalid cHRM green point specified");

  1003       return;

  1004    }

  1005    itemp = (png_uint_32)(green_x * 100000.0 + 0.5);

  1006    png_save_uint_32(buf + 16, itemp);

  1007    itemp = (png_uint_32)(green_y * 100000.0 + 0.5);

  1008    png_save_uint_32(buf + 20, itemp);

  1009 

  1010    if (blue_x < 0 || blue_y < 0 || blue_x + blue_y > 1.0)

  1011    {

  1012       png_warning(png_ptr, "Invalid cHRM blue point specified");

  1013       return;

  1014    }

  1015    itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);

  1016    png_save_uint_32(buf + 24, itemp);

  1017    itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);

  1018    png_save_uint_32(buf + 28, itemp);

  1019 

  1020    png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

  1021 }

  1022 #endif

  1023 #ifdef PNG_FIXED_POINT_SUPPORTED

  1024 void /* PRIVATE */

  1025 png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

  1026    png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

  1027    png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

  1028    png_fixed_point blue_y)

  1029 {

  1030 #ifdef PNG_USE_LOCAL_ARRAYS

  1031    PNG_cHRM;

  1032 #endif

  1033    png_byte buf[32];

  1034 

  1035    png_debug(1, "in png_write_cHRM\n");

  1036    /* each value is saved in 1/100,000ths */

  1037    if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)

  1038    {

  1039       png_warning(png_ptr, "Invalid fixed cHRM white point specified");

  1040 #if !defined(PNG_NO_CONSOLE_IO)

  1041       fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,

  1042         (unsigned long)white_y);

  1043 #endif

  1044       return;

  1045    }

  1046    png_save_uint_32(buf, (png_uint_32)white_x);

  1047    png_save_uint_32(buf + 4, (png_uint_32)white_y);

  1048 

  1049    if (red_x + red_y > 100000L)

  1050    {

  1051       png_warning(png_ptr, "Invalid cHRM fixed red point specified");

  1052       return;

  1053    }

  1054    png_save_uint_32(buf + 8, (png_uint_32)red_x);

  1055    png_save_uint_32(buf + 12, (png_uint_32)red_y);

  1056 

  1057    if (green_x + green_y > 100000L)

  1058    {

  1059       png_warning(png_ptr, "Invalid fixed cHRM green point specified");

  1060       return;

  1061    }

  1062    png_save_uint_32(buf + 16, (png_uint_32)green_x);

  1063    png_save_uint_32(buf + 20, (png_uint_32)green_y);

  1064 

  1065    if (blue_x + blue_y > 100000L)

  1066    {

  1067       png_warning(png_ptr, "Invalid fixed cHRM blue point specified");

  1068       return;

  1069    }

  1070    png_save_uint_32(buf + 24, (png_uint_32)blue_x);

  1071    png_save_uint_32(buf + 28, (png_uint_32)blue_y);

  1072 

  1073    png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

  1074 }

  1075 #endif

  1076 #endif

  1077 

  1078 #if defined(PNG_WRITE_tRNS_SUPPORTED)

  1079 /* write the tRNS chunk */

  1080 void /* PRIVATE */

  1081 png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,

  1082    int num_trans, int color_type)

  1083 {

  1084 #ifdef PNG_USE_LOCAL_ARRAYS

  1085    PNG_tRNS;

  1086 #endif

  1087    png_byte buf[6];

  1088 

  1089    png_debug(1, "in png_write_tRNS\n");

  1090    if (color_type == PNG_COLOR_TYPE_PALETTE)

  1091    {

  1092       if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

  1093       {

  1094          png_warning(png_ptr, "Invalid number of transparent colors specified");

  1095          return;

  1096       }

  1097       /* write the chunk out as it is */

  1098       png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,

  1099         (png_size_t)num_trans);

  1100    }

  1101    else if (color_type == PNG_COLOR_TYPE_GRAY)

  1102    {

  1103       /* one 16 bit value */

  1104       if (tran->gray >= (1 << png_ptr->bit_depth))

  1105       {

  1106          png_warning(png_ptr,

  1107            "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

  1108          return;

  1109       }

  1110       png_save_uint_16(buf, tran->gray);

  1111       png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);

  1112    }

  1113    else if (color_type == PNG_COLOR_TYPE_RGB)

  1114    {

  1115       /* three 16 bit values */

  1116       png_save_uint_16(buf, tran->red);

  1117       png_save_uint_16(buf + 2, tran->green);

  1118       png_save_uint_16(buf + 4, tran->blue);

  1119       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

  1120       {

  1121          png_warning(png_ptr,

  1122            "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");

  1123          return;

  1124       }

  1125       png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);

  1126    }

  1127    else

  1128    {

  1129       png_warning(png_ptr, "Can't write tRNS with an alpha channel");

  1130    }

  1131 }

  1132 #endif

  1133 

  1134 #if defined(PNG_WRITE_bKGD_SUPPORTED)

  1135 /* write the background chunk */