1 

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

     3  *

     4  * Last changed in libpng 1.2.40 [September 10, 2009]

     5  * Copyright (c) 1998-2009 Glenn Randers-Pehrson

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

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

     8  *

     9  * This code is released under the libpng license.

    10  * For conditions of distribution and use, see the disclaimer

    11  * and license in png.h

    12  */

    13 

    14 #define PNG_INTERNAL

    15 #include "png.h"

    16 #ifdef PNG_WRITE_SUPPORTED

    17 

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

    19  * with unsigned numbers for convenience, although one supported

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

    21  */

    22 void PNGAPI

    23 png_save_uint_32(png_bytep buf, png_uint_32 i)

    24 {

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

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

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

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

    29 }

    30 

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

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

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

    34  */

    35 void PNGAPI

    36 png_save_int_32(png_bytep buf, png_int_32 i)

    37 {

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

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

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

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

    42 }

    43 

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

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

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

    47  */

    48 void PNGAPI

    49 png_save_uint_16(png_bytep buf, unsigned int i)

    50 {

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

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

    53 }

    54 

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

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

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

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

    59  * bytes have already been written.

    60  */

    61 void /* PRIVATE */

    62 png_write_sig(png_structp png_ptr)

    63 {

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

    65 

    66    /* Write the rest of the 8 byte signature */

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

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

    69    if (png_ptr->sig_bytes < 3)

    70       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

    71 }

    72 

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

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

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

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

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

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

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

    80  * functions instead.

    81  */

    82 void PNGAPI

    83 png_write_chunk(png_structp png_ptr, png_bytep chunk_name,

    84    png_bytep data, png_size_t length)

    85 {

    86    if (png_ptr == NULL)

    87       return;

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

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

    90    png_write_chunk_end(png_ptr);

    91 }

    92 

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

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

    95  * passing in png_write_chunk_data().

    96  */

    97 void PNGAPI

    98 png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,

    99    png_uint_32 length)

   100 {

   101    png_byte buf[8];

   102 

   103    png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,

   104       (unsigned long)length);

   105 

   106    if (png_ptr == NULL)

   107       return;

   108 

   109    /* Write the length and the chunk name */

   110    png_save_uint_32(buf, length);

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

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

   113    /* Put the chunk name into png_ptr->chunk_name */

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

   115    /* Reset the crc and run it over the chunk name */

   116    png_reset_crc(png_ptr);

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

   118 }

   119 

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

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

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

   123  * given to png_write_chunk_start().

   124  */

   125 void PNGAPI

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

   127 {

   128    /* Write the data, and run the CRC over it */

   129    if (png_ptr == NULL)

   130       return;

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

   132    {

   133       png_write_data(png_ptr, data, length);

   134       /* Update the CRC after writing the data,

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

   136        */

   137       png_calculate_crc(png_ptr, data, length);

   138    }

   139 }

   140 

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

   142 void PNGAPI

   143 png_write_chunk_end(png_structp png_ptr)

   144 {

   145    png_byte buf[4];

   146 

   147    if (png_ptr == NULL) return;

   148 

   149    /* Write the crc in a single operation */

   150    png_save_uint_32(buf, png_ptr->crc);

   151 

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

   153 }

   154 

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

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

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

   158  * The compression_state structure is shared context for these functions

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

   160  */

   161 

   162 typedef struct

   163 {

   164    char *input;   /* The uncompressed input data */

   165    int input_len;   /* Its length */

   166    int num_output_ptr; /* Number of output pointers used */

   167    int max_output_ptr; /* Size of output_ptr */

   168    png_charpp output_ptr; /* Array of pointers to output */

   169 } compression_state;

   170 

   171 /* Compress given text into storage in the png_ptr structure */

   172 static int /* PRIVATE */

   173 png_text_compress(png_structp png_ptr,

   174         png_charp text, png_size_t text_len, int compression,

   175         compression_state *comp)

   176 {

   177    int ret;

   178 

   179    comp->num_output_ptr = 0;

   180    comp->max_output_ptr = 0;

   181    comp->output_ptr = NULL;

   182    comp->input = NULL;

   183    comp->input_len = 0;

   184 

   185    /* We may just want to pass the text right through */

   186    if (compression == PNG_TEXT_COMPRESSION_NONE)

   187    {

   188        comp->input = text;

   189        comp->input_len = text_len;

   190        return((int)text_len);

   191    }

   192 

   193    if (compression >= PNG_TEXT_COMPRESSION_LAST)

   194    {

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

   196       char msg[50];

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

   198       png_warning(png_ptr, msg);

   199 #else

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

   201 #endif

   202    }

   203 

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

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

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

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

   208     * malloc'd pointers to be sure.

   209     *

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

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

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

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

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

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

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

   217     */

   218 

   219    /* Set up the compression buffers */

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

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

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

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

   224 

   225    /* This is the same compression loop as in png_write_row() */

   226    do

   227    {

   228       /* Compress the data */

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

   230       if (ret != Z_OK)

   231       {

   232          /* Error */

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

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

   235          else

   236             png_error(png_ptr, "zlib error");

   237       }

   238       /* Check to see if we need more room */

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

   240       {

   241          /* Make sure the output array has room */

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

   243          {

   244             int old_max;

   245 

   246             old_max = comp->max_output_ptr;

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

   248             if (comp->output_ptr != NULL)

   249             {

   250                png_charpp old_ptr;

   251 

   252                old_ptr = comp->output_ptr;

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

   254                   (png_uint_32)

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

   256                png_memcpy(comp->output_ptr, old_ptr, old_max

   257                   * png_sizeof(png_charp));

   258                png_free(png_ptr, old_ptr);

   259             }

   260             else

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

   262                   (png_uint_32)

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

   264          }

   265 

   266          /* Save the data */

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

   268             (png_charp)png_malloc(png_ptr,

   269             (png_uint_32)png_ptr->zbuf_size);

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

   271             png_ptr->zbuf_size);

   272          comp->num_output_ptr++;

   273 

   274          /* and reset the buffer */

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

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

   277       }

   278    /* Continue until we don't have any more to compress */

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

   280 

   281    /* Finish the compression */

   282    do

   283    {

   284       /* Tell zlib we are finished */

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

   286 

   287       if (ret == Z_OK)

   288       {

   289          /* Check to see if we need more room */

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

   291          {

   292             /* Check to make sure our output array has room */

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

   294             {

   295                int old_max;

   296 

   297                old_max = comp->max_output_ptr;

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

   299                if (comp->output_ptr != NULL)

   300                {

   301                   png_charpp old_ptr;

   302 

   303                   old_ptr = comp->output_ptr;

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

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

   306                      (png_uint_32)(comp->max_output_ptr *

   307                      png_sizeof(png_charp)));

   308                   png_memcpy(comp->output_ptr, old_ptr,

   309                      old_max * png_sizeof(png_charp));

   310                   png_free(png_ptr, old_ptr);

   311                }

   312                else

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

   314                      (png_uint_32)(comp->max_output_ptr *

   315                      png_sizeof(png_charp)));

   316             }

   317 

   318             /* Save the data */

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

   320                (png_charp)png_malloc(png_ptr,

   321                (png_uint_32)png_ptr->zbuf_size);

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

   323                png_ptr->zbuf_size);

   324             comp->num_output_ptr++;

   325 

   326             /* and reset the buffer pointers */

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

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

   329          }

   330       }

   331       else if (ret != Z_STREAM_END)

   332       {

   333          /* We got an error */

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

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

   336          else

   337             png_error(png_ptr, "zlib error");

   338       }

   339    } while (ret != Z_STREAM_END);

   340 

   341    /* Text length is number of buffers plus last buffer */

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

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

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

   345 

   346    return((int)text_len);

   347 }

   348 

   349 /* Ship the compressed text out via chunk writes */

   350 static void /* PRIVATE */

   351 png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

   352 {

   353    int i;

   354 

   355    /* Handle the no-compression case */

   356    if (comp->input)

   357    {

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

   359                             (png_size_t)comp->input_len);

   360       return;

   361    }

   362 

   363    /* Write saved output buffers, if any */

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

   365    {

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

   367          (png_size_t)png_ptr->zbuf_size);

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

   369        comp->output_ptr[i]=NULL;

   370    }

   371    if (comp->max_output_ptr != 0)

   372       png_free(png_ptr, comp->output_ptr);

   373        comp->output_ptr=NULL;

   374    /* Write anything left in zbuf */

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

   376       png_write_chunk_data(png_ptr, png_ptr->zbuf,

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

   378 

   379    /* Reset zlib for another zTXt/iTXt or image data */

   380    deflateReset(&png_ptr->zstream);

   381    png_ptr->zstream.data_type = Z_BINARY;

   382 }

   383 #endif

   384 

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

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

   387  * information being correct.

   388  */

   389 void /* PRIVATE */

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

   391    int bit_depth, int color_type, int compression_type, int filter_type,

   392    int interlace_type)

   393 {

   394 #ifdef PNG_USE_LOCAL_ARRAYS

   395    PNG_IHDR;

   396 #endif

   397    int ret;

   398 

   399    png_byte buf[13]; /* Buffer to store the IHDR info */

   400 

   401    png_debug(1, "in png_write_IHDR");

   402 

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

   404    switch (color_type)

   405    {

   406       case PNG_COLOR_TYPE_GRAY:

   407          switch (bit_depth)

   408          {

   409             case 1:

   410             case 2:

   411             case 4:

   412             case 8:

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

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

   415          }

   416          break;

   417       case PNG_COLOR_TYPE_RGB:

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

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

   420          png_ptr->channels = 3;

   421          break;

   422       case PNG_COLOR_TYPE_PALETTE:

   423          switch (bit_depth)

   424          {

   425             case 1:

   426             case 2:

   427             case 4:

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

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

   430          }

   431          break;

   432       case PNG_COLOR_TYPE_GRAY_ALPHA:

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

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

   435          png_ptr->channels = 2;

   436          break;

   437       case PNG_COLOR_TYPE_RGB_ALPHA:

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

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

   440          png_ptr->channels = 4;

   441          break;

   442       default:

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

   444    }

   445 

   446    if (compression_type != PNG_COMPRESSION_TYPE_BASE)

   447    {

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

   449       compression_type = PNG_COMPRESSION_TYPE_BASE;

   450    }

   451 

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

   453     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

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

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

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

   457     *    included PNG_FLAG_MNG_FILTER_64 and

   458     * 4. The filter_method is 64 and

   459     * 5. The color_type is RGB or RGBA

   460     */

   461    if (

   462 #if defined(PNG_MNG_FEATURES_SUPPORTED)

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

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

   465       (color_type == PNG_COLOR_TYPE_RGB ||

   466        color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

   467       (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

   468 #endif

   469       filter_type != PNG_FILTER_TYPE_BASE)

   470    {

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

   472       filter_type = PNG_FILTER_TYPE_BASE;

   473    }

   474 

   475 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   476    if (interlace_type != PNG_INTERLACE_NONE &&

   477       interlace_type != PNG_INTERLACE_ADAM7)

   478    {

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

   480       interlace_type = PNG_INTERLACE_ADAM7;

   481    }

   482 #else

   483    interlace_type=PNG_INTERLACE_NONE;

   484 #endif

   485 

   486    /* Save the relevent information */

   487    png_ptr->bit_depth = (png_byte)bit_depth;

   488    png_ptr->color_type = (png_byte)color_type;

   489    png_ptr->interlaced = (png_byte)interlace_type;

   490 #if defined(PNG_MNG_FEATURES_SUPPORTED)

   491    png_ptr->filter_type = (png_byte)filter_type;

   492 #endif

   493    png_ptr->compression_type = (png_byte)compression_type;

   494    png_ptr->width = width;

   495    png_ptr->height = height;

   496 

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

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

   499    /* Set the usr info, so any transformations can modify it */

   500    png_ptr->usr_width = png_ptr->width;

   501    png_ptr->usr_bit_depth = png_ptr->bit_depth;

   502    png_ptr->usr_channels = png_ptr->channels;

   503 

   504    /* Pack the header information into the buffer */

   505    png_save_uint_32(buf, width);

   506    png_save_uint_32(buf + 4, height);

   507    buf[8] = (png_byte)bit_depth;

   508    buf[9] = (png_byte)color_type;

   509    buf[10] = (png_byte)compression_type;

   510    buf[11] = (png_byte)filter_type;

   511    buf[12] = (png_byte)interlace_type;

   512 

   513    /* Write the chunk */

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

   515 

   516    /* Initialize zlib with PNG info */

   517    png_ptr->zstream.zalloc = png_zalloc;

   518    png_ptr->zstream.zfree = png_zfree;

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

   520    if (!(png_ptr->do_filter))

   521    {

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

   523          png_ptr->bit_depth < 8)

   524          png_ptr->do_filter = PNG_FILTER_NONE;

   525       else

   526          png_ptr->do_filter = PNG_ALL_FILTERS;

   527    }

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

   529    {

   530       if (png_ptr->do_filter != PNG_FILTER_NONE)

   531          png_ptr->zlib_strategy = Z_FILTERED;

   532       else

   533          png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

   534    }

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

   536       png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

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

   538       png_ptr->zlib_mem_level = 8;

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

   540       png_ptr->zlib_window_bits = 15;

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

   542       png_ptr->zlib_method = 8;

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

   544          png_ptr->zlib_method, png_ptr->zlib_window_bits,

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

   546    if (ret != Z_OK)

   547    {

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

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

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

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

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

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

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

   555    }

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

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

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

   559    /* Set it to a predefined value, to avoid its evaluation inside zlib */

   560    png_ptr->zstream.data_type = Z_BINARY;

   561 

   562    png_ptr->mode = PNG_HAVE_IHDR;

   563 }

   564 

   565 /* Write the palette.  We are careful not to trust png_color to be in the

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

   567  * structure.

   568  */

   569 void /* PRIVATE */

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

   571 {

   572 #ifdef PNG_USE_LOCAL_ARRAYS

   573    PNG_PLTE;

   574 #endif

   575    png_uint_32 i;

   576    png_colorp pal_ptr;

   577    png_byte buf[3];

   578 

   579    png_debug(1, "in png_write_PLTE");

   580 

   581    if ((

   582 #if defined(PNG_MNG_FEATURES_SUPPORTED)

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

   584 #endif

   585         num_pal == 0) || num_pal > 256)

   586    {

   587      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

   588      {

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

   590      }

   591      else

   592      {

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

   594         return;

   595      }

   596    }

   597 

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

   599    {

   600       png_warning(png_ptr,

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

   602       return;

   603    }

   604 

   605    png_ptr->num_palette = (png_uint_16)num_pal;

   606    png_debug1(3, "num_palette = %d", png_ptr->num_palette);

   607 

   608    png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,

   609      (png_uint_32)(num_pal * 3));

   610 #ifndef PNG_NO_POINTER_INDEXING

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

   612    {

   613       buf[0] = pal_ptr->red;

   614       buf[1] = pal_ptr->green;

   615       buf[2] = pal_ptr->blue;

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

   617    }

   618 #else

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

   620    pal_ptr=palette;

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

   622    {

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

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

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

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

   627    }

   628 #endif

   629    png_write_chunk_end(png_ptr);

   630    png_ptr->mode |= PNG_HAVE_PLTE;

   631 }

   632 

   633 /* Write an IDAT chunk */

   634 void /* PRIVATE */

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

   636 {

   637 #ifdef PNG_USE_LOCAL_ARRAYS

   638    PNG_IDAT;

   639 #endif

   640 

   641    png_debug(1, "in png_write_IDAT");

   642 

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

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

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

   646        png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

   647    {

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

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

   650       {

   651          /* Avoid memory underflows and multiplication overflows.

   652           *

   653           * The conditions below are practically always satisfied;

   654           * however, they still must be checked.

   655           */

   656          if (length >= 2 &&

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

   658          {

   659             png_uint_32 uncompressed_idat_size = png_ptr->height *

   660                ((png_ptr->width *

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

   662             unsigned int z_cinfo = z_cmf >> 4;

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

   664             while (uncompressed_idat_size <= half_z_window_size &&

   665                    half_z_window_size >= 256)

   666             {

   667                z_cinfo--;

   668                half_z_window_size >>= 1;

   669             }

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

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

   672             {

   673                data[0] = (png_byte)z_cmf;

   674                data[1] &= 0xe0;

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

   676             }

   677          }

   678       }

   679       else

   680          png_error(png_ptr,

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

   682    }

   683 

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

   685    png_ptr->mode |= PNG_HAVE_IDAT;

   686 }

   687 

   688 /* Write an IEND chunk */

   689 void /* PRIVATE */

   690 png_write_IEND(png_structp png_ptr)

   691 {

   692 #ifdef PNG_USE_LOCAL_ARRAYS

   693    PNG_IEND;

   694 #endif

   695 

   696    png_debug(1, "in png_write_IEND");

   697 

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

   699      (png_size_t)0);

   700    png_ptr->mode |= PNG_HAVE_IEND;

   701 }

   702 

   703 #if defined(PNG_WRITE_gAMA_SUPPORTED)

   704 /* Write a gAMA chunk */

   705 #ifdef PNG_FLOATING_POINT_SUPPORTED

   706 void /* PRIVATE */

   707 png_write_gAMA(png_structp png_ptr, double file_gamma)

   708 {

   709 #ifdef PNG_USE_LOCAL_ARRAYS

   710    PNG_gAMA;

   711 #endif

   712    png_uint_32 igamma;

   713    png_byte buf[4];

   714 

   715    png_debug(1, "in png_write_gAMA");

   716 

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

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

   719    png_save_uint_32(buf, igamma);

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

   721 }

   722 #endif

   723 #ifdef PNG_FIXED_POINT_SUPPORTED

   724 void /* PRIVATE */

   725 png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

   726 {

   727 #ifdef PNG_USE_LOCAL_ARRAYS

   728    PNG_gAMA;

   729 #endif

   730    png_byte buf[4];

   731 

   732    png_debug(1, "in png_write_gAMA");

   733 

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

   735    png_save_uint_32(buf, (png_uint_32)file_gamma);

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

   737 }

   738 #endif

   739 #endif

   740 

   741 #if defined(PNG_WRITE_sRGB_SUPPORTED)

   742 /* Write a sRGB chunk */

   743 void /* PRIVATE */

   744 png_write_sRGB(png_structp png_ptr, int srgb_intent)

   745 {

   746 #ifdef PNG_USE_LOCAL_ARRAYS

   747    PNG_sRGB;

   748 #endif

   749    png_byte buf[1];

   750 

   751    png_debug(1, "in png_write_sRGB");

   752 

   753    if (srgb_intent >= PNG_sRGB_INTENT_LAST)

   754          png_warning(png_ptr,

   755             "Invalid sRGB rendering intent specified");

   756    buf[0]=(png_byte)srgb_intent;

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

   758 }

   759 #endif

   760 

   761 #if defined(PNG_WRITE_iCCP_SUPPORTED)

   762 /* Write an iCCP chunk */

   763 void /* PRIVATE */

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

   765    png_charp profile, int profile_len)

   766 {

   767 #ifdef PNG_USE_LOCAL_ARRAYS

   768    PNG_iCCP;

   769 #endif

   770    png_size_t name_len;

   771    png_charp new_name;

   772    compression_state comp;

   773    int embedded_profile_len = 0;

   774 

   775    png_debug(1, "in png_write_iCCP");

   776 

   777    comp.num_output_ptr = 0;

   778    comp.max_output_ptr = 0;

   779    comp.output_ptr = NULL;

   780    comp.input = NULL;

   781    comp.input_len = 0;

   782 

   783    if ((name_len = png_check_keyword(png_ptr, name,

   784       &new_name)) == 0)

   785       return;

   786 

   787    if (compression_type != PNG_COMPRESSION_TYPE_BASE)

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

   789 

   790    if (profile == NULL)

   791       profile_len = 0;

   792 

   793    if (profile_len > 3)

   794       embedded_profile_len =

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

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

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

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

   799 

   800    if (embedded_profile_len < 0)

   801    {

   802       png_warning(png_ptr,

   803         "Embedded profile length in iCCP chunk is negative");

   804       png_free(png_ptr, new_name);

   805       return;

   806    }

   807 

   808    if (profile_len < embedded_profile_len)

   809    {

   810       png_warning(png_ptr,

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

   812       png_free(png_ptr, new_name);

   813       return;

   814    }

   815 

   816    if (profile_len > embedded_profile_len)

   817    {

   818       png_warning(png_ptr,

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

   820       profile_len = embedded_profile_len;

   821    }

   822 

   823    if (profile_len)

   824       profile_len = png_text_compress(png_ptr, profile,

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

   826 

   827    /* Make sure we include the NULL after the name and the compression type */

   828    png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

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

   830    new_name[name_len + 1] = 0x00;

   831    png_write_chunk_data(png_ptr, (png_bytep)new_name,

   832      (png_size_t)(name_len + 2));

   833 

   834    if (profile_len)

   835       png_write_compressed_data_out(png_ptr, &comp);

   836 

   837    png_write_chunk_end(png_ptr);

   838    png_free(png_ptr, new_name);

   839 }

   840 #endif

   841 

   842 #if defined(PNG_WRITE_sPLT_SUPPORTED)

   843 /* Write a sPLT chunk */

   844 void /* PRIVATE */

   845 png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)

   846 {

   847 #ifdef PNG_USE_LOCAL_ARRAYS

   848    PNG_sPLT;

   849 #endif

   850    png_size_t name_len;

   851    png_charp new_name;

   852    png_byte entrybuf[10];

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

   854    int palette_size = entry_size * spalette->nentries;

   855    png_sPLT_entryp ep;

   856 #ifdef PNG_NO_POINTER_INDEXING

   857    int i;

   858 #endif

   859 

   860    png_debug(1, "in png_write_sPLT");

   861 

   862    if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0)

   863       return;

   864 

   865    /* Make sure we include the NULL after the name */

   866    png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,

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

   868    png_write_chunk_data(png_ptr, (png_bytep)new_name,

   869      (png_size_t)(name_len + 1));

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

   871 

   872    /* Loop through each palette entry, writing appropriately */

   873 #ifndef PNG_NO_POINTER_INDEXING

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

   875    {

   876       if (spalette->depth == 8)

   877       {

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

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

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

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

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

   883       }

   884       else

   885       {

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

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

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

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

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

   891       }

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

   893    }

   894 #else

   895    ep=spalette->entries;

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

   897    {

   898       if (spalette->depth == 8)

   899       {

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

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

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

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

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

   905       }

   906       else

   907       {

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

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

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

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

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

   913       }

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

   915    }

   916 #endif

   917 

   918    png_write_chunk_end(png_ptr);

   919    png_free(png_ptr, new_name);

   920 }

   921 #endif

   922 

   923 #if defined(PNG_WRITE_sBIT_SUPPORTED)

   924 /* Write the sBIT chunk */

   925 void /* PRIVATE */

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

   927 {

   928 #ifdef PNG_USE_LOCAL_ARRAYS

   929    PNG_sBIT;

   930 #endif

   931    png_byte buf[4];

   932    png_size_t size;

   933 

   934    png_debug(1, "in png_write_sBIT");

   935 

   936    /* Make sure we don't depend upon the order of PNG_COLOR_8 */

   937    if (color_type & PNG_COLOR_MASK_COLOR)

   938    {

   939       png_byte maxbits;

   940 

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

   942                 png_ptr->usr_bit_depth);

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

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

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

   946       {

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

   948          return;

   949       }

   950       buf[0] = sbit->red;

   951       buf[1] = sbit->green;

   952       buf[2] = sbit->blue;

   953       size = 3;

   954    }

   955    else

   956    {

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

   958       {

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

   960          return;

   961       }

   962       buf[0] = sbit->gray;

   963       size = 1;

   964    }

   965 

   966    if (color_type & PNG_COLOR_MASK_ALPHA)

   967    {

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

   969       {

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

   971          return;

   972       }

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

   974    }

   975 

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

   977 }

   978 #endif

   979 

   980 #if defined(PNG_WRITE_cHRM_SUPPORTED)

   981 /* Write the cHRM chunk */

   982 #ifdef PNG_FLOATING_POINT_SUPPORTED

   983 void /* PRIVATE */

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

   985    double red_x, double red_y, double green_x, double green_y,

   986    double blue_x, double blue_y)

   987 {

   988 #ifdef PNG_USE_LOCAL_ARRAYS

   989    PNG_cHRM;

   990 #endif

   991    png_byte buf[32];

   992 

   993    png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y,

   994       int_green_x, int_green_y, int_blue_x, int_blue_y;

   995 

   996    png_debug(1, "in png_write_cHRM");

   997 

   998    int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);

   999    int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);

  1000    int_red_x   = (png_uint_32)(red_x   * 100000.0 + 0.5);

  1001    int_red_y   = (png_uint_32)(red_y   * 100000.0 + 0.5);

  1002    int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);

  1003    int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);

  1004    int_blue_x  = (png_uint_32)(blue_x  * 100000.0 + 0.5);

  1005    int_blue_y  = (png_uint_32)(blue_y  * 100000.0 + 0.5);

  1006 

  1007 #if !defined(PNG_NO_CHECK_cHRM)

  1008    if (png_check_cHRM_fixed(png_ptr, int_white_x, int_white_y,

  1009       int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))

  1010 #endif

  1011    {

  1012       /* Each value is saved in 1/100,000ths */

  1013 

  1014       png_save_uint_32(buf, int_white_x);

  1015       png_save_uint_32(buf + 4, int_white_y);

  1016 

  1017       png_save_uint_32(buf + 8, int_red_x);

  1018       png_save_uint_32(buf + 12, int_red_y);

  1019 

  1020       png_save_uint_32(buf + 16, int_green_x);

  1021       png_save_uint_32(buf + 20, int_green_y);

  1022 

  1023       png_save_uint_32(buf + 24, int_blue_x);

  1024       png_save_uint_32(buf + 28, int_blue_y);

  1025 

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

  1027    }

  1028 }

  1029 #endif

  1030 #ifdef PNG_FIXED_POINT_SUPPORTED

  1031 void /* PRIVATE */

  1032 png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

  1033    png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

  1034    png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

  1035    png_fixed_point blue_y)

  1036 {

  1037 #ifdef PNG_USE_LOCAL_ARRAYS

  1038    PNG_cHRM;

  1039 #endif

  1040    png_byte buf[32];

  1041 

  1042    png_debug(1, "in png_write_cHRM");

  1043 

  1044    /* Each value is saved in 1/100,000ths */

  1045 #if !defined(PNG_NO_CHECK_cHRM)

  1046    if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,

  1047       green_x, green_y, blue_x, blue_y))

  1048 #endif

  1049    {

  1050       png_save_uint_32(buf, (png_uint_32)white_x);

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

  1052 

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

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

  1055 

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

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

  1058 

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

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

  1061 

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

  1063    }

  1064 }

  1065 #endif

  1066 #endif

  1067 

  1068 #if defined(PNG_WRITE_tRNS_SUPPORTED)

  1069 /* Write the tRNS chunk */

  1070 void /* PRIVATE */

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

  1072    int num_trans, int color_type)

  1073 {

  1074 #ifdef PNG_USE_LOCAL_ARRAYS

  1075    PNG_tRNS;

  1076 #endif

  1077    png_byte buf[6];

  1078 

  1079    png_debug(1, "in png_write_tRNS");

  1080 

  1081    if (color_type == PNG_COLOR_TYPE_PALETTE)

  1082    {

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

  1084       {

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

  1086          return;

  1087       }

  1088       /* Write the chunk out as it is */

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

  1090         (png_size_t)num_trans);

  1091    }

  1092    else if (color_type == PNG_COLOR_TYPE_GRAY)

  1093    {

  1094       /* One 16 bit value */

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

  1096       {

  1097          png_warning(png_ptr,

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

  1099          return;

  1100       }

  1101       png_save_uint_16(buf, tran->gray);

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

  1103    }

  1104    else if (color_type == PNG_COLOR_TYPE_RGB)

  1105    {

  1106       /* Three 16 bit values */

  1107       png_save_uint_16(buf, tran->red);

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

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

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

  1111       {

  1112          png_warning(png_ptr,

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

  1114          return;

  1115       }

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

  1117    }

  1118    else

  1119    {

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

  1121    }

  1122 }

  1123 #endif

  1124 

  1125 #if defined(PNG_WRITE_bKGD_SUPPORTED)

  1126 /* Write the background chunk */

  1127 void /* PRIVATE */

  1128 png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)

  1129 {

  1130 #ifdef PNG_USE_LOCAL_ARRAYS

  1131    PNG_bKGD;

  1132 #endif

  1133    png_byte buf[6];

  1134