home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / libpng / pngwutil.c < prev   
C/C++ Source or Header  |  2001-04-27  |  83KB  |  2,638 lines
  1.  
  2. /* pngwutil.c - utilities to write a PNG file
  3.  *
  4.  * libpng 1.0.11 - April 27, 2001
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2001 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 /* PRIVATE */
  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. #if defined(PNG_WRITE_pCAL_SUPPORTED)
  29. /* The png_save_int_32 function assumes integers are stored in two's
  30.  * complement format.  If this isn't the case, then this routine needs to
  31.  * be modified to write data in two's complement format.
  32.  */
  33. void /* PRIVATE */
  34. png_save_int_32(png_bytep buf, png_int_32 i)
  35. {
  36.    buf[0] = (png_byte)((i >> 24) & 0xff);
  37.    buf[1] = (png_byte)((i >> 16) & 0xff);
  38.    buf[2] = (png_byte)((i >> 8) & 0xff);
  39.    buf[3] = (png_byte)(i & 0xff);
  40. }
  41. #endif
  42.  
  43. /* Place a 16-bit number into a buffer in PNG byte order.
  44.  * The parameter is declared unsigned int, not png_uint_16,
  45.  * just to avoid potential problems on pre-ANSI C compilers.
  46.  */
  47. void /* PRIVATE */
  48. png_save_uint_16(png_bytep buf, unsigned int i)
  49. {
  50.    buf[0] = (png_byte)((i >> 8) & 0xff);
  51.    buf[1] = (png_byte)(i & 0xff);
  52. }
  53.  
  54. /* Write a PNG chunk all at once.  The type is an array of ASCII characters
  55.  * representing the chunk name.  The array must be at least 4 bytes in
  56.  * length, and does not need to be null terminated.  To be safe, pass the
  57.  * pre-defined chunk names here, and if you need a new one, define it
  58.  * where the others are defined.  The length is the length of the data.
  59.  * All the data must be present.  If that is not possible, use the
  60.  * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
  61.  * functions instead.
  62.  */
  63. void PNGAPI
  64. png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
  65.    png_bytep data, png_size_t length)
  66. {
  67.    png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
  68.    png_write_chunk_data(png_ptr, data, length);
  69.    png_write_chunk_end(png_ptr);
  70. }
  71.  
  72. /* Write the start of a PNG chunk.  The type is the chunk type.
  73.  * The total_length is the sum of the lengths of all the data you will be
  74.  * passing in png_write_chunk_data().
  75.  */
  76. void PNGAPI
  77. png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
  78.    png_uint_32 length)
  79. {
  80.    png_byte buf[4];
  81.    png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length);
  82.  
  83.    /* write the length */
  84.    png_save_uint_32(buf, length);
  85.    png_write_data(png_ptr, buf, (png_size_t)4);
  86.  
  87.    /* write the chunk name */
  88.    png_write_data(png_ptr, chunk_name, (png_size_t)4);
  89.    /* reset the crc and run it over the chunk name */
  90.    png_reset_crc(png_ptr);
  91.    png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);
  92. }
  93.  
  94. /* Write the data of a PNG chunk started with png_write_chunk_start().
  95.  * Note that multiple calls to this function are allowed, and that the
  96.  * sum of the lengths from these calls *must* add up to the total_length
  97.  * given to png_write_chunk_start().
  98.  */
  99. void PNGAPI
  100. png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
  101. {
  102.    /* write the data, and run the CRC over it */
  103.    if (data != NULL && length > 0)
  104.    {
  105.       png_calculate_crc(png_ptr, data, length);
  106.       png_write_data(png_ptr, data, length);
  107.    }
  108. }
  109.  
  110. /* Finish a chunk started with png_write_chunk_start(). */
  111. void PNGAPI
  112. png_write_chunk_end(png_structp png_ptr)
  113. {
  114.    png_byte buf[4];
  115.  
  116.    /* write the crc */
  117.    png_save_uint_32(buf, png_ptr->crc);
  118.  
  119.    png_write_data(png_ptr, buf, (png_size_t)4);
  120. }
  121.  
  122. /* Simple function to write the signature.  If we have already written
  123.  * the magic bytes of the signature, or more likely, the PNG stream is
  124.  * being embedded into another stream and doesn't need its own signature,
  125.  * we should call png_set_sig_bytes() to tell libpng how many of the
  126.  * bytes have already been written.
  127.  */
  128. void /* PRIVATE */
  129. png_write_sig(png_structp png_ptr)
  130. {
  131.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  132.    /* write the rest of the 8 byte signature */
  133.    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
  134.       (png_size_t)8 - png_ptr->sig_bytes);
  135.    if(png_ptr->sig_bytes < 3)
  136.       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
  137. }
  138.  
  139. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
  140. /*
  141.  * This pair of functions encapsulates the operation of (a) compressing a
  142.  * text string, and (b) issuing it later as a series of chunk data writes.
  143.  * The compression_state structure is shared context for these functions
  144.  * set up by the caller in order to make the whole mess thread-safe.
  145.  */
  146.  
  147. typedef struct
  148. {
  149.     char *input;   /* the uncompressed input data */
  150.     int input_len;   /* its length */
  151.     int num_output_ptr; /* number of output pointers used */
  152.     int max_output_ptr; /* size of output_ptr */
  153.     png_charpp output_ptr; /* array of pointers to output */
  154. } compression_state;
  155.  
  156. /* compress given text into storage in the png_ptr structure */
  157. static int /* PRIVATE */
  158. png_text_compress(png_structp png_ptr,
  159.         png_charp text, png_size_t text_len, int compression,
  160.         compression_state *comp)
  161. {
  162.    int ret;
  163.  
  164.    comp->num_output_ptr = comp->max_output_ptr = 0;
  165.    comp->output_ptr = NULL;
  166.    comp->input = NULL;
  167.  
  168.    /* we may just want to pass the text right through */
  169.    if (compression == PNG_TEXT_COMPRESSION_NONE)
  170.    {
  171.        comp->input = text;
  172.        comp->input_len = text_len;
  173.        return((int)text_len);
  174.    }
  175.  
  176.    if (compression >= PNG_TEXT_COMPRESSION_LAST)
  177.    {
  178. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  179.       char msg[50];
  180.       sprintf(msg, "Unknown compression type %d", compression);
  181.       png_warning(png_ptr, msg);
  182. #else
  183.       png_warning(png_ptr, "Unknown compression type");
  184. #endif
  185.    }
  186.  
  187.    /* We can't write the chunk until we find out how much data we have,
  188.     * which means we need to run the compressor first and save the
  189.     * output.  This shouldn't be a problem, as the vast majority of
  190.     * comments should be reasonable, but we will set up an array of
  191.     * malloc'd pointers to be sure.
  192.     *
  193.     * If we knew the application was well behaved, we could simplify this
  194.     * greatly by assuming we can always malloc an output buffer large
  195.     * enough to hold the compressed text ((1001 * text_len / 1000) + 12)
  196.     * and malloc this directly.  The only time this would be a bad idea is
  197.     * if we can't malloc more than 64K and we have 64K of random input
  198.     * data, or if the input string is incredibly large (although this
  199.     * wouldn't cause a failure, just a slowdown due to swapping).
  200.     */
  201.  
  202.    /* set up the compression buffers */
  203.    png_ptr->zstream.avail_in = (uInt)text_len;
  204.    png_ptr->zstream.next_in = (Bytef *)text;
  205.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  206.    png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;
  207.  
  208.    /* this is the same compression loop as in png_write_row() */
  209.    do
  210.    {
  211.       /* compress the data */
  212.       ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
  213.       if (ret != Z_OK)
  214.       {
  215.          /* error */
  216.          if (png_ptr->zstream.msg != NULL)
  217.             png_error(png_ptr, png_ptr->zstream.msg);
  218.          else
  219.             png_error(png_ptr, "zlib error");
  220.       }
  221.       /* check to see if we need more room */
  222.       if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in)
  223.       {
  224.          /* make sure the output array has room */
  225.          if (comp->num_output_ptr >= comp->max_output_ptr)
  226.          {
  227.             int old_max;
  228.  
  229.             old_max = comp->max_output_ptr;
  230.             comp->max_output_ptr = comp->num_output_ptr + 4;
  231.             if (comp->output_ptr != NULL)
  232.             {
  233.                png_charpp old_ptr;
  234.  
  235.                old_ptr = comp->output_ptr;
  236.                comp->output_ptr = (png_charpp)png_malloc(png_ptr,
  237.                   (png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
  238.                png_memcpy(comp->output_ptr, old_ptr, old_max
  239.                   * sizeof (png_charp));
  240.                png_free(png_ptr, old_ptr);
  241.             }
  242.             else
  243.                comp->output_ptr = (png_charpp)png_malloc(png_ptr,
  244.                   (png_uint_32)(comp->max_output_ptr * sizeof (png_charp)));
  245.          }
  246.  
  247.          /* save the data */
  248.          comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr,
  249.             (png_uint_32)png_ptr->zbuf_size);
  250.          png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
  251.             png_ptr->zbuf_size);
  252.          comp->num_output_ptr++;
  253.  
  254.          /* and reset the buffer */
  255.          png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  256.          png_ptr->zstream.next_out = png_ptr->zbuf;
  257.       }
  258.    /* continue until we don't have any more to compress */
  259.    } while (png_ptr->zstream.avail_in);
  260.  
  261.    /* finish the compression */
  262.    do
  263.    {
  264.       /* tell zlib we are finished */
  265.       ret = deflate(&png_ptr->zstream, Z_FINISH);
  266.  
  267.       if (ret == Z_OK)
  268.       {
  269.          /* check to see if we need more room */
  270.          if (!(png_ptr->zstream.avail_out))
  271.          {
  272.             /* check to make sure our output array has room */
  273.             if (comp->num_output_ptr >= comp->max_output_ptr)
  274.             {
  275.                int old_max;
  276.  
  277.                old_max = comp->max_output_ptr;
  278.                comp->max_output_ptr = comp->num_output_ptr + 4;
  279.                if (comp->output_ptr != NULL)
  280.                {
  281.                   png_charpp old_ptr;
  282.  
  283.                   old_ptr = comp->output_ptr;
  284.                   /* This could be optimized to realloc() */
  285.                   comp->output_ptr = (png_charpp)png_malloc(png_ptr,
  286.                      (png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
  287.                   png_memcpy(comp->output_ptr, old_ptr,
  288.                        old_max * sizeof (png_charp));
  289.                   png_free(png_ptr, old_ptr);
  290.                }
  291.                else
  292.                   comp->output_ptr = (png_charpp)png_malloc(png_ptr,
  293.                      (png_uint_32)(comp->max_output_ptr * sizeof (png_charp)));
  294.             }
  295.  
  296.             /* save off the data */
  297.             comp->output_ptr[comp->num_output_ptr] =
  298.                (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size);
  299.             png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
  300.                png_ptr->zbuf_size);
  301.             comp->num_output_ptr++;
  302.  
  303.             /* and reset the buffer pointers */
  304.             png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  305.             png_ptr->zstream.next_out = png_ptr->zbuf;
  306.          }
  307.       }
  308.       else if (ret != Z_STREAM_END)
  309.       {
  310.          /* we got an error */
  311.          if (png_ptr->zstream.msg != NULL)
  312.             png_error(png_ptr, png_ptr->zstream.msg);
  313.          else
  314.             png_error(png_ptr, "zlib error");
  315.       }
  316.    } while (ret != Z_STREAM_END);
  317.  
  318.    /* text length is number of buffers plus last buffer */
  319.    text_len = png_ptr->zbuf_size * comp->num_output_ptr;
  320.    if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
  321.       text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;
  322.  
  323.    return((int)text_len);
  324. }
  325.  
  326. /* ship the compressed text out via chunk writes */
  327. static void /* PRIVATE */
  328. png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
  329. {
  330.    int i;
  331.  
  332.    /* handle the no-compression case */
  333.    if (comp->input)
  334.    {
  335.        png_write_chunk_data(png_ptr, (png_bytep)comp->input, comp->input_len);
  336.        return;
  337.    }
  338.  
  339.    /* write saved output buffers, if any */
  340.    for (i = 0; i < comp->num_output_ptr; i++)
  341.    {
  342.       png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i],
  343.          png_ptr->zbuf_size);
  344.       png_free(png_ptr, comp->output_ptr[i]);
  345.       comp->output_ptr[i]=NULL;
  346.    }
  347.    if (comp->max_output_ptr != 0)
  348.       png_free(png_ptr, comp->output_ptr);
  349.       comp->output_ptr=NULL;
  350.    /* write anything left in zbuf */
  351.    if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
  352.       png_write_chunk_data(png_ptr, png_ptr->zbuf,
  353.          png_ptr->zbuf_size - png_ptr->zstream.avail_out);
  354.  
  355.    /* reset zlib for another zTXt/iTXt or the image data */
  356.    deflateReset(&png_ptr->zstream);
  357.  
  358. }
  359. #endif
  360.  
  361. /* Write the IHDR chunk, and update the png_struct with the necessary
  362.  * information.  Note that the rest of this code depends upon this
  363.  * information being correct.
  364.  */
  365. void /* PRIVATE */
  366. png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
  367.    int bit_depth, int color_type, int compression_type, int filter_type,
  368.    int interlace_type)
  369. {
  370. #ifdef PNG_USE_LOCAL_ARRAYS
  371.    PNG_IHDR;
  372. #endif
  373.    png_byte buf[13]; /* buffer to store the IHDR info */
  374.  
  375.    png_debug(1, "in png_write_IHDR\n");
  376.    /* Check that we have valid input data from the application info */
  377.    switch (color_type)
  378.    {
  379.       case PNG_COLOR_TYPE_GRAY:
  380.          switch (bit_depth)
  381.          {
  382.             case 1:
  383.             case 2:
  384.             case 4:
  385.             case 8:
  386.             case 16: png_ptr->channels = 1; break;
  387.             default: png_error(png_ptr,"Invalid bit depth for grayscale image");
  388.          }
  389.          break;
  390.       case PNG_COLOR_TYPE_RGB:
  391.          if (bit_depth != 8 && bit_depth != 16)
  392.             png_error(png_ptr, "Invalid bit depth for RGB image");
  393.          png_ptr->channels = 3;
  394.          break;
  395.       case PNG_COLOR_TYPE_PALETTE:
  396.          switch (bit_depth)
  397.          {
  398.             case 1:
  399.             case 2:
  400.             case 4:
  401.             case 8: png_ptr->channels = 1; break;
  402.             default: png_error(png_ptr, "Invalid bit depth for paletted image");
  403.          }
  404.          break;
  405.       case PNG_COLOR_TYPE_GRAY_ALPHA:
  406.          if (bit_depth != 8 && bit_depth != 16)
  407.             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
  408.          png_ptr->channels = 2;
  409.          break;
  410.       case PNG_COLOR_TYPE_RGB_ALPHA:
  411.          if (bit_depth != 8 && bit_depth != 16)
  412.             png_error(png_ptr, "Invalid bit depth for RGBA image");
  413.          png_ptr->channels = 4;
  414.          break;
  415.       default:
  416.          png_error(png_ptr, "Invalid image color type specified");
  417.    }
  418.  
  419.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  420.    {
  421.       png_warning(png_ptr, "Invalid compression type specified");
  422.       compression_type = PNG_COMPRESSION_TYPE_BASE;
  423.    }
  424.  
  425.    /* Write filter_method 64 (intrapixel differencing) only if
  426.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  427.     * 2. Libpng did not write a PNG signature (this filter_method is only
  428.     *    used in PNG datastreams that are embedded in MNG datastreams) and
  429.     * 3. The application called png_permit_mng_features with a mask that
  430.     *    included PNG_FLAG_MNG_FILTER_64 and
  431.     * 4. The filter_method is 64 and
  432.     * 5. The color_type is RGB or RGBA
  433.     */
  434.    if (
  435. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  436.       !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  437.       ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
  438.       (color_type == PNG_COLOR_TYPE_RGB || 
  439.        color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
  440.       (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
  441. #endif
  442.       filter_type != PNG_FILTER_TYPE_BASE)
  443.    {
  444.       png_warning(png_ptr, "Invalid filter type specified");
  445.       filter_type = PNG_FILTER_TYPE_BASE;
  446.    }
  447.  
  448. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  449.    if (interlace_type != PNG_INTERLACE_NONE &&
  450.       interlace_type != PNG_INTERLACE_ADAM7)
  451.    {
  452.       png_warning(png_ptr, "Invalid interlace type specified");
  453.       interlace_type = PNG_INTERLACE_ADAM7;
  454.    }
  455. #else
  456.    interlace_type=PNG_INTERLACE_NONE;
  457. #endif
  458.  
  459.    /* save off the relevent information */
  460.    png_ptr->bit_depth = (png_byte)bit_depth;
  461.    png_ptr->color_type = (png_byte)color_type;
  462.    png_ptr->interlaced = (png_byte)interlace_type;
  463.    png_ptr->filter_type = (png_byte)filter_type;
  464.    png_ptr->width = width;
  465.    png_ptr->height = height;
  466.  
  467.    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
  468.    png_ptr->rowbytes = ((width * (png_size_t)png_ptr->pixel_depth + 7) >> 3);
  469.    /* set the usr info, so any transformations can modify it */
  470.    png_ptr->usr_width = png_ptr->width;
  471.    png_ptr->usr_bit_depth = png_ptr->bit_depth;
  472.    png_ptr->usr_channels = png_ptr->channels;
  473.  
  474.    /* pack the header information into the buffer */
  475.    png_save_uint_32(buf, width);
  476.    png_save_uint_32(buf + 4, height);
  477.    buf[8] = (png_byte)bit_depth;
  478.    buf[9] = (png_byte)color_type;
  479.    buf[10] = (png_byte)compression_type;
  480.    buf[11] = (png_byte)filter_type;
  481.    buf[12] = (png_byte)interlace_type;
  482.  
  483.    /* write the chunk */
  484.    png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
  485.  
  486.    /* initialize zlib with PNG info */
  487.    png_ptr->zstream.zalloc = png_zalloc;
  488.    png_ptr->zstream.zfree = png_zfree;
  489.    png_ptr->zstream.opaque = (voidpf)png_ptr;
  490.    if (!(png_ptr->do_filter))
  491.    {
  492.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
  493.          png_ptr->bit_depth < 8)
  494.          png_ptr->do_filter = PNG_FILTER_NONE;
  495.       else
  496.          png_ptr->do_filter = PNG_ALL_FILTERS;
  497.    }
  498.    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))
  499.    {
  500.       if (png_ptr->do_filter != PNG_FILTER_NONE)
  501.          png_ptr->zlib_strategy = Z_FILTERED;
  502.       else
  503.          png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
  504.    }
  505.    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))
  506.       png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;
  507.    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))
  508.       png_ptr->zlib_mem_level = 8;
  509.    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))
  510.       png_ptr->zlib_window_bits = 15;
  511.    if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
  512.       png_ptr->zlib_method = 8;
  513.    deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,
  514.       png_ptr->zlib_method, png_ptr->zlib_window_bits,
  515.       png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
  516.    png_ptr->zstream.next_out = png_ptr->zbuf;
  517.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  518.  
  519.    png_ptr->mode = PNG_HAVE_IHDR;
  520. }
  521.  
  522. /* write the palette.  We are careful not to trust png_color to be in the
  523.  * correct order for PNG, so people can redefine it to any convenient
  524.  * structure.
  525.  */
  526. void /* PRIVATE */
  527. png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
  528. {
  529. #ifdef PNG_USE_LOCAL_ARRAYS
  530.    PNG_PLTE;
  531. #endif
  532.    png_uint_32 i;
  533.    png_colorp pal_ptr;
  534.    png_byte buf[3];
  535.  
  536.    png_debug(1, "in png_write_PLTE\n");
  537.    if ((
  538. #if defined(PNG_MNG_FEATURES_SUPPORTED) || \
  539.     defined (PNG_WRITE_EMPTY_PLTE_SUPPORTED)
  540.         !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
  541. #endif
  542.         num_pal == 0) || num_pal > 256)
  543.      {
  544.        if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  545.          {
  546.            png_error(png_ptr, "Invalid number of colors in palette");
  547.          }
  548.        else
  549.          {
  550.            png_warning(png_ptr, "Invalid number of colors in palette");
  551.            return;
  552.          }
  553.    }
  554.  
  555.    png_ptr->num_palette = (png_uint_16)num_pal;
  556.    png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
  557.  
  558.    png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3);
  559. #ifndef PNG_NO_POINTER_INDEXING
  560.    for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
  561.    {
  562.       buf[0] = pal_ptr->red;
  563.       buf[1] = pal_ptr->green;
  564.       buf[2] = pal_ptr->blue;
  565.       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
  566.    }
  567. #else
  568.    /* This is a little slower but some buggy compilers need to do this instead */
  569.    pal_ptr=palette;
  570.    for (i = 0; i < num_pal; i++)
  571.    {
  572.       buf[0] = pal_ptr[i].red;
  573.       buf[1] = pal_ptr[i].green;
  574.       buf[2] = pal_ptr[i].blue;
  575.       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
  576.    }
  577. #endif
  578.    png_write_chunk_end(png_ptr);
  579.    png_ptr->mode |= PNG_HAVE_PLTE;
  580. }
  581.  
  582. /* write an IDAT chunk */
  583. void /* PRIVATE */
  584. png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
  585. {
  586. #ifdef PNG_USE_LOCAL_ARRAYS
  587.    PNG_IDAT;
  588. #endif
  589.    png_debug(1, "in png_write_IDAT\n");
  590.    png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);
  591.    png_ptr->mode |= PNG_HAVE_IDAT;
  592. }
  593.  
  594. /* write an IEND chunk */
  595. void /* PRIVATE */
  596. png_write_IEND(png_structp png_ptr)
  597. {
  598. #ifdef PNG_USE_LOCAL_ARRAYS
  599.    PNG_IEND;
  600. #endif
  601.    png_debug(1, "in png_write_IEND\n");
  602.    png_write_chunk(png_ptr, (png_bytep)png_IEND, NULL, (png_size_t)0);
  603.    png_ptr->mode |= PNG_HAVE_IEND;
  604. }
  605.  
  606. #if defined(PNG_WRITE_gAMA_SUPPORTED)
  607. /* write a gAMA chunk */
  608. #ifdef PNG_FLOATING_POINT_SUPPORTED
  609. void /* PRIVATE */
  610. png_write_gAMA(png_structp png_ptr, double file_gamma)
  611. {
  612. #ifdef PNG_USE_LOCAL_ARRAYS
  613.    PNG_gAMA;
  614. #endif
  615.    png_uint_32 igamma;
  616.    png_byte buf[4];
  617.  
  618.    png_debug(1, "in png_write_gAMA\n");
  619.    /* file_gamma is saved in 1/100,000ths */
  620.    igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
  621.    png_save_uint_32(buf, igamma);
  622.    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
  623. }
  624. #endif
  625. #ifdef PNG_FIXED_POINT_SUPPORTED
  626. void /* PRIVATE */
  627. png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
  628. {
  629. #ifdef PNG_USE_LOCAL_ARRAYS
  630.    PNG_gAMA;
  631. #endif
  632.    png_byte buf[4];
  633.  
  634.    png_debug(1, "in png_write_gAMA\n");
  635.    /* file_gamma is saved in 1/100,000ths */
  636.    png_save_uint_32(buf, file_gamma);
  637.    png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
  638. }
  639. #endif
  640. #endif
  641.  
  642. #if defined(PNG_WRITE_sRGB_SUPPORTED)
  643. /* write a sRGB chunk */
  644. void /* PRIVATE */
  645. png_write_sRGB(png_structp png_ptr, int srgb_intent)
  646. {
  647. #ifdef PNG_USE_LOCAL_ARRAYS
  648.    PNG_sRGB;
  649. #endif
  650.    png_byte buf[1];
  651.  
  652.    png_debug(1, "in png_write_sRGB\n");
  653.    if(srgb_intent >= PNG_sRGB_INTENT_LAST)
  654.          png_warning(png_ptr,
  655.             "Invalid sRGB rendering intent specified");
  656.    buf[0]=(png_byte)srgb_intent;
  657.    png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);
  658. }
  659. #endif
  660.  
  661. #if defined(PNG_WRITE_iCCP_SUPPORTED)
  662. /* write an iCCP chunk */
  663. void /* PRIVATE */
  664. png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
  665.    png_charp profile, int profile_len)
  666. {
  667. #ifdef PNG_USE_LOCAL_ARRAYS
  668.    PNG_iCCP;
  669. #endif
  670.    png_size_t name_len;
  671.    png_charp new_name;
  672.    compression_state comp;
  673.  
  674.    png_debug(1, "in png_write_iCCP\n");
  675.    if (name == NULL || (name_len = png_check_keyword(png_ptr, name,
  676.       &new_name)) == 0)
  677.    {
  678.       png_warning(png_ptr, "Empty keyword in iCCP chunk");
  679.       return;
  680.    }
  681.  
  682.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  683.       png_warning(png_ptr, "Unknown compression type in iCCP chunk");
  684.  
  685.    if (profile == NULL)
  686.       profile_len = 0;
  687.  
  688.    if (profile_len)
  689.        profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len,
  690.           PNG_COMPRESSION_TYPE_BASE, &comp);
  691.  
  692.    /* make sure we include the NULL after the name and the compression type */
  693.    png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,
  694.           (png_uint_32)name_len+profile_len+2);
  695.    new_name[name_len+1]=0x00;
  696.    png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2);
  697.  
  698.    if (profile_len)
  699.       png_write_compressed_data_out(png_ptr, &comp);
  700.  
  701.    png_write_chunk_end(png_ptr);
  702.    png_free(png_ptr, new_name);
  703. }
  704. #endif
  705.  
  706. #if defined(PNG_WRITE_sPLT_SUPPORTED)
  707. /* write a sPLT chunk */
  708. void /* PRIVATE */
  709. png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
  710. {
  711. #ifdef PNG_USE_LOCAL_ARRAYS
  712.    PNG_sPLT;
  713. #endif
  714.    png_size_t name_len;
  715.    png_charp new_name;
  716.    png_byte entrybuf[10];
  717.    int entry_size = (spalette->depth == 8 ? 6 : 10);
  718.    int palette_size = entry_size * spalette->nentries;
  719.    png_sPLT_entryp ep;
  720. #ifdef PNG_NO_POINTER_INDEXING
  721.    int i;
  722. #endif
  723.  
  724.    png_debug(1, "in png_write_sPLT\n");
  725.    if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,
  726.       spalette->name, &new_name))==0)
  727.    {
  728.       png_warning(png_ptr, "Empty keyword in sPLT chunk");
  729.       return;
  730.    }
  731.  
  732.    /* make sure we include the NULL after the name */
  733.    png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
  734.           (png_uint_32)(name_len + 2 + palette_size));
  735.    png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1);
  736.    png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1);
  737.  
  738.    /* loop through each palette entry, writing appropriately */
  739. #ifndef PNG_NO_POINTER_INDEXING
  740.    for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++)
  741.    {
  742.        if (spalette->depth == 8)
  743.        {
  744.            entrybuf[0] = (png_byte)ep->red;
  745.            entrybuf[1] = (png_byte)ep->green;
  746.            entrybuf[2] = (png_byte)ep->blue;
  747.            entrybuf[3] = (png_byte)ep->alpha;
  748.            png_save_uint_16(entrybuf + 4, ep->frequency);
  749.        }
  750.        else
  751.        {
  752.            png_save_uint_16(entrybuf + 0, ep->red);
  753.            png_save_uint_16(entrybuf + 2, ep->green);
  754.            png_save_uint_16(entrybuf + 4, ep->blue);
  755.            png_save_uint_16(entrybuf + 6, ep->alpha);
  756.            png_save_uint_16(entrybuf + 8, ep->frequency);
  757.        }
  758.        png_write_chunk_data(png_ptr, entrybuf, entry_size);
  759.    }
  760. #else
  761.    ep=spalette->entries;
  762.    for (i=0; i>spalette->nentries; i++)
  763.    {
  764.        if (spalette->depth == 8)
  765.        {
  766.            entrybuf[0] = (png_byte)ep[i].red;
  767.            entrybuf[1] = (png_byte)ep[i].green;
  768.            entrybuf[2] = (png_byte)ep[i].blue;
  769.            entrybuf[3] = (png_byte)ep[i].alpha;
  770.            png_save_uint_16(entrybuf + 4, ep[i].frequency);
  771.        }
  772.        else
  773.        {
  774.            png_save_uint_16(entrybuf + 0, ep[i].red);
  775.            png_save_uint_16(entrybuf + 2, ep[i].green);
  776.            png_save_uint_16(entrybuf + 4, ep[i].blue);
  777.            png_save_uint_16(entrybuf + 6, ep[i].alpha);
  778.            png_save_uint_16(entrybuf + 8, ep[i].frequency);
  779.        }
  780.        png_write_chunk_data(png_ptr, entrybuf, entry_size);
  781.    }
  782. #endif
  783.  
  784.    png_write_chunk_end(png_ptr);
  785.    png_free(png_ptr, new_name);
  786. }
  787. #endif
  788.  
  789. #if defined(PNG_WRITE_sBIT_SUPPORTED)
  790. /* write the sBIT chunk */
  791. void /* PRIVATE */
  792. png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
  793. {
  794. #ifdef PNG_USE_LOCAL_ARRAYS
  795.    PNG_sBIT;
  796. #endif
  797.    png_byte buf[4];
  798.    png_size_t size;
  799.  
  800.    png_debug(1, "in png_write_sBIT\n");
  801.    /* make sure we don't depend upon the order of PNG_COLOR_8 */
  802.    if (color_type & PNG_COLOR_MASK_COLOR)
  803.    {
  804.       png_byte maxbits;
  805.  
  806.       maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
  807.                 png_ptr->usr_bit_depth);
  808.       if (sbit->red == 0 || sbit->red > maxbits ||
  809.           sbit->green == 0 || sbit->green > maxbits ||
  810.           sbit->blue == 0 || sbit->blue > maxbits)
  811.       {
  812.          png_warning(png_ptr, "Invalid sBIT depth specified");
  813.          return;
  814.       }
  815.       buf[0] = sbit->red;
  816.       buf[1] = sbit->green;
  817.       buf[2] = sbit->blue;
  818.       size = 3;
  819.    }
  820.    else
  821.    {
  822.       if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
  823.       {
  824.          png_warning(png_ptr, "Invalid sBIT depth specified");
  825.          return;
  826.       }
  827.       buf[0] = sbit->gray;
  828.       size = 1;
  829.    }
  830.  
  831.    if (color_type & PNG_COLOR_MASK_ALPHA)
  832.    {
  833.       if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
  834.       {
  835.          png_warning(png_ptr, "Invalid sBIT depth specified");
  836.          return;
  837.       }
  838.       buf[size++] = sbit->alpha;
  839.    }
  840.  
  841.    png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);
  842. }
  843. #endif
  844.  
  845. #if defined(PNG_WRITE_cHRM_SUPPORTED)
  846. /* write the cHRM chunk */
  847. #ifdef PNG_FLOATING_POINT_SUPPORTED
  848. void /* PRIVATE */
  849. png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
  850.    double red_x, double red_y, double green_x, double green_y,
  851.    double blue_x, double blue_y)
  852. {
  853. #ifdef PNG_USE_LOCAL_ARRAYS
  854.    PNG_cHRM;
  855. #endif
  856.    png_byte buf[32];
  857.    png_uint_32 itemp;
  858.  
  859.    png_debug(1, "in png_write_cHRM\n");
  860.    /* each value is saved in 1/100,000ths */
  861.    if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
  862.        white_x + white_y > 1.0)
  863.    {
  864.       png_warning(png_ptr, "Invalid cHRM white point specified");
  865. #if !defined(PNG_NO_CONSOLE_IO)
  866.       fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y);
  867. #endif
  868.       return;
  869.    }
  870.    itemp = (png_uint_32)(white_x * 100000.0 + 0.5);
  871.    png_save_uint_32(buf, itemp);
  872.    itemp = (png_uint_32)(white_y * 100000.0 + 0.5);
  873.    png_save_uint_32(buf + 4, itemp);
  874.  
  875.    if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 ||
  876.        red_x + red_y > 1.0)
  877.    {
  878.       png_warning(png_ptr, "Invalid cHRM red point specified");
  879.       return;
  880.    }
  881.    itemp = (png_uint_32)(red_x * 100000.0 + 0.5);
  882.    png_save_uint_32(buf + 8, itemp);
  883.    itemp = (png_uint_32)(red_y * 100000.0 + 0.5);
  884.    png_save_uint_32(buf + 12, itemp);
  885.  
  886.    if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 ||
  887.        green_x + green_y > 1.0)
  888.    {
  889.       png_warning(png_ptr, "Invalid cHRM green point specified");
  890.       return;
  891.    }
  892.    itemp = (png_uint_32)(green_x * 100000.0 + 0.5);
  893.    png_save_uint_32(buf + 16, itemp);
  894.    itemp = (png_uint_32)(green_y * 100000.0 + 0.5);
  895.    png_save_uint_32(buf + 20, itemp);
  896.  
  897.    if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 ||
  898.        blue_x + blue_y > 1.0)
  899.    {
  900.       png_warning(png_ptr, "Invalid cHRM blue point specified");
  901.       return;
  902.    }
  903.    itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);
  904.    png_save_uint_32(buf + 24, itemp);
  905.    itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);
  906.    png_save_uint_32(buf + 28, itemp);
  907.  
  908.    png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
  909. }
  910. #endif
  911. #ifdef PNG_FIXED_POINT_SUPPORTED
  912. void /* PRIVATE */
  913. png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
  914.    png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,
  915.    png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,
  916.    png_fixed_point blue_y)
  917. {
  918. #ifdef PNG_USE_LOCAL_ARRAYS
  919.    PNG_cHRM;
  920. #endif
  921.    png_byte buf[32];
  922.  
  923.    png_debug(1, "in png_write_cHRM\n");
  924.    /* each value is saved in 1/100,000ths */
  925.    if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)
  926.    {
  927.       png_warning(png_ptr, "Invalid fixed cHRM white point specified");
  928. #if !defined(PNG_NO_CONSOLE_IO)
  929.       fprintf(stderr,"white_x=%ld, white_y=%ld\n",white_x, white_y);
  930. #endif
  931.       return;
  932.    }
  933.    png_save_uint_32(buf, white_x);
  934.    png_save_uint_32(buf + 4, white_y);
  935.  
  936.    if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L)
  937.    {
  938.       png_warning(png_ptr, "Invalid cHRM fixed red point specified");
  939.       return;
  940.    }
  941.    png_save_uint_32(buf + 8, red_x);
  942.    png_save_uint_32(buf + 12, red_y);
  943.  
  944.    if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L)
  945.    {
  946.       png_warning(png_ptr, "Invalid fixed cHRM green point specified");
  947.       return;
  948.    }
  949.    png_save_uint_32(buf + 16, green_x);
  950.    png_save_uint_32(buf + 20, green_y);
  951.  
  952.    if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L)
  953.    {
  954.       png_warning(png_ptr, "Invalid fixed cHRM blue point specified");
  955.       return;
  956.    }
  957.    png_save_uint_32(buf + 24, blue_x);
  958.    png_save_uint_32(buf + 28, blue_y);
  959.  
  960.    png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
  961. }
  962. #endif
  963. #endif
  964.  
  965. #if defined(PNG_WRITE_tRNS_SUPPORTED)
  966. /* write the tRNS chunk */
  967. void /* PRIVATE */
  968. png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
  969.    int num_trans, int color_type)
  970. {
  971. #ifdef PNG_USE_LOCAL_ARRAYS
  972.    PNG_tRNS;
  973. #endif
  974.    png_byte buf[6];
  975.  
  976.    png_debug(1, "in png_write_tRNS\n");
  977.    if (color_type == PNG_COLOR_TYPE_PALETTE)
  978.    {
  979.       if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
  980.       {
  981.          png_warning(png_ptr,"Invalid number of transparent colors specified");
  982.          return;
  983.       }
  984.       /* write the chunk out as it is */
  985.       png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans);
  986.    }
  987.    else if (color_type == PNG_COLOR_TYPE_GRAY)
  988.    {
  989.       /* one 16 bit value */
  990.       png_save_uint_16(buf, tran->gray);
  991.       png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);
  992.    }
  993.    else if (color_type == PNG_COLOR_TYPE_RGB)
  994.    {
  995.       /* three 16 bit values */
  996.       png_save_uint_16(buf, tran->red);
  997.       png_save_uint_16(buf + 2, tran->green);
  998.       png_save_uint_16(buf + 4, tran->blue);
  999.       png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);
  1000.    }
  1001.    else
  1002.    {
  1003.       png_warning(png_ptr, "Can't write tRNS with an alpha channel");
  1004.    }
  1005. }
  1006. #endif
  1007.  
  1008. #if defined(PNG_WRITE_bKGD_SUPPORTED)
  1009. /* write the background chunk */
  1010. void /* PRIVATE */
  1011. png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
  1012. {
  1013. #ifdef PNG_USE_LOCAL_ARRAYS
  1014.    PNG_bKGD;
  1015. #endif
  1016.    png_byte buf[6];
  1017.  
  1018.    png_debug(1, "in png_write_bKGD\n");
  1019.    if (color_type == PNG_COLOR_TYPE_PALETTE)
  1020.    {
  1021.       if (
  1022. #if defined(PNG_MNG_FEATURES_SUPPORTED) || \
  1023.     defined (PNG_WRITE_EMPTY_PLTE_SUPPORTED)
  1024.           (png_ptr->num_palette ||
  1025.           (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
  1026. #endif
  1027.          back->index > png_ptr->num_palette)
  1028.       {
  1029.          png_warning(png_ptr, "Invalid background palette index");
  1030.          return;
  1031.       }
  1032.       buf[0] = back->index;
  1033.       png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);
  1034.    }
  1035.    else if (color_type & PNG_COLOR_MASK_COLOR)
  1036.    {
  1037.       png_save_uint_16(buf, back->red);
  1038.       png_save_uint_16(buf + 2, back->green);
  1039.       png_save_uint_16(buf + 4, back->blue);
  1040.       png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);
  1041.    }
  1042.    else
  1043.    {
  1044.       png_save_uint_16(buf, back->gray);
  1045.       png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);
  1046.    }
  1047. }
  1048. #endif
  1049.  
  1050. #if defined(PNG_WRITE_hIST_SUPPORTED)
  1051. /* write the histogram */
  1052. void /* PRIVATE */
  1053. png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
  1054. {
  1055. #ifdef PNG_USE_LOCAL_ARRAYS
  1056.    PNG_hIST;
  1057. #endif
  1058.    int i;
  1059.    png_byte buf[3];
  1060.  
  1061.    png_debug(1, "in png_write_hIST\n");
  1062.    if (num_hist > (int)png_ptr->num_palette)
  1063.    {
  1064.       png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,
  1065.          png_ptr->num_palette);
  1066.       png_warning(png_ptr, "Invalid number of histogram entries specified");
  1067.       return;
  1068.    }
  1069.  
  1070.    png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2));
  1071.    for (i = 0; i < num_hist; i++)
  1072.    {
  1073.       png_save_uint_16(buf, hist[i]);
  1074.       png_write_chunk_data(png_ptr, buf, (png_size_t)2);
  1075.    }
  1076.    png_write_chunk_end(png_ptr);
  1077. }
  1078. #endif
  1079.  
  1080. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
  1081.     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
  1082. /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
  1083.  * and if invalid, correct the keyword rather than discarding the entire
  1084.  * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in
  1085.  * length, forbids leading or trailing whitespace, multiple internal spaces,
  1086.  * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.
  1087.  *
  1088.  * The new_key is allocated to hold the corrected keyword and must be freed
  1089.  * by the calling routine.  This avoids problems with trying to write to
  1090.  * static keywords without having to have duplicate copies of the strings.
  1091.  */
  1092. png_size_t /* PRIVATE */
  1093. png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
  1094. {
  1095.    png_size_t key_len;
  1096.    png_charp kp, dp;
  1097.    int kflag;
  1098.    int kwarn=0;
  1099.  
  1100.    png_debug(1, "in png_check_keyword\n");
  1101.    *new_key = NULL;
  1102.  
  1103.    if (key == NULL || (key_len = png_strlen(key)) == 0)
  1104.    {
  1105.       png_warning(png_ptr, "zero length keyword");
  1106.       return ((png_size_t)0);
  1107.    }
  1108.  
  1109.    png_debug1(2, "Keyword to be checked is '%s'\n", key);
  1110.  
  1111.    *new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 2));
  1112.  
  1113.    /* Replace non-printing characters with a blank and print a warning */
  1114.    for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
  1115.    {
  1116.       if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1))
  1117.       {
  1118. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  1119.          char msg[40];
  1120.  
  1121.          sprintf(msg, "invalid keyword character 0x%02X", *kp);
  1122.          png_warning(png_ptr, msg);
  1123. #else
  1124.          png_warning(png_ptr, "invalid character in keyword");
  1125. #endif
  1126.          *dp = ' ';
  1127.       }
  1128.       else
  1129.       {
  1130.          *dp = *kp;
  1131.       }
  1132.    }
  1133.    *dp = '\0';
  1134.  
  1135.    /* Remove any trailing white space. */
  1136.    kp = *new_key + key_len - 1;
  1137.    if (*kp == ' ')
  1138.    {
  1139.       png_warning(png_ptr, "trailing spaces removed from keyword");
  1140.  
  1141.       while (*kp == ' ')
  1142.       {
  1143.         *(kp--) = '\0';
  1144.         key_len--;
  1145.       }
  1146.    }
  1147.  
  1148.    /* Remove any leading white space. */
  1149.    kp = *new_key;
  1150.    if (*kp == ' ')
  1151.    {
  1152.       png_warning(png_ptr, "leading spaces removed from keyword");
  1153.  
  1154.       while (*kp == ' ')
  1155.       {
  1156.         kp++;
  1157.         key_len--;
  1158.       }
  1159.    }
  1160.  
  1161.    png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);
  1162.  
  1163.    /* Remove multiple internal spaces. */
  1164.    for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
  1165.    {
  1166.       if (*kp == ' ' && kflag == 0)
  1167.       {
  1168.          *(dp++) = *kp;
  1169.          kflag = 1;
  1170.       }
  1171.       else if (*kp == ' ')
  1172.       {
  1173.          key_len--;
  1174.          kwarn=1;
  1175.       }
  1176.       else
  1177.       {
  1178.          *(dp++) = *kp;
  1179.          kflag = 0;
  1180.       }
  1181.    }
  1182.    *dp = '\0';
  1183.    if(kwarn)
  1184.       png_warning(png_ptr, "extra interior spaces removed from keyword");
  1185.  
  1186.    if (key_len == 0)
  1187.    {
  1188.       png_free(png_ptr, *new_key);
  1189.       *new_key=NULL;
  1190.       png_warning(png_ptr, "Zero length keyword");
  1191.    }
  1192.  
  1193.    if (key_len > 79)
  1194.    {
  1195.       png_warning(png_ptr, "keyword length must be 1 - 79 characters");
  1196.       new_key[79] = '\0';
  1197.       key_len = 79;
  1198.    }
  1199.  
  1200.    return (key_len);
  1201. }
  1202. #endif
  1203.  
  1204. #if defined(PNG_WRITE_tEXt_SUPPORTED)
  1205. /* write a tEXt chunk */
  1206. void /* PRIVATE */
  1207. png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
  1208.    png_size_t text_len)
  1209. {
  1210. #ifdef PNG_USE_LOCAL_ARRAYS
  1211.    PNG_tEXt;
  1212. #endif
  1213.    png_size_t key_len;
  1214.    png_charp new_key;
  1215.  
  1216.    png_debug(1, "in png_write_tEXt\n");
  1217.    if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
  1218.    {
  1219.       png_warning(png_ptr, "Empty keyword in tEXt chunk");
  1220.       return;
  1221.    }
  1222.  
  1223.    if (text == NULL || *text == '\0')
  1224.       text_len = 0;
  1225.    else
  1226.       text_len = png_strlen(text);
  1227.  
  1228.    /* make sure we include the 0 after the key */
  1229.    png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1);
  1230.    /*
  1231.     * We leave it to the application to meet PNG-1.0 requirements on the
  1232.     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
  1233.     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.
  1234.     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1235.     */
  1236.    png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
  1237.    if (text_len)
  1238.       png_write_chunk_data(png_ptr, (png_bytep)text, text_len);
  1239.  
  1240.    png_write_chunk_end(png_ptr);
  1241.    png_free(png_ptr, new_key);
  1242. }
  1243. #endif
  1244.  
  1245. #if defined(PNG_WRITE_zTXt_SUPPORTED)
  1246. /* write a compressed text chunk */
  1247. void /* PRIVATE */
  1248. png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
  1249.    png_size_t text_len, int compression)
  1250. {
  1251. #ifdef PNG_USE_LOCAL_ARRAYS
  1252.    PNG_zTXt;
  1253. #endif
  1254.    png_size_t key_len;
  1255.    char buf[1];
  1256.    png_charp new_key;
  1257.    compression_state comp;
  1258.  
  1259.    png_debug(1, "in png_write_zTXt\n");
  1260.  
  1261.    if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
  1262.    {
  1263.       png_warning(png_ptr, "Empty keyword in zTXt chunk");
  1264.       return;
  1265.    }
  1266.  
  1267.    if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
  1268.    {
  1269.       png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
  1270.       png_free(png_ptr, new_key);
  1271.       return;
  1272.    }
  1273.  
  1274.    text_len = png_strlen(text);
  1275.  
  1276.    png_free(png_ptr, new_key);
  1277.  
  1278.    /* compute the compressed data; do it now for the length */
  1279.    text_len = png_text_compress(png_ptr, text, text_len, compression,
  1280.        &comp);
  1281.  
  1282.    /* write start of chunk */
  1283.    png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32)
  1284.       (key_len+text_len+2));
  1285.    /* write key */
  1286.    png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1);
  1287.    buf[0] = (png_byte)compression;
  1288.    /* write compression */
  1289.    png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
  1290.    /* write the compressed data */
  1291.    png_write_compressed_data_out(png_ptr, &comp);
  1292.  
  1293.    /* close the chunk */
  1294.    png_write_chunk_end(png_ptr);
  1295. }
  1296. #endif
  1297.  
  1298. #if defined(PNG_WRITE_iTXt_SUPPORTED)
  1299. /* write an iTXt chunk */
  1300. void /* PRIVATE */
  1301. png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
  1302.     png_charp lang, png_charp lang_key, png_charp text)
  1303. {
  1304. #ifdef PNG_USE_LOCAL_ARRAYS
  1305.    PNG_iTXt;
  1306. #endif
  1307.    png_size_t lang_len, key_len, lang_key_len, text_len;
  1308.    png_charp new_lang, new_key;
  1309.    png_byte cbuf[2];
  1310.    compression_state comp;
  1311.  
  1312.    png_debug(1, "in png_write_iTXt\n");
  1313.  
  1314.    if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
  1315.    {
  1316.       png_warning(png_ptr, "Empty keyword in iTXt chunk");
  1317.       return;
  1318.    }
  1319.    if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang,
  1320.       &new_lang))==0)
  1321.    {
  1322.       png_warning(png_ptr, "Empty language field in iTXt chunk");
  1323.       return;
  1324.    }
  1325.    lang_key_len = png_strlen(lang_key);
  1326.    text_len = png_strlen(text);
  1327.  
  1328.    if (text == NULL || *text == '\0')
  1329.       text_len = 0;
  1330.  
  1331.    /* compute the compressed data; do it now for the length */
  1332.    text_len = png_text_compress(png_ptr, text, text_len, compression-2,
  1333.       &comp);
  1334.  
  1335.    /* make sure we include the compression flag, the compression byte,
  1336.     * and the NULs after the key, lang, and lang_key parts */
  1337.  
  1338.    png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,
  1339.           (png_uint_32)(
  1340.         5 /* comp byte, comp flag, terminators for key, lang and lang_key */
  1341.         + key_len
  1342.         + lang_len
  1343.         + lang_key_len
  1344.         + text_len));
  1345.  
  1346.    /*
  1347.     * We leave it to the application to meet PNG-1.0 requirements on the
  1348.     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
  1349.     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.
  1350.     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1351.     */
  1352.    png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
  1353.  
  1354.    /* set the compression flag */
  1355.    if (compression == PNG_ITXT_COMPRESSION_NONE || \
  1356.        compression == PNG_TEXT_COMPRESSION_NONE)
  1357.        cbuf[0] = 0;
  1358.    else /* compression == PNG_ITXT_COMPRESSION_zTXt */
  1359.        cbuf[0] = 1;
  1360.    /* set the compression method */
  1361.    cbuf[1] = 0;
  1362.    png_write_chunk_data(png_ptr, cbuf, 2);
  1363.  
  1364.    png_write_chunk_data(png_ptr, (png_bytep)new_lang, lang_len + 1);
  1365.    png_write_chunk_data(png_ptr, (png_bytep)lang_key, lang_key_len+1);
  1366.    png_write_chunk_data(png_ptr, '\0', 1);
  1367.  
  1368.    png_write_compressed_data_out(png_ptr, &comp);
  1369.  
  1370.    png_write_chunk_end(png_ptr);
  1371.    png_free(png_ptr, new_key);
  1372.    png_free(png_ptr, new_lang);
  1373. }
  1374. #endif
  1375.  
  1376. #if defined(PNG_WRITE_oFFs_SUPPORTED)
  1377. /* write the oFFs chunk */
  1378. void /* PRIVATE */
  1379. png_write_oFFs(png_structp png_ptr, png_uint_32 x_offset,
  1380.    png_uint_32 y_offset,
  1381.    int unit_type)
  1382. {
  1383. #ifdef PNG_USE_LOCAL_ARRAYS
  1384.    PNG_oFFs;
  1385. #endif
  1386.    png_byte buf[9];
  1387.  
  1388.    png_debug(1, "in png_write_oFFs\n");
  1389.    if (unit_type >= PNG_OFFSET_LAST)
  1390.       png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
  1391.  
  1392.    png_save_uint_32(buf, x_offset);
  1393.    png_save_uint_32(buf + 4, y_offset);
  1394.    buf[8] = (png_byte)unit_type;
  1395.  
  1396.    png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);
  1397. }
  1398. #endif
  1399.  
  1400. #if defined(PNG_WRITE_pCAL_SUPPORTED)
  1401. /* write the pCAL chunk (described in the PNG extensions document) */
  1402. void /* PRIVATE */
  1403. png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
  1404.    png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
  1405. {
  1406. #ifdef PNG_USE_LOCAL_ARRAYS
  1407.    PNG_pCAL;
  1408. #endif
  1409.    png_size_t purpose_len, units_len, total_len;
  1410.    png_uint_32p params_len;
  1411.    png_byte buf[10];
  1412.    png_charp new_purpose;
  1413.    int i;
  1414.  
  1415.    png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
  1416.    if (type >= PNG_EQUATION_LAST)
  1417.       png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
  1418.  
  1419.    purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
  1420.    png_debug1(3, "pCAL purpose length = %d\n", purpose_len);
  1421.    units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
  1422.    png_debug1(3, "pCAL units length = %d\n", units_len);
  1423.    total_len = purpose_len + units_len + 10;
  1424.  
  1425.    params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams
  1426.       *sizeof(png_uint_32)));
  1427.  
  1428.    /* Find the length of each parameter, making sure we don't count the
  1429.       null terminator for the last parameter. */
  1430.    for (i = 0; i < nparams; i++)
  1431.    {
  1432.       params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
  1433.       png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]);
  1434.       total_len += (png_size_t)params_len[i];
  1435.    }
  1436.  
  1437.    png_debug1(3, "pCAL total length = %d\n", total_len);
  1438.    png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);
  1439.    png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);
  1440.    png_save_int_32(buf, X0);
  1441.    png_save_int_32(buf + 4, X1);
  1442.    buf[8] = (png_byte)type;
  1443.    buf[9] = (png_byte)nparams;
  1444.    png_write_chunk_data(png_ptr, buf, (png_size_t)10);
  1445.    png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);
  1446.  
  1447.    png_free(png_ptr, new_purpose);
  1448.  
  1449.    for (i = 0; i < nparams; i++)
  1450.    {
  1451.       png_write_chunk_data(png_ptr, (png_bytep)params[i],
  1452.          (png_size_t)params_len[i]);
  1453.    }
  1454.  
  1455.    png_free(png_ptr, params_len);
  1456.    png_write_chunk_end(png_ptr);
  1457. }
  1458. #endif
  1459.  
  1460. #if defined(PNG_WRITE_sCAL_SUPPORTED)
  1461. /* write the sCAL chunk */
  1462. #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
  1463. void /* PRIVATE */
  1464. png_write_sCAL(png_structp png_ptr, int unit, double width,double height)
  1465. {
  1466. #ifdef PNG_USE_LOCAL_ARRAYS
  1467.    PNG_sCAL;
  1468. #endif
  1469.    png_size_t total_len;
  1470.    char wbuf[32], hbuf[32];
  1471.  
  1472.    png_debug(1, "in png_write_sCAL\n");
  1473.  
  1474. #if defined(_WIN32_WCE)
  1475. /* sprintf() function is not supported on WindowsCE */
  1476.    {
  1477.       wchar_t wc_buf[32];
  1478.       swprintf(wc_buf, TEXT("%12.12e"), width);
  1479.       WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL);
  1480.       swprintf(wc_buf, TEXT("%12.12e"), height);
  1481.       WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL);
  1482.    }
  1483. #else
  1484.    sprintf(wbuf, "%12.12e", width);
  1485.    sprintf(hbuf, "%12.12e", height);
  1486. #endif
  1487.    total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf);
  1488.  
  1489.    png_debug1(3, "sCAL total length = %d\n", total_len);
  1490.    png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len);
  1491.    png_write_chunk_data(png_ptr, (png_bytep)&unit, 1);
  1492.    png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1);
  1493.    png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf));
  1494.  
  1495.    png_write_chunk_end(png_ptr);
  1496. }
  1497. #else
  1498. #ifdef PNG_FIXED_POINT_SUPPORTED
  1499. void /* PRIVATE */
  1500. png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
  1501.    png_charp height)
  1502. {
  1503. #ifdef PNG_USE_LOCAL_ARRAYS
  1504.    PNG_sCAL;
  1505. #endif
  1506.    png_size_t total_len;
  1507.    char wbuf[32], hbuf[32];
  1508.  
  1509.    png_debug(1, "in png_write_sCAL_s\n");
  1510.  
  1511.    png_strcpy(wbuf,(const char *)width);
  1512.    png_strcpy(hbuf,(const char *)height);
  1513.    total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf);
  1514.  
  1515.    png_debug1(3, "sCAL total length = %d\n", total_len);
  1516.    png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len);
  1517.    png_write_chunk_data(png_ptr, (png_bytep)&unit, 1);
  1518.    png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1);
  1519.    png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf));
  1520.  
  1521.    png_write_chunk_end(png_ptr);
  1522. }
  1523. #endif
  1524. #endif
  1525. #endif
  1526.  
  1527. #if defined(PNG_WRITE_pHYs_SUPPORTED)
  1528. /* write the pHYs chunk */
  1529. void /* PRIVATE */
  1530. png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
  1531.    png_uint_32 y_pixels_per_unit,
  1532.    int unit_type)
  1533. {
  1534. #ifdef PNG_USE_LOCAL_ARRAYS
  1535.    PNG_pHYs;
  1536. #endif
  1537.    png_byte buf[9];
  1538.  
  1539.    png_debug(1, "in png_write_pHYs\n");
  1540.    if (unit_type >= PNG_RESOLUTION_LAST)
  1541.       png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
  1542.  
  1543.    png_save_uint_32(buf, x_pixels_per_unit);
  1544.    png_save_uint_32(buf + 4, y_pixels_per_unit);
  1545.    buf[8] = (png_byte)unit_type;
  1546.  
  1547.    png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
  1548. }
  1549. #endif
  1550.  
  1551. #if defined(PNG_WRITE_tIME_SUPPORTED)
  1552. /* Write the tIME chunk.  Use either png_convert_from_struct_tm()
  1553.  * or png_convert_from_time_t(), or fill in the structure yourself.
  1554.  */
  1555. void /* PRIVATE */
  1556. png_write_tIME(png_structp png_ptr, png_timep mod_time)
  1557. {
  1558. #ifdef PNG_USE_LOCAL_ARRAYS
  1559.    PNG_tIME;
  1560. #endif
  1561.    png_byte buf[7];
  1562.  
  1563.    png_debug(1, "in png_write_tIME\n");
  1564.    if (mod_time->month  > 12 || mod_time->month  < 1 ||
  1565.        mod_time->day    > 31 || mod_time->day    < 1 ||
  1566.        mod_time->hour   > 23 || mod_time->second > 60)
  1567.    {
  1568.       png_warning(png_ptr, "Invalid time specified for tIME chunk");
  1569.       return;
  1570.    }
  1571.  
  1572.    png_save_uint_16(buf, mod_time->year);
  1573.    buf[2] = mod_time->month;
  1574.    buf[3] = mod_time->day;
  1575.    buf[4] = mod_time->hour;
  1576.    buf[5] = mod_time->minute;
  1577.    buf[6] = mod_time->second;
  1578.  
  1579.    png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
  1580. }
  1581. #endif
  1582.  
  1583. /* initializes the row writing capability of libpng */
  1584. void /* PRIVATE */
  1585. png_write_start_row(png_structp png_ptr)
  1586. {
  1587. #ifdef PNG_USE_LOCAL_ARRAYS
  1588.    /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1589.  
  1590.    /* start of interlace block */
  1591.    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1592.  
  1593.    /* offset to next interlace block */
  1594.    int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1595.  
  1596.    /* start of interlace block in the y direction */
  1597.    int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  1598.  
  1599.    /* offset to next interlace block in the y direction */
  1600.    int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  1601. #endif
  1602.  
  1603.    png_size_t buf_size;
  1604.  
  1605.    png_debug(1, "in png_write_start_row\n");
  1606.    buf_size = (png_size_t)(((png_ptr->width * png_ptr->usr_channels *
  1607.                             png_ptr->usr_bit_depth + 7) >> 3) + 1);
  1608.  
  1609.    /* set up row buffer */
  1610.    png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
  1611.    png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
  1612.  
  1613.    /* set up filtering buffer, if using this filter */
  1614.    if (png_ptr->do_filter & PNG_FILTER_SUB)
  1615.    {
  1616.       png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
  1617.          (png_ptr->rowbytes + 1));
  1618.       png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
  1619.    }
  1620.  
  1621.    /* We only need to keep the previous row if we are using one of these. */
  1622.    if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
  1623.    {
  1624.      /* set up previous row buffer */
  1625.       png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
  1626.       png_memset(png_ptr->prev_row, 0, buf_size);
  1627.  
  1628.       if (png_ptr->do_filter & PNG_FILTER_UP)
  1629.       {
  1630.          png_ptr->up_row = (png_bytep )png_malloc(png_ptr,
  1631.             (png_ptr->rowbytes + 1));
  1632.          png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
  1633.       }
  1634.  
  1635.       if (png_ptr->do_filter & PNG_FILTER_AVG)
  1636.       {
  1637.          png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
  1638.             (png_ptr->rowbytes + 1));
  1639.          png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
  1640.       }
  1641.  
  1642.       if (png_ptr->do_filter & PNG_FILTER_PAETH)
  1643.       {
  1644.          png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,
  1645.             (png_ptr->rowbytes + 1));
  1646.          png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
  1647.       }
  1648.    }
  1649.  
  1650. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1651.    /* if interlaced, we need to set up width and height of pass */
  1652.    if (png_ptr->interlaced)
  1653.    {
  1654.       if (!(png_ptr->transformations & PNG_INTERLACE))
  1655.       {
  1656.          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
  1657.             png_pass_ystart[0]) / png_pass_yinc[0];
  1658.          png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
  1659.             png_pass_start[0]) / png_pass_inc[0];
  1660.       }
  1661.       else
  1662.       {
  1663.          png_ptr->num_rows = png_ptr->height;
  1664.          png_ptr->usr_width = png_ptr->width;
  1665.       }
  1666.    }
  1667.    else
  1668. #endif
  1669.    {
  1670.       png_ptr->num_rows = png_ptr->height;
  1671.       png_ptr->usr_width = png_ptr->width;
  1672.    }
  1673.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1674.    png_ptr->zstream.next_out = png_ptr->zbuf;
  1675. }
  1676.  
  1677. /* Internal use only.  Called when finished processing a row of data. */
  1678. void /* PRIVATE */
  1679. png_write_finish_row(png_structp png_ptr)
  1680. {
  1681. #ifdef PNG_USE_LOCAL_ARRAYS
  1682.    /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1683.  
  1684.    /* start of interlace block */
  1685.    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1686.  
  1687.    /* offset to next interlace block */
  1688.    int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1689.  
  1690.    /* start of interlace block in the y direction */
  1691.    int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  1692.  
  1693.    /* offset to next interlace block in the y direction */
  1694.    int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  1695. #endif
  1696.  
  1697.    int ret;
  1698.  
  1699.    png_debug(1, "in png_write_finish_row\n");
  1700.    /* next row */
  1701.    png_ptr->row_number++;
  1702.  
  1703.    /* see if we are done */
  1704.    if (png_ptr->row_number < png_ptr->num_rows)
  1705.       return;
  1706.  
  1707. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1708.    /* if interlaced, go to next pass */
  1709.    if (png_ptr->interlaced)
  1710.    {
  1711.       png_ptr->row_number = 0;
  1712.       if (png_ptr->transformations & PNG_INTERLACE)
  1713.       {
  1714.          png_ptr->pass++;
  1715.       }
  1716.       else
  1717.       {
  1718.          /* loop until we find a non-zero width or height pass */
  1719.          do
  1720.          {
  1721.             png_ptr->pass++;
  1722.             if (png_ptr->pass >= 7)
  1723.                break;
  1724.             png_ptr->usr_width = (png_ptr->width +
  1725.                png_pass_inc[png_ptr->pass] - 1 -
  1726.                png_pass_start[png_ptr->pass]) /
  1727.                png_pass_inc[png_ptr->pass];
  1728.             png_ptr->num_rows = (png_ptr->height +
  1729.                png_pass_yinc[png_ptr->pass] - 1 -
  1730.                png_pass_ystart[png_ptr->pass]) /
  1731.                png_pass_yinc[png_ptr->pass];
  1732.             if (png_ptr->transformations & PNG_INTERLACE)
  1733.                break;
  1734.          } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
  1735.  
  1736.       }
  1737.  
  1738.       /* reset the row above the image for the next pass */
  1739.       if (png_ptr->pass < 7)
  1740.       {
  1741.          if (png_ptr->prev_row != NULL)
  1742.             png_memset(png_ptr->prev_row, 0,
  1743.                (png_size_t) (((png_uint_32)png_ptr->usr_channels *
  1744.                (png_uint_32)png_ptr->usr_bit_depth *
  1745.                png_ptr->width + 7) >> 3) + 1);
  1746.          return;
  1747.       }
  1748.    }
  1749. #endif
  1750.  
  1751.    /* if we get here, we've just written the last row, so we need
  1752.       to flush the compressor */
  1753.    do
  1754.    {
  1755.       /* tell the compressor we are done */
  1756.       ret = deflate(&png_ptr->zstream, Z_FINISH);
  1757.       /* check for an error */
  1758.       if (ret == Z_OK)
  1759.       {
  1760.          /* check to see if we need more room */
  1761.          if (!(png_ptr->zstream.avail_out))
  1762.          {
  1763.             png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
  1764.             png_ptr->zstream.next_out = png_ptr->zbuf;
  1765.             png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1766.          }
  1767.       }
  1768.       else if (ret != Z_STREAM_END)
  1769.       {
  1770.          if (png_ptr->zstream.msg != NULL)
  1771.             png_error(png_ptr, png_ptr->zstream.msg);
  1772.          else
  1773.             png_error(png_ptr, "zlib error");
  1774.       }
  1775.    } while (ret != Z_STREAM_END);
  1776.  
  1777.    /* write any extra space */
  1778.    if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)
  1779.    {
  1780.       png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -
  1781.          png_ptr->zstream.avail_out);
  1782.    }
  1783.  
  1784.    deflateReset(&png_ptr->zstream);
  1785. }
  1786.  
  1787. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  1788. /* Pick out the correct pixels for the interlace pass.
  1789.  * The basic idea here is to go through the row with a source
  1790.  * pointer and a destination pointer (sp and dp), and copy the
  1791.  * correct pixels for the pass.  As the row gets compacted,
  1792.  * sp will always be >= dp, so we should never overwrite anything.
  1793.  * See the default: case for the easiest code to understand.
  1794.  */
  1795. void /* PRIVATE */
  1796. png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
  1797. {
  1798. #ifdef PNG_USE_LOCAL_ARRAYS
  1799.    /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1800.  
  1801.    /* start of interlace block */
  1802.    int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1803.  
  1804.    /* offset to next interlace block */
  1805.    int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1806. #endif
  1807.  
  1808.    png_debug(1, "in png_do_write_interlace\n");
  1809.    /* we don't have to do anything on the last pass (6) */
  1810. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  1811.    if (row != NULL && row_info != NULL && pass < 6)
  1812. #else
  1813.    if (pass < 6)
  1814. #endif
  1815.    {
  1816.       /* each pixel depth is handled separately */
  1817.       switch (row_info->pixel_depth)
  1818.       {
  1819.          case 1:
  1820.          {
  1821.             png_bytep sp;
  1822.             png_bytep dp;
  1823.             int shift;
  1824.             int d;
  1825.             int value;
  1826.             png_uint_32 i;
  1827.             png_uint_32 row_width = row_info->width;
  1828.  
  1829.             dp = row;
  1830.             d = 0;
  1831.             shift = 7;
  1832.             for (i = png_pass_start[pass]; i < row_width;
  1833.                i += png_pass_inc[pass])
  1834.             {
  1835.                sp = row + (png_size_t)(i >> 3);
  1836.                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
  1837.                d |= (value << shift);
  1838.  
  1839.                if (shift == 0)
  1840.                {
  1841.                   shift = 7;
  1842.                   *dp++ = (png_byte)d;
  1843.                   d = 0;
  1844.                }
  1845.                else
  1846.                   shift--;
  1847.  
  1848.             }
  1849.             if (shift != 7)
  1850.                *dp = (png_byte)d;
  1851.             break;
  1852.          }
  1853.          case 2:
  1854.          {
  1855.             png_bytep sp;
  1856.             png_bytep dp;
  1857.             int shift;
  1858.             int d;
  1859.             int value;
  1860.             png_uint_32 i;
  1861.             png_uint_32 row_width = row_info->width;
  1862.  
  1863.             dp = row;
  1864.             shift = 6;
  1865.             d = 0;
  1866.             for (i = png_pass_start[pass]; i < row_width;
  1867.                i += png_pass_inc[pass])
  1868.             {
  1869.                sp = row + (png_size_t)(i >> 2);
  1870.                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
  1871.                d |= (value << shift);
  1872.  
  1873.                if (shift == 0)
  1874.                {
  1875.                   shift = 6;
  1876.                   *dp++ = (png_byte)d;
  1877.                   d = 0;
  1878.                }
  1879.                else
  1880.                   shift -= 2;
  1881.             }
  1882.             if (shift != 6)
  1883.                    *dp = (png_byte)d;
  1884.             break;
  1885.          }
  1886.          case 4:
  1887.          {
  1888.             png_bytep sp;
  1889.             png_bytep dp;
  1890.             int shift;
  1891.             int d;
  1892.             int value;
  1893.             png_uint_32 i;
  1894.             png_uint_32 row_width = row_info->width;
  1895.  
  1896.             dp = row;
  1897.             shift = 4;
  1898.             d = 0;
  1899.             for (i = png_pass_start[pass]; i < row_width;
  1900.                i += png_pass_inc[pass])
  1901.             {
  1902.                sp = row + (png_size_t)(i >> 1);
  1903.                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
  1904.                d |= (value << shift);
  1905.  
  1906.                if (shift == 0)
  1907.                {
  1908.                   shift = 4;
  1909.                   *dp++ = (png_byte)d;
  1910.                   d = 0;
  1911.                }
  1912.                else
  1913.                   shift -= 4;
  1914.             }
  1915.             if (shift != 4)
  1916.                *dp = (png_byte)d;
  1917.             break;
  1918.          }
  1919.          default:
  1920.          {
  1921.             png_bytep sp;
  1922.             png_bytep dp;
  1923.             png_uint_32 i;
  1924.             png_uint_32 row_width = row_info->width;
  1925.             png_size_t pixel_bytes;
  1926.  
  1927.             /* start at the beginning */
  1928.             dp = row;
  1929.             /* find out how many bytes each pixel takes up */
  1930.             pixel_bytes = (row_info->pixel_depth >> 3);
  1931.             /* loop through the row, only looking at the pixels that
  1932.                matter */
  1933.             for (i = png_pass_start[pass]; i < row_width;
  1934.                i += png_pass_inc[pass])
  1935.             {
  1936.                /* find out where the original pixel is */
  1937.                sp = row + (png_size_t)i * pixel_bytes;
  1938.                /* move the pixel */
  1939.                if (dp != sp)
  1940.                   png_memcpy(dp, sp, pixel_bytes);
  1941.                /* next pixel */
  1942.                dp += pixel_bytes;
  1943.             }
  1944.             break;
  1945.          }
  1946.       }
  1947.       /* set new row width */
  1948.       row_info->width = (row_info->width +
  1949.          png_pass_inc[pass] - 1 -
  1950.          png_pass_start[pass]) /
  1951.          png_pass_inc[pass];
  1952.          row_info->rowbytes = ((row_info->width *
  1953.             row_info->pixel_depth + 7) >> 3);
  1954.    }
  1955. }
  1956. #endif
  1957.  
  1958. /* This filters the row, chooses which filter to use, if it has not already
  1959.  * been specified by the application, and then writes the row out with the
  1960.  * chosen filter.
  1961.  */
  1962. #define PNG_MAXSUM (~((png_uint_32)0) >> 1)
  1963. #define PNG_HISHIFT 10
  1964. #define PNG_LOMASK ((png_uint_32)0xffffL)
  1965. #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
  1966. void /* PRIVATE */
  1967. png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
  1968. {
  1969.    png_bytep prev_row, best_row, row_buf;
  1970.    png_uint_32 mins, bpp;
  1971.    png_byte filter_to_do = png_ptr->do_filter;
  1972.    png_uint_32 row_bytes = row_info->rowbytes;
  1973. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  1974.    int num_p_filters = (int)png_ptr->num_prev_filters;
  1975. #endif
  1976.  
  1977.    png_debug(1, "in png_write_find_filter\n");
  1978.    /* find out how many bytes offset each pixel is */
  1979.    bpp = (row_info->pixel_depth + 7) / 8;
  1980.  
  1981.    prev_row = png_ptr->prev_row;
  1982.    best_row = row_buf = png_ptr->row_buf;
  1983.    mins = PNG_MAXSUM;
  1984.  
  1985.    /* The prediction method we use is to find which method provides the
  1986.     * smallest value when summing the absolute values of the distances
  1987.     * from zero, using anything >= 128 as negative numbers.  This is known
  1988.     * as the "minimum sum of absolute differences" heuristic.  Other
  1989.     * heuristics are the "weighted minimum sum of absolute differences"
  1990.     * (experimental and can in theory improve compression), and the "zlib
  1991.     * predictive" method (not implemented yet), which does test compressions
  1992.     * of lines using different filter methods, and then chooses the
  1993.     * (series of) filter(s) that give minimum compressed data size (VERY
  1994.     * computationally expensive).
  1995.     *
  1996.     * GRR 980525:  consider also
  1997.     *   (1) minimum sum of absolute differences from running average (i.e.,
  1998.     *       keep running sum of non-absolute differences & count of bytes)
  1999.     *       [track dispersion, too?  restart average if dispersion too large?]
  2000.     *  (1b) minimum sum of absolute differences from sliding average, probably
  2001.     *       with window size <= deflate window (usually 32K)
  2002.     *   (2) minimum sum of squared differences from zero or running average
  2003.     *       (i.e., ~ root-mean-square approach)
  2004.     */
  2005.  
  2006.  
  2007.    /* We don't need to test the 'no filter' case if this is the only filter
  2008.     * that has been chosen, as it doesn't actually do anything to the data.
  2009.     */
  2010.    if ((filter_to_do & PNG_FILTER_NONE) &&
  2011.        filter_to_do != PNG_FILTER_NONE)
  2012.    {
  2013.       png_bytep rp;
  2014.       png_uint_32 sum = 0;
  2015.       png_uint_32 i;
  2016.       int v;
  2017.  
  2018.       for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
  2019.       {
  2020.          v = *rp;
  2021.          sum += (v < 128) ? v : 256 - v;
  2022.       }
  2023.  
  2024. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2025.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2026.       {
  2027.          png_uint_32 sumhi, sumlo;
  2028.          int j;
  2029.          sumlo = sum & PNG_LOMASK;
  2030.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
  2031.  
  2032.          /* Reduce the sum if we match any of the previous rows */
  2033.          for (j = 0; j < num_p_filters; j++)
  2034.          {
  2035.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
  2036.             {
  2037.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2038.                   PNG_WEIGHT_SHIFT;
  2039.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2040.                   PNG_WEIGHT_SHIFT;
  2041.             }
  2042.          }
  2043.  
  2044.          /* Factor in the cost of this filter (this is here for completeness,
  2045.           * but it makes no sense to have a "cost" for the NONE filter, as
  2046.           * it has the minimum possible computational cost - none).
  2047.           */
  2048.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
  2049.             PNG_COST_SHIFT;
  2050.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
  2051.             PNG_COST_SHIFT;
  2052.  
  2053.          if (sumhi > PNG_HIMASK)
  2054.             sum = PNG_MAXSUM;
  2055.          else
  2056.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2057.       }
  2058. #endif
  2059.       mins = sum;
  2060.    }
  2061.  
  2062.    /* sub filter */
  2063.    if (filter_to_do == PNG_FILTER_SUB)
  2064.    /* it's the only filter so no testing is needed */
  2065.    {
  2066.       png_bytep rp, lp, dp;
  2067.       png_uint_32 i;
  2068.       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
  2069.            i++, rp++, dp++)
  2070.       {
  2071.          *dp = *rp;
  2072.       }
  2073.       for (lp = row_buf + 1; i < row_bytes;
  2074.          i++, rp++, lp++, dp++)
  2075.       {
  2076.          *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  2077.       }
  2078.       best_row = png_ptr->sub_row;
  2079.    }
  2080.  
  2081.    else if (filter_to_do & PNG_FILTER_SUB)
  2082.    {
  2083.       png_bytep rp, dp, lp;
  2084.       png_uint_32 sum = 0, lmins = mins;
  2085.       png_uint_32 i;
  2086.       int v;
  2087.  
  2088. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2089.       /* We temporarily increase the "minimum sum" by the factor we
  2090.        * would reduce the sum of this filter, so that we can do the
  2091.        * early exit comparison without scaling the sum each time.
  2092.        */
  2093.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2094.       {
  2095.          int j;
  2096.          png_uint_32 lmhi, lmlo;
  2097.          lmlo = lmins & PNG_LOMASK;
  2098.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2099.  
  2100.          for (j = 0; j < num_p_filters; j++)
  2101.          {
  2102.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
  2103.             {
  2104.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2105.                   PNG_WEIGHT_SHIFT;
  2106.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2107.                   PNG_WEIGHT_SHIFT;
  2108.             }
  2109.          }
  2110.  
  2111.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2112.             PNG_COST_SHIFT;
  2113.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2114.             PNG_COST_SHIFT;
  2115.  
  2116.          if (lmhi > PNG_HIMASK)
  2117.             lmins = PNG_MAXSUM;
  2118.          else
  2119.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2120.       }
  2121. #endif
  2122.  
  2123.       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
  2124.            i++, rp++, dp++)
  2125.       {
  2126.          v = *dp = *rp;
  2127.  
  2128.          sum += (v < 128) ? v : 256 - v;
  2129.       }
  2130.       for (lp = row_buf + 1; i < row_info->rowbytes;
  2131.          i++, rp++, lp++, dp++)
  2132.       {
  2133.          v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  2134.  
  2135.          sum += (v < 128) ? v : 256 - v;
  2136.  
  2137.          if (sum > lmins)  /* We are already worse, don't continue. */
  2138.             break;
  2139.       }
  2140.  
  2141. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2142.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2143.       {
  2144.          int j;
  2145.          png_uint_32 sumhi, sumlo;
  2146.          sumlo = sum & PNG_LOMASK;
  2147.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2148.  
  2149.          for (j = 0; j < num_p_filters; j++)
  2150.          {
  2151.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
  2152.             {
  2153.                sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
  2154.                   PNG_WEIGHT_SHIFT;
  2155.                sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
  2156.                   PNG_WEIGHT_SHIFT;
  2157.             }
  2158.          }
  2159.  
  2160.          sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2161.             PNG_COST_SHIFT;
  2162.          sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2163.             PNG_COST_SHIFT;
  2164.  
  2165.          if (sumhi > PNG_HIMASK)
  2166.             sum = PNG_MAXSUM;
  2167.          else
  2168.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2169.       }
  2170. #endif
  2171.  
  2172.       if (sum < mins)
  2173.       {
  2174.          mins = sum;
  2175.          best_row = png_ptr->sub_row;
  2176.       }
  2177.    }
  2178.  
  2179.    /* up filter */
  2180.    if (filter_to_do == PNG_FILTER_UP)
  2181.    {
  2182.       png_bytep rp, dp, pp;
  2183.       png_uint_32 i;
  2184.  
  2185.       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
  2186.            pp = prev_row + 1; i < row_bytes;
  2187.            i++, rp++, pp++, dp++)
  2188.       {
  2189.          *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
  2190.       }
  2191.       best_row = png_ptr->up_row;
  2192.    }
  2193.  
  2194.    else if (filter_to_do & PNG_FILTER_UP)
  2195.    {
  2196.       png_bytep rp, dp, pp;
  2197.       png_uint_32 sum = 0, lmins = mins;
  2198.       png_uint_32 i;
  2199.       int v;
  2200.  
  2201.  
  2202. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2203.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2204.       {
  2205.          int j;
  2206.          png_uint_32 lmhi, lmlo;
  2207.          lmlo = lmins & PNG_LOMASK;
  2208.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2209.  
  2210.          for (j = 0; j < num_p_filters; j++)
  2211.          {
  2212.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
  2213.             {
  2214.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2215.                   PNG_WEIGHT_SHIFT;
  2216.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2217.                   PNG_WEIGHT_SHIFT;
  2218.             }
  2219.          }
  2220.  
  2221.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
  2222.             PNG_COST_SHIFT;
  2223.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
  2224.             PNG_COST_SHIFT;
  2225.  
  2226.          if (lmhi > PNG_HIMASK)
  2227.             lmins = PNG_MAXSUM;
  2228.          else
  2229.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2230.       }
  2231. #endif
  2232.  
  2233.       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
  2234.            pp = prev_row + 1; i < row_bytes; i++)
  2235.       {
  2236.          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2237.  
  2238.          sum += (v < 128) ? v : 256 - v;
  2239.  
  2240.          if (sum > lmins)  /* We are already worse, don't continue. */
  2241.             break;
  2242.       }
  2243.  
  2244. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2245.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2246.       {
  2247.          int j;
  2248.          png_uint_32 sumhi, sumlo;
  2249.          sumlo = sum & PNG_LOMASK;
  2250.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2251.  
  2252.          for (j = 0; j < num_p_filters; j++)
  2253.          {
  2254.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
  2255.             {
  2256.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2257.                   PNG_WEIGHT_SHIFT;
  2258.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2259.                   PNG_WEIGHT_SHIFT;
  2260.             }
  2261.          }
  2262.  
  2263.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
  2264.             PNG_COST_SHIFT;
  2265.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
  2266.             PNG_COST_SHIFT;
  2267.  
  2268.          if (sumhi > PNG_HIMASK)
  2269.             sum = PNG_MAXSUM;
  2270.          else
  2271.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2272.       }
  2273. #endif
  2274.  
  2275.       if (sum < mins)
  2276.       {
  2277.          mins = sum;
  2278.          best_row = png_ptr->up_row;
  2279.       }
  2280.    }
  2281.  
  2282.    /* avg filter */
  2283.    if (filter_to_do == PNG_FILTER_AVG)
  2284.    {
  2285.       png_bytep rp, dp, pp, lp;
  2286.       png_uint_32 i;
  2287.       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
  2288.            pp = prev_row + 1; i < bpp; i++)
  2289.       {
  2290.          *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  2291.       }
  2292.       for (lp = row_buf + 1; i < row_bytes; i++)
  2293.       {
  2294.          *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
  2295.                  & 0xff);
  2296.       }
  2297.       best_row = png_ptr->avg_row;
  2298.    }
  2299.  
  2300.    else if (filter_to_do & PNG_FILTER_AVG)
  2301.    {
  2302.       png_bytep rp, dp, pp, lp;
  2303.       png_uint_32 sum = 0, lmins = mins;
  2304.       png_uint_32 i;
  2305.       int v;
  2306.  
  2307. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2308.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2309.       {
  2310.          int j;
  2311.          png_uint_32 lmhi, lmlo;
  2312.          lmlo = lmins & PNG_LOMASK;
  2313.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2314.  
  2315.          for (j = 0; j < num_p_filters; j++)
  2316.          {
  2317.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
  2318.             {
  2319.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2320.                   PNG_WEIGHT_SHIFT;
  2321.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2322.                   PNG_WEIGHT_SHIFT;
  2323.             }
  2324.          }
  2325.  
  2326.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2327.             PNG_COST_SHIFT;
  2328.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2329.             PNG_COST_SHIFT;
  2330.  
  2331.          if (lmhi > PNG_HIMASK)
  2332.             lmins = PNG_MAXSUM;
  2333.          else
  2334.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2335.       }
  2336. #endif
  2337.  
  2338.       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
  2339.            pp = prev_row + 1; i < bpp; i++)
  2340.       {
  2341.          v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  2342.  
  2343.          sum += (v < 128) ? v : 256 - v;
  2344.       }
  2345.       for (lp = row_buf + 1; i < row_bytes; i++)
  2346.       {
  2347.          v = *dp++ =
  2348.           (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
  2349.  
  2350.          sum += (v < 128) ? v : 256 - v;
  2351.  
  2352.          if (sum > lmins)  /* We are already worse, don't continue. */
  2353.             break;
  2354.       }
  2355.  
  2356. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2357.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2358.       {
  2359.          int j;
  2360.          png_uint_32 sumhi, sumlo;
  2361.          sumlo = sum & PNG_LOMASK;
  2362.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2363.  
  2364.          for (j = 0; j < num_p_filters; j++)
  2365.          {
  2366.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
  2367.             {
  2368.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2369.                   PNG_WEIGHT_SHIFT;
  2370.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2371.                   PNG_WEIGHT_SHIFT;
  2372.             }
  2373.          }
  2374.  
  2375.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2376.             PNG_COST_SHIFT;
  2377.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2378.             PNG_COST_SHIFT;
  2379.  
  2380.          if (sumhi > PNG_HIMASK)
  2381.             sum = PNG_MAXSUM;
  2382.          else
  2383.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2384.       }
  2385. #endif
  2386.  
  2387.       if (sum < mins)
  2388.       {
  2389.          mins = sum;
  2390.          best_row = png_ptr->avg_row;
  2391.       }
  2392.    }
  2393.  
  2394.    /* Paeth filter */
  2395.    if (filter_to_do == PNG_FILTER_PAETH)
  2396.    {
  2397.       png_bytep rp, dp, pp, cp, lp;
  2398.       png_uint_32 i;
  2399.       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
  2400.            pp = prev_row + 1; i < bpp; i++)
  2401.       {
  2402.          *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2403.       }
  2404.  
  2405.       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
  2406.       {
  2407.          int a, b, c, pa, pb, pc, p;
  2408.  
  2409.          b = *pp++;
  2410.          c = *cp++;
  2411.          a = *lp++;
  2412.  
  2413.          p = b - c;
  2414.          pc = a - c;
  2415.  
  2416. #ifdef PNG_USE_ABS
  2417.          pa = abs(p);
  2418.          pb = abs(pc);
  2419.          pc = abs(p + pc);
  2420. #else
  2421.          pa = p < 0 ? -p : p;
  2422.          pb = pc < 0 ? -pc : pc;
  2423.          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2424. #endif
  2425.  
  2426.          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2427.  
  2428.          *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2429.       }
  2430.       best_row = png_ptr->paeth_row;
  2431.    }
  2432.  
  2433.    else if (filter_to_do & PNG_FILTER_PAETH)
  2434.    {
  2435.       png_bytep rp, dp, pp, cp, lp;
  2436.       png_uint_32 sum = 0, lmins = mins;
  2437.       png_uint_32 i;
  2438.       int v;
  2439.  
  2440. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2441.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2442.       {
  2443.          int j;
  2444.          png_uint_32 lmhi, lmlo;
  2445.          lmlo = lmins & PNG_LOMASK;
  2446.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2447.  
  2448.          for (j = 0; j < num_p_filters; j++)
  2449.          {
  2450.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
  2451.             {
  2452.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2453.                   PNG_WEIGHT_SHIFT;
  2454.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2455.                   PNG_WEIGHT_SHIFT;
  2456.             }
  2457.          }
  2458.  
  2459.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2460.             PNG_COST_SHIFT;
  2461.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2462.             PNG_COST_SHIFT;
  2463.  
  2464.          if (lmhi > PNG_HIMASK)
  2465.             lmins = PNG_MAXSUM;
  2466.          else
  2467.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2468.       }
  2469. #endif
  2470.  
  2471.       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
  2472.            pp = prev_row + 1; i < bpp; i++)
  2473.       {
  2474.          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2475.  
  2476.          sum += (v < 128) ? v : 256 - v;
  2477.       }
  2478.  
  2479.       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
  2480.       {
  2481.          int a, b, c, pa, pb, pc, p;
  2482.  
  2483.          b = *pp++;
  2484.          c = *cp++;
  2485.          a = *lp++;
  2486.  
  2487. #ifndef PNG_SLOW_PAETH
  2488.          p = b - c;
  2489.          pc = a - c;
  2490. #ifdef PNG_USE_ABS
  2491.          pa = abs(p);
  2492.          pb = abs(pc);
  2493.          pc = abs(p + pc);
  2494. #else
  2495.          pa = p < 0 ? -p : p;
  2496.          pb = pc < 0 ? -pc : pc;
  2497.          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2498. #endif
  2499.          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2500. #else /* PNG_SLOW_PAETH */
  2501.          p = a + b - c;
  2502.          pa = abs(p - a);
  2503.          pb = abs(p - b);
  2504.          pc = abs(p - c);
  2505.          if (pa <= pb && pa <= pc)
  2506.             p = a;
  2507.          else if (pb <= pc)
  2508.             p = b;
  2509.          else
  2510.             p = c;
  2511. #endif /* PNG_SLOW_PAETH */
  2512.  
  2513.          v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2514.  
  2515.          sum += (v < 128) ? v : 256 - v;
  2516.  
  2517.          if (sum > lmins)  /* We are already worse, don't continue. */
  2518.             break;
  2519.       }
  2520.  
  2521. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2522.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2523.       {
  2524.          int j;
  2525.          png_uint_32 sumhi, sumlo;
  2526.          sumlo = sum & PNG_LOMASK;
  2527.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2528.  
  2529.          for (j = 0; j < num_p_filters; j++)
  2530.          {
  2531.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
  2532.             {
  2533.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2534.                   PNG_WEIGHT_SHIFT;
  2535.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2536.                   PNG_WEIGHT_SHIFT;
  2537.             }
  2538.          }
  2539.  
  2540.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2541.             PNG_COST_SHIFT;
  2542.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2543.             PNG_COST_SHIFT;
  2544.  
  2545.          if (sumhi > PNG_HIMASK)
  2546.             sum = PNG_MAXSUM;
  2547.          else
  2548.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2549.       }
  2550. #endif
  2551.  
  2552.       if (sum < mins)
  2553.       {
  2554.          best_row = png_ptr->paeth_row;
  2555.       }
  2556.    }
  2557.  
  2558.    /* Do the actual writing of the filtered row data from the chosen filter. */
  2559.  
  2560.    png_write_filtered_row(png_ptr, best_row);
  2561.  
  2562. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  2563.    /* Save the type of filter we picked this time for future calculations */
  2564.    if (png_ptr->num_prev_filters > 0)
  2565.    {
  2566.       int j;
  2567.       for (j = 1; j < num_p_filters; j++)
  2568.       {
  2569.          png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
  2570.       }
  2571.       png_ptr->prev_filters[j] = best_row[0];
  2572.    }
  2573. #endif
  2574. }
  2575.  
  2576.  
  2577. /* Do the actual writing of a previously filtered row. */
  2578. void /* PRIVATE */
  2579. png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
  2580. {
  2581.    png_debug(1, "in png_write_filtered_row\n");
  2582.    png_debug1(2, "filter = %d\n", filtered_row[0]);
  2583.    /* set up the zlib input buffer */
  2584.  
  2585.    png_ptr->zstream.next_in = filtered_row;
  2586.    png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;
  2587.    /* repeat until we have compressed all the data */
  2588.    do
  2589.    {
  2590.       int ret; /* return of zlib */
  2591.  
  2592.       /* compress the data */
  2593.       ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);
  2594.       /* check for compression errors */
  2595.       if (ret != Z_OK)
  2596.       {
  2597.          if (png_ptr->zstream.msg != NULL)
  2598.             png_error(png_ptr, png_ptr->zstream.msg);
  2599.          else
  2600.             png_error(png_ptr, "zlib error");
  2601.       }
  2602.  
  2603.       /* see if it is time to write another IDAT */
  2604.       if (!(png_ptr->zstream.avail_out))
  2605.       {
  2606.          /* write the IDAT and reset the zlib output buffer */
  2607.          png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
  2608.          png_ptr->zstream.next_out = png_ptr->zbuf;
  2609.          png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  2610.       }
  2611.    /* repeat until all data has been compressed */
  2612.    } while (png_ptr->zstream.avail_in);
  2613.  
  2614.    /* swap the current and previous rows */
  2615.    if (png_ptr->prev_row != NULL)
  2616.    {
  2617.       png_bytep tptr;
  2618.  
  2619.       tptr = png_ptr->prev_row;
  2620.       png_ptr->prev_row = png_ptr->row_buf;
  2621.       png_ptr->row_buf = tptr;
  2622.    }
  2623.  
  2624.    /* finish row - updates counters and flushes zlib if last row */
  2625.    png_write_finish_row(png_ptr);
  2626.  
  2627. #if defined(PNG_WRITE_FLUSH_SUPPORTED)
  2628.    png_ptr->flush_rows++;
  2629.  
  2630.    if (png_ptr->flush_dist > 0 &&
  2631.        png_ptr->flush_rows >= png_ptr->flush_dist)
  2632.    {
  2633.       png_write_flush(png_ptr);
  2634.    }
  2635. #endif
  2636. }
  2637. #endif /* PNG_WRITE_SUPPORTED */
  2638.