Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1.  
  2. /* pngwutil.c - utilities to write a PNG file
  3.  *
  4.  * Last changed in libpng 1.6.2 [April 25, 2013]
  5.  * Copyright (c) 1998-2013 Glenn Randers-Pehrson
  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  7.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  8.  *
  9.  * This code is released under the libpng license.
  10.  * For conditions of distribution and use, see the disclaimer
  11.  * and license in png.h
  12.  */
  13.  
  14. #include "pngpriv.h"
  15.  
  16. #ifdef PNG_WRITE_SUPPORTED
  17.  
  18. #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
  19. /* Place a 32-bit number into a buffer in PNG byte order.  We work
  20.  * with unsigned numbers for convenience, although one supported
  21.  * ancillary chunk uses signed (two's complement) numbers.
  22.  */
  23. void PNGAPI
  24. png_save_uint_32(png_bytep buf, png_uint_32 i)
  25. {
  26.    buf[0] = (png_byte)((i >> 24) & 0xff);
  27.    buf[1] = (png_byte)((i >> 16) & 0xff);
  28.    buf[2] = (png_byte)((i >> 8) & 0xff);
  29.    buf[3] = (png_byte)(i & 0xff);
  30. }
  31.  
  32. /* Place a 16-bit number into a buffer in PNG byte order.
  33.  * The parameter is declared unsigned int, not png_uint_16,
  34.  * just to avoid potential problems on pre-ANSI C compilers.
  35.  */
  36. void PNGAPI
  37. png_save_uint_16(png_bytep buf, unsigned int i)
  38. {
  39.    buf[0] = (png_byte)((i >> 8) & 0xff);
  40.    buf[1] = (png_byte)(i & 0xff);
  41. }
  42. #endif
  43.  
  44. /* Simple function to write the signature.  If we have already written
  45.  * the magic bytes of the signature, or more likely, the PNG stream is
  46.  * being embedded into another stream and doesn't need its own signature,
  47.  * we should call png_set_sig_bytes() to tell libpng how many of the
  48.  * bytes have already been written.
  49.  */
  50. void PNGAPI
  51. png_write_sig(png_structrp png_ptr)
  52. {
  53.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  54.  
  55. #ifdef PNG_IO_STATE_SUPPORTED
  56.    /* Inform the I/O callback that the signature is being written */
  57.    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
  58. #endif
  59.  
  60.    /* Write the rest of the 8 byte signature */
  61.    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
  62.       (png_size_t)(8 - png_ptr->sig_bytes));
  63.  
  64.    if (png_ptr->sig_bytes < 3)
  65.       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
  66. }
  67.  
  68. /* Write the start of a PNG chunk.  The type is the chunk type.
  69.  * The total_length is the sum of the lengths of all the data you will be
  70.  * passing in png_write_chunk_data().
  71.  */
  72. static void
  73. png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,
  74.     png_uint_32 length)
  75. {
  76.    png_byte buf[8];
  77.  
  78. #if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
  79.    PNG_CSTRING_FROM_CHUNK(buf, chunk_name);
  80.    png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);
  81. #endif
  82.  
  83.    if (png_ptr == NULL)
  84.       return;
  85.  
  86. #ifdef PNG_IO_STATE_SUPPORTED
  87.    /* Inform the I/O callback that the chunk header is being written.
  88.     * PNG_IO_CHUNK_HDR requires a single I/O call.
  89.     */
  90.    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
  91. #endif
  92.  
  93.    /* Write the length and the chunk name */
  94.    png_save_uint_32(buf, length);
  95.    png_save_uint_32(buf + 4, chunk_name);
  96.    png_write_data(png_ptr, buf, 8);
  97.  
  98.    /* Put the chunk name into png_ptr->chunk_name */
  99.    png_ptr->chunk_name = chunk_name;
  100.  
  101.    /* Reset the crc and run it over the chunk name */
  102.    png_reset_crc(png_ptr);
  103.  
  104.    png_calculate_crc(png_ptr, buf + 4, 4);
  105.  
  106. #ifdef PNG_IO_STATE_SUPPORTED
  107.    /* Inform the I/O callback that chunk data will (possibly) be written.
  108.     * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
  109.     */
  110.    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
  111. #endif
  112. }
  113.  
  114. void PNGAPI
  115. png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
  116.     png_uint_32 length)
  117. {
  118.    png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
  119. }
  120.  
  121. /* Write the data of a PNG chunk started with png_write_chunk_header().
  122.  * Note that multiple calls to this function are allowed, and that the
  123.  * sum of the lengths from these calls *must* add up to the total_length
  124.  * given to png_write_chunk_header().
  125.  */
  126. void PNGAPI
  127. png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
  128.     png_size_t length)
  129. {
  130.    /* Write the data, and run the CRC over it */
  131.    if (png_ptr == NULL)
  132.       return;
  133.  
  134.    if (data != NULL && length > 0)
  135.    {
  136.       png_write_data(png_ptr, data, length);
  137.  
  138.       /* Update the CRC after writing the data,
  139.        * in case that the user I/O routine alters it.
  140.        */
  141.       png_calculate_crc(png_ptr, data, length);
  142.    }
  143. }
  144.  
  145. /* Finish a chunk started with png_write_chunk_header(). */
  146. void PNGAPI
  147. png_write_chunk_end(png_structrp png_ptr)
  148. {
  149.    png_byte buf[4];
  150.  
  151.    if (png_ptr == NULL) return;
  152.  
  153. #ifdef PNG_IO_STATE_SUPPORTED
  154.    /* Inform the I/O callback that the chunk CRC is being written.
  155.     * PNG_IO_CHUNK_CRC requires a single I/O function call.
  156.     */
  157.    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
  158. #endif
  159.  
  160.    /* Write the crc in a single operation */
  161.    png_save_uint_32(buf, png_ptr->crc);
  162.  
  163.    png_write_data(png_ptr, buf, (png_size_t)4);
  164. }
  165.  
  166. /* Write a PNG chunk all at once.  The type is an array of ASCII characters
  167.  * representing the chunk name.  The array must be at least 4 bytes in
  168.  * length, and does not need to be null terminated.  To be safe, pass the
  169.  * pre-defined chunk names here, and if you need a new one, define it
  170.  * where the others are defined.  The length is the length of the data.
  171.  * All the data must be present.  If that is not possible, use the
  172.  * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
  173.  * functions instead.
  174.  */
  175. static void
  176. png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
  177.    png_const_bytep data, png_size_t length)
  178. {
  179.    if (png_ptr == NULL)
  180.       return;
  181.  
  182.    /* On 64 bit architectures 'length' may not fit in a png_uint_32. */
  183.    if (length > PNG_UINT_31_MAX)
  184.       png_error(png_ptr, "length exceeds PNG maxima");
  185.  
  186.    png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length);
  187.    png_write_chunk_data(png_ptr, data, length);
  188.    png_write_chunk_end(png_ptr);
  189. }
  190.  
  191. /* This is the API that calls the internal function above. */
  192. void PNGAPI
  193. png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
  194.    png_const_bytep data, png_size_t length)
  195. {
  196.    png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
  197.       length);
  198. }
  199.  
  200. /* This is used below to find the size of an image to pass to png_deflate_claim,
  201.  * so it only needs to be accurate if the size is less than 16384 bytes (the
  202.  * point at which a lower LZ window size can be used.)
  203.  */
  204. static png_alloc_size_t
  205. png_image_size(png_structrp png_ptr)
  206. {
  207.    /* Only return sizes up to the maximum of a png_uint_32, do this by limiting
  208.     * the width and height used to 15 bits.
  209.     */
  210.    png_uint_32 h = png_ptr->height;
  211.  
  212.    if (png_ptr->rowbytes < 32768 && h < 32768)
  213.    {
  214.       if (png_ptr->interlaced)
  215.       {
  216.          /* Interlacing makes the image larger because of the replication of
  217.           * both the filter byte and the padding to a byte boundary.
  218.           */
  219.          png_uint_32 w = png_ptr->width;
  220.          unsigned int pd = png_ptr->pixel_depth;
  221.          png_alloc_size_t cb_base;
  222.          int pass;
  223.  
  224.          for (cb_base=0, pass=0; pass<=6; ++pass)
  225.          {
  226.             png_uint_32 pw = PNG_PASS_COLS(w, pass);
  227.  
  228.             if (pw > 0)
  229.                cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass);
  230.          }
  231.  
  232.          return cb_base;
  233.       }
  234.  
  235.       else
  236.          return (png_ptr->rowbytes+1) * h;
  237.    }
  238.  
  239.    else
  240.       return 0xffffffffU;
  241. }
  242.  
  243. #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  244.    /* This is the code to hack the first two bytes of the deflate stream (the
  245.     * deflate header) to correct the windowBits value to match the actual data
  246.     * size.  Note that the second argument is the *uncompressed* size but the
  247.     * first argument is the *compressed* data (and it must be deflate
  248.     * compressed.)
  249.     */
  250. static void
  251. optimize_cmf(png_bytep data, png_alloc_size_t data_size)
  252. {
  253.    /* Optimize the CMF field in the zlib stream.  The resultant zlib stream is
  254.     * still compliant to the stream specification.
  255.     */
  256.    if (data_size <= 16384) /* else windowBits must be 15 */
  257.    {
  258.       unsigned int z_cmf = data[0];  /* zlib compression method and flags */
  259.  
  260.       if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
  261.       {
  262.          unsigned int z_cinfo;
  263.          unsigned int half_z_window_size;
  264.  
  265.          z_cinfo = z_cmf >> 4;
  266.          half_z_window_size = 1U << (z_cinfo + 7);
  267.  
  268.          if (data_size <= half_z_window_size) /* else no change */
  269.          {
  270.             unsigned int tmp;
  271.  
  272.             do
  273.             {
  274.                half_z_window_size >>= 1;
  275.                --z_cinfo;
  276.             }
  277.             while (z_cinfo > 0 && data_size <= half_z_window_size);
  278.  
  279.             z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
  280.  
  281.             data[0] = (png_byte)z_cmf;
  282.             tmp = data[1] & 0xe0;
  283.             tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
  284.             data[1] = (png_byte)tmp;
  285.          }
  286.       }
  287.    }
  288. }
  289. #else
  290. #  define optimize_cmf(dp,dl) ((void)0)
  291. #endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
  292.  
  293. /* Initialize the compressor for the appropriate type of compression. */
  294. static int
  295. png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
  296.    png_alloc_size_t data_size)
  297. {
  298.    if (png_ptr->zowner != 0)
  299.    {
  300.       char msg[64];
  301.  
  302.       PNG_STRING_FROM_CHUNK(msg, owner);
  303.       msg[4] = ':';
  304.       msg[5] = ' ';
  305.       PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);
  306.       /* So the message that results is "<chunk> using zstream"; this is an
  307.        * internal error, but is very useful for debugging.  i18n requirements
  308.        * are minimal.
  309.        */
  310.       (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
  311. #     if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
  312.          png_warning(png_ptr, msg);
  313.  
  314.          /* Attempt sane error recovery */
  315.          if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */
  316.          {
  317.             png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");
  318.             return Z_STREAM_ERROR;
  319.          }
  320.  
  321.          png_ptr->zowner = 0;
  322. #     else
  323.          png_error(png_ptr, msg);
  324. #     endif
  325.    }
  326.  
  327.    {
  328.       int level = png_ptr->zlib_level;
  329.       int method = png_ptr->zlib_method;
  330.       int windowBits = png_ptr->zlib_window_bits;
  331.       int memLevel = png_ptr->zlib_mem_level;
  332.       int strategy; /* set below */
  333.       int ret; /* zlib return code */
  334.  
  335.       if (owner == png_IDAT)
  336.       {
  337.          if (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)
  338.             strategy = png_ptr->zlib_strategy;
  339.  
  340.          else if (png_ptr->do_filter != PNG_FILTER_NONE)
  341.             strategy = PNG_Z_DEFAULT_STRATEGY;
  342.  
  343.          else
  344.             strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
  345.       }
  346.  
  347.       else
  348.       {
  349. #        ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
  350.             level = png_ptr->zlib_text_level;
  351.             method = png_ptr->zlib_text_method;
  352.             windowBits = png_ptr->zlib_text_window_bits;
  353.             memLevel = png_ptr->zlib_text_mem_level;
  354.             strategy = png_ptr->zlib_text_strategy;
  355. #        else
  356.             /* If customization is not supported the values all come from the
  357.              * IDAT values except for the strategy, which is fixed to the
  358.              * default.  (This is the pre-1.6.0 behavior too, although it was
  359.              * implemented in a very different way.)
  360.              */
  361.             strategy = Z_DEFAULT_STRATEGY;
  362. #        endif
  363.       }
  364.  
  365.       /* Adjust 'windowBits' down if larger than 'data_size'; to stop this
  366.        * happening just pass 32768 as the data_size parameter.  Notice that zlib
  367.        * requires an extra 262 bytes in the window in addition to the data to be
  368.        * able to see the whole of the data, so if data_size+262 takes us to the
  369.        * next windowBits size we need to fix up the value later.  (Because even
  370.        * though deflate needs the extra window, inflate does not!)
  371.        */
  372.       if (data_size <= 16384)
  373.       {
  374.          /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to
  375.           * work round a Microsoft Visual C misbehavior which, contrary to C-90,
  376.           * widens the result of the following shift to 64-bits if (and,
  377.           * apparently, only if) it is used in a test.
  378.           */
  379.          unsigned int half_window_size = 1U << (windowBits-1);
  380.  
  381.          while (data_size + 262 <= half_window_size)
  382.          {
  383.             half_window_size >>= 1;
  384.             --windowBits;
  385.          }
  386.       }
  387.  
  388.       /* Check against the previous initialized values, if any. */
  389.       if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) &&
  390.          (png_ptr->zlib_set_level != level ||
  391.          png_ptr->zlib_set_method != method ||
  392.          png_ptr->zlib_set_window_bits != windowBits ||
  393.          png_ptr->zlib_set_mem_level != memLevel ||
  394.          png_ptr->zlib_set_strategy != strategy))
  395.       {
  396.          if (deflateEnd(&png_ptr->zstream) != Z_OK)
  397.             png_warning(png_ptr, "deflateEnd failed (ignored)");
  398.  
  399.          png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;
  400.       }
  401.  
  402.       /* For safety clear out the input and output pointers (currently zlib
  403.        * doesn't use them on Init, but it might in the future).
  404.        */
  405.       png_ptr->zstream.next_in = NULL;
  406.       png_ptr->zstream.avail_in = 0;
  407.       png_ptr->zstream.next_out = NULL;
  408.       png_ptr->zstream.avail_out = 0;
  409.  
  410.       /* Now initialize if required, setting the new parameters, otherwise just
  411.        * to a simple reset to the previous parameters.
  412.        */
  413.       if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)
  414.          ret = deflateReset(&png_ptr->zstream);
  415.  
  416.       else
  417.       {
  418.          ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
  419.             memLevel, strategy);
  420.  
  421.          if (ret == Z_OK)
  422.             png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
  423.       }
  424.  
  425.       /* The return code is from either deflateReset or deflateInit2; they have
  426.        * pretty much the same set of error codes.
  427.        */
  428.       if (ret == Z_OK)
  429.          png_ptr->zowner = owner;
  430.  
  431.       else
  432.          png_zstream_error(png_ptr, ret);
  433.  
  434.       return ret;
  435.    }
  436. }
  437.  
  438. /* Clean up (or trim) a linked list of compression buffers. */
  439. void /* PRIVATE */
  440. png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)
  441. {
  442.    png_compression_bufferp list = *listp;
  443.  
  444.    if (list != NULL)
  445.    {
  446.       *listp = NULL;
  447.  
  448.       do
  449.       {
  450.          png_compression_bufferp next = list->next;
  451.  
  452.          png_free(png_ptr, list);
  453.          list = next;
  454.       }
  455.       while (list != NULL);
  456.    }
  457. }
  458.  
  459. #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
  460. /* This pair of functions encapsulates the operation of (a) compressing a
  461.  * text string, and (b) issuing it later as a series of chunk data writes.
  462.  * The compression_state structure is shared context for these functions
  463.  * set up by the caller to allow access to the relevant local variables.
  464.  *
  465.  * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size
  466.  * temporary buffers.  From 1.6.0 it is retained in png_struct so that it will
  467.  * be correctly freed in the event of a write error (previous implementations
  468.  * just leaked memory.)
  469.  */
  470. typedef struct
  471. {
  472.    png_const_bytep      input;        /* The uncompressed input data */
  473.    png_alloc_size_t     input_len;    /* Its length */
  474.    png_uint_32          output_len;   /* Final compressed length */
  475.    png_byte             output[1024]; /* First block of output */
  476. } compression_state;
  477.  
  478. static void
  479. png_text_compress_init(compression_state *comp, png_const_bytep input,
  480.    png_alloc_size_t input_len)
  481. {
  482.    comp->input = input;
  483.    comp->input_len = input_len;
  484.    comp->output_len = 0;
  485. }
  486.  
  487. /* Compress the data in the compression state input */
  488. static int
  489. png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
  490.    compression_state *comp, png_uint_32 prefix_len)
  491. {
  492.    int ret;
  493.  
  494.    /* To find the length of the output it is necessary to first compress the
  495.     * input, the result is buffered rather than using the two-pass algorithm
  496.     * that is used on the inflate side; deflate is assumed to be slower and a
  497.     * PNG writer is assumed to have more memory available than a PNG reader.
  498.     *
  499.     * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an
  500.     * upper limit on the output size, but it is always bigger than the input
  501.     * size so it is likely to be more efficient to use this linked-list
  502.     * approach.
  503.     */
  504.    ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
  505.  
  506.    if (ret != Z_OK)
  507.       return ret;
  508.  
  509.    /* Set up the compression buffers, we need a loop here to avoid overflowing a
  510.     * uInt.  Use ZLIB_IO_MAX to limit the input.  The output is always limited
  511.     * by the output buffer size, so there is no need to check that.  Since this
  512.     * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits
  513.     * in size.
  514.     */
  515.    {
  516.       png_compression_bufferp *end = &png_ptr->zbuffer_list;
  517.       png_alloc_size_t input_len = comp->input_len; /* may be zero! */
  518.       png_uint_32 output_len;
  519.  
  520.       /* zlib updates these for us: */
  521.       png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);
  522.       png_ptr->zstream.avail_in = 0; /* Set below */
  523.       png_ptr->zstream.next_out = comp->output;
  524.       png_ptr->zstream.avail_out = (sizeof comp->output);
  525.  
  526.       output_len = png_ptr->zstream.avail_out;
  527.  
  528.       do
  529.       {
  530.          uInt avail_in = ZLIB_IO_MAX;
  531.  
  532.          if (avail_in > input_len)
  533.             avail_in = (uInt)input_len;
  534.  
  535.          input_len -= avail_in;
  536.  
  537.          png_ptr->zstream.avail_in = avail_in;
  538.  
  539.          if (png_ptr->zstream.avail_out == 0)
  540.          {
  541.             png_compression_buffer *next;
  542.  
  543.             /* Chunk data is limited to 2^31 bytes in length, so the prefix
  544.              * length must be counted here.
  545.              */
  546.             if (output_len + prefix_len > PNG_UINT_31_MAX)
  547.             {
  548.                ret = Z_MEM_ERROR;
  549.                break;
  550.             }
  551.  
  552.             /* Need a new (malloc'ed) buffer, but there may be one present
  553.              * already.
  554.              */
  555.             next = *end;
  556.             if (next == NULL)
  557.             {
  558.                next = png_voidcast(png_compression_bufferp, png_malloc_base
  559.                   (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
  560.  
  561.                if (next == NULL)
  562.                {
  563.                   ret = Z_MEM_ERROR;
  564.                   break;
  565.                }
  566.  
  567.                /* Link in this buffer (so that it will be freed later) */
  568.                next->next = NULL;
  569.                *end = next;
  570.             }
  571.  
  572.             png_ptr->zstream.next_out = next->output;
  573.             png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
  574.             output_len += png_ptr->zstream.avail_out;
  575.  
  576.             /* Move 'end' to the next buffer pointer. */
  577.             end = &next->next;
  578.          }
  579.  
  580.          /* Compress the data */
  581.          ret = deflate(&png_ptr->zstream,
  582.             input_len > 0 ? Z_NO_FLUSH : Z_FINISH);
  583.  
  584.          /* Claw back input data that was not consumed (because avail_in is
  585.           * reset above every time round the loop).
  586.           */
  587.          input_len += png_ptr->zstream.avail_in;
  588.          png_ptr->zstream.avail_in = 0; /* safety */
  589.       }
  590.       while (ret == Z_OK);
  591.  
  592.       /* There may be some space left in the last output buffer, this needs to
  593.        * be subtracted from output_len.
  594.        */
  595.       output_len -= png_ptr->zstream.avail_out;
  596.       png_ptr->zstream.avail_out = 0; /* safety */
  597.       comp->output_len = output_len;
  598.  
  599.       /* Now double check the output length, put in a custom message if it is
  600.        * too long.  Otherwise ensure the z_stream::msg pointer is set to
  601.        * something.
  602.        */
  603.       if (output_len + prefix_len >= PNG_UINT_31_MAX)
  604.       {
  605.          png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
  606.          ret = Z_MEM_ERROR;
  607.       }
  608.  
  609.       else
  610.          png_zstream_error(png_ptr, ret);
  611.  
  612.       /* Reset zlib for another zTXt/iTXt or image data */
  613.       png_ptr->zowner = 0;
  614.  
  615.       /* The only success case is Z_STREAM_END, input_len must be 0, if not this
  616.        * is an internal error.
  617.        */
  618.       if (ret == Z_STREAM_END && input_len == 0)
  619.       {
  620.          /* Fix up the deflate header, if required */
  621.          optimize_cmf(comp->output, comp->input_len);
  622.  
  623.          /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
  624.           * function above to return Z_STREAM_END on an error (though it never
  625.           * does in the current versions of zlib.)
  626.           */
  627.          return Z_OK;
  628.       }
  629.  
  630.       else
  631.          return ret;
  632.    }
  633. }
  634.  
  635. /* Ship the compressed text out via chunk writes */
  636. static void
  637. png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
  638. {
  639.    png_uint_32 output_len = comp->output_len;
  640.    png_const_bytep output = comp->output;
  641.    png_uint_32 avail = (sizeof comp->output);
  642.    png_compression_buffer *next = png_ptr->zbuffer_list;
  643.  
  644.    for (;;)
  645.    {
  646.       if (avail > output_len)
  647.          avail = output_len;
  648.  
  649.       png_write_chunk_data(png_ptr, output, avail);
  650.  
  651.       output_len -= avail;
  652.  
  653.       if (output_len == 0 || next == NULL)
  654.          break;
  655.  
  656.       avail = png_ptr->zbuffer_size;
  657.       output = next->output;
  658.       next = next->next;
  659.    }
  660.  
  661.    /* This is an internal error; 'next' must have been NULL! */
  662.    if (output_len > 0)
  663.       png_error(png_ptr, "error writing ancillary chunked compressed data");
  664. }
  665. #endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */
  666.  
  667. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
  668.     defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
  669. /* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,
  670.  * and if invalid, correct the keyword rather than discarding the entire
  671.  * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in
  672.  * length, forbids leading or trailing whitespace, multiple internal spaces,
  673.  * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.
  674.  *
  675.  * The 'new_key' buffer must be 80 characters in size (for the keyword plus a
  676.  * trailing '\0').  If this routine returns 0 then there was no keyword, or a
  677.  * valid one could not be generated, and the caller must png_error.
  678.  */
  679. static png_uint_32
  680. png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
  681. {
  682.    png_const_charp orig_key = key;
  683.    png_uint_32 key_len = 0;
  684.    int bad_character = 0;
  685.    int space = 1;
  686.  
  687.    png_debug(1, "in png_check_keyword");
  688.  
  689.    if (key == NULL)
  690.    {
  691.       *new_key = 0;
  692.       return 0;
  693.    }
  694.  
  695.    while (*key && key_len < 79)
  696.    {
  697.       png_byte ch = (png_byte)(0xff & *key++);
  698.  
  699.       if ((ch > 32 && ch <= 126) || (ch >= 161 /*&& ch <= 255*/))
  700.          *new_key++ = ch, ++key_len, space = 0;
  701.  
  702.       else if (!space)
  703.       {
  704.          /* A space or an invalid character when one wasn't seen immediately
  705.           * before; output just a space.
  706.           */
  707.          *new_key++ = 32, ++key_len, space = 1;
  708.  
  709.          /* If the character was not a space then it is invalid. */
  710.          if (ch != 32)
  711.             bad_character = ch;
  712.       }
  713.  
  714.       else if (!bad_character)
  715.          bad_character = ch; /* just skip it, record the first error */
  716.    }
  717.  
  718.    if (key_len > 0 && space) /* trailing space */
  719.    {
  720.       --key_len, --new_key;
  721.       if (!bad_character)
  722.          bad_character = 32;
  723.    }
  724.  
  725.    /* Terminate the keyword */
  726.    *new_key = 0;
  727.  
  728.    if (key_len == 0)
  729.       return 0;
  730.  
  731.    /* Try to only output one warning per keyword: */
  732.    if (*key) /* keyword too long */
  733.       png_warning(png_ptr, "keyword truncated");
  734.  
  735.    else if (bad_character)
  736.    {
  737.       PNG_WARNING_PARAMETERS(p)
  738.  
  739.       png_warning_parameter(p, 1, orig_key);
  740.       png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_02x, bad_character);
  741.  
  742.       png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
  743.    }
  744.  
  745.    return key_len;
  746. }
  747. #endif
  748.  
  749. /* Write the IHDR chunk, and update the png_struct with the necessary
  750.  * information.  Note that the rest of this code depends upon this
  751.  * information being correct.
  752.  */
  753. void /* PRIVATE */
  754. png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
  755.     int bit_depth, int color_type, int compression_type, int filter_type,
  756.     int interlace_type)
  757. {
  758.    png_byte buf[13]; /* Buffer to store the IHDR info */
  759.  
  760.    png_debug(1, "in png_write_IHDR");
  761.  
  762.    /* Check that we have valid input data from the application info */
  763.    switch (color_type)
  764.    {
  765.       case PNG_COLOR_TYPE_GRAY:
  766.          switch (bit_depth)
  767.          {
  768.             case 1:
  769.             case 2:
  770.             case 4:
  771.             case 8:
  772. #ifdef PNG_WRITE_16BIT_SUPPORTED
  773.             case 16:
  774. #endif
  775.                png_ptr->channels = 1; break;
  776.  
  777.             default:
  778.                png_error(png_ptr,
  779.                    "Invalid bit depth for grayscale image");
  780.          }
  781.          break;
  782.  
  783.       case PNG_COLOR_TYPE_RGB:
  784. #ifdef PNG_WRITE_16BIT_SUPPORTED
  785.          if (bit_depth != 8 && bit_depth != 16)
  786. #else
  787.          if (bit_depth != 8)
  788. #endif
  789.             png_error(png_ptr, "Invalid bit depth for RGB image");
  790.  
  791.          png_ptr->channels = 3;
  792.          break;
  793.  
  794.       case PNG_COLOR_TYPE_PALETTE:
  795.          switch (bit_depth)
  796.          {
  797.             case 1:
  798.             case 2:
  799.             case 4:
  800.             case 8:
  801.                png_ptr->channels = 1;
  802.                break;
  803.  
  804.             default:
  805.                png_error(png_ptr, "Invalid bit depth for paletted image");
  806.          }
  807.          break;
  808.  
  809.       case PNG_COLOR_TYPE_GRAY_ALPHA:
  810.          if (bit_depth != 8 && bit_depth != 16)
  811.             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
  812.  
  813.          png_ptr->channels = 2;
  814.          break;
  815.  
  816.       case PNG_COLOR_TYPE_RGB_ALPHA:
  817. #ifdef PNG_WRITE_16BIT_SUPPORTED
  818.          if (bit_depth != 8 && bit_depth != 16)
  819. #else
  820.          if (bit_depth != 8)
  821. #endif
  822.             png_error(png_ptr, "Invalid bit depth for RGBA image");
  823.  
  824.          png_ptr->channels = 4;
  825.          break;
  826.  
  827.       default:
  828.          png_error(png_ptr, "Invalid image color type specified");
  829.    }
  830.  
  831.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  832.    {
  833.       png_warning(png_ptr, "Invalid compression type specified");
  834.       compression_type = PNG_COMPRESSION_TYPE_BASE;
  835.    }
  836.  
  837.    /* Write filter_method 64 (intrapixel differencing) only if
  838.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  839.     * 2. Libpng did not write a PNG signature (this filter_method is only
  840.     *    used in PNG datastreams that are embedded in MNG datastreams) and
  841.     * 3. The application called png_permit_mng_features with a mask that
  842.     *    included PNG_FLAG_MNG_FILTER_64 and
  843.     * 4. The filter_method is 64 and
  844.     * 5. The color_type is RGB or RGBA
  845.     */
  846.    if (
  847. #ifdef PNG_MNG_FEATURES_SUPPORTED
  848.        !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  849.        ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
  850.        (color_type == PNG_COLOR_TYPE_RGB ||
  851.         color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
  852.        (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
  853. #endif
  854.        filter_type != PNG_FILTER_TYPE_BASE)
  855.    {
  856.       png_warning(png_ptr, "Invalid filter type specified");
  857.       filter_type = PNG_FILTER_TYPE_BASE;
  858.    }
  859.  
  860. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  861.    if (interlace_type != PNG_INTERLACE_NONE &&
  862.        interlace_type != PNG_INTERLACE_ADAM7)
  863.    {
  864.       png_warning(png_ptr, "Invalid interlace type specified");
  865.       interlace_type = PNG_INTERLACE_ADAM7;
  866.    }
  867. #else
  868.    interlace_type=PNG_INTERLACE_NONE;
  869. #endif
  870.  
  871.    /* Save the relevent information */
  872.    png_ptr->bit_depth = (png_byte)bit_depth;
  873.    png_ptr->color_type = (png_byte)color_type;
  874.    png_ptr->interlaced = (png_byte)interlace_type;
  875. #ifdef PNG_MNG_FEATURES_SUPPORTED
  876.    png_ptr->filter_type = (png_byte)filter_type;
  877. #endif
  878.    png_ptr->compression_type = (png_byte)compression_type;
  879.    png_ptr->width = width;
  880.    png_ptr->height = height;
  881.  
  882.    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
  883.    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
  884.    /* Set the usr info, so any transformations can modify it */
  885.    png_ptr->usr_width = png_ptr->width;
  886.    png_ptr->usr_bit_depth = png_ptr->bit_depth;
  887.    png_ptr->usr_channels = png_ptr->channels;
  888.  
  889.    /* Pack the header information into the buffer */
  890.    png_save_uint_32(buf, width);
  891.    png_save_uint_32(buf + 4, height);
  892.    buf[8] = (png_byte)bit_depth;
  893.    buf[9] = (png_byte)color_type;
  894.    buf[10] = (png_byte)compression_type;
  895.    buf[11] = (png_byte)filter_type;
  896.    buf[12] = (png_byte)interlace_type;
  897.  
  898.    /* Write the chunk */
  899.    png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
  900.  
  901.    if (!(png_ptr->do_filter))
  902.    {
  903.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
  904.           png_ptr->bit_depth < 8)
  905.          png_ptr->do_filter = PNG_FILTER_NONE;
  906.  
  907.       else
  908.          png_ptr->do_filter = PNG_ALL_FILTERS;
  909.    }
  910.  
  911.    png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
  912. }
  913.  
  914. /* Write the palette.  We are careful not to trust png_color to be in the
  915.  * correct order for PNG, so people can redefine it to any convenient
  916.  * structure.
  917.  */
  918. void /* PRIVATE */
  919. png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
  920.     png_uint_32 num_pal)
  921. {
  922.    png_uint_32 i;
  923.    png_const_colorp pal_ptr;
  924.    png_byte buf[3];
  925.  
  926.    png_debug(1, "in png_write_PLTE");
  927.  
  928.    if ((
  929. #ifdef PNG_MNG_FEATURES_SUPPORTED
  930.        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
  931. #endif
  932.        num_pal == 0) || num_pal > 256)
  933.    {
  934.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  935.       {
  936.          png_error(png_ptr, "Invalid number of colors in palette");
  937.       }
  938.  
  939.       else
  940.       {
  941.          png_warning(png_ptr, "Invalid number of colors in palette");
  942.          return;
  943.       }
  944.    }
  945.  
  946.    if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))
  947.    {
  948.       png_warning(png_ptr,
  949.           "Ignoring request to write a PLTE chunk in grayscale PNG");
  950.  
  951.       return;
  952.    }
  953.  
  954.    png_ptr->num_palette = (png_uint_16)num_pal;
  955.    png_debug1(3, "num_palette = %d", png_ptr->num_palette);
  956.  
  957.    png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
  958. #ifdef PNG_POINTER_INDEXING_SUPPORTED
  959.  
  960.    for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
  961.    {
  962.       buf[0] = pal_ptr->red;
  963.       buf[1] = pal_ptr->green;
  964.       buf[2] = pal_ptr->blue;
  965.       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
  966.    }
  967.  
  968. #else
  969.    /* This is a little slower but some buggy compilers need to do this
  970.     * instead
  971.     */
  972.    pal_ptr=palette;
  973.  
  974.    for (i = 0; i < num_pal; i++)
  975.    {
  976.       buf[0] = pal_ptr[i].red;
  977.       buf[1] = pal_ptr[i].green;
  978.       buf[2] = pal_ptr[i].blue;
  979.       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
  980.    }
  981.  
  982. #endif
  983.    png_write_chunk_end(png_ptr);
  984.    png_ptr->mode |= PNG_HAVE_PLTE;
  985. }
  986.  
  987. /* This is similar to png_text_compress, above, except that it does not require
  988.  * all of the data at once and, instead of buffering the compressed result,
  989.  * writes it as IDAT chunks.  Unlike png_text_compress it *can* png_error out
  990.  * because it calls the write interface.  As a result it does its own error
  991.  * reporting and does not return an error code.  In the event of error it will
  992.  * just call png_error.  The input data length may exceed 32-bits.  The 'flush'
  993.  * parameter is exactly the same as that to deflate, with the following
  994.  * meanings:
  995.  *
  996.  * Z_NO_FLUSH: normal incremental output of compressed data
  997.  * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
  998.  * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
  999.  *
  1000.  * The routine manages the acquire and release of the png_ptr->zstream by
  1001.  * checking and (at the end) clearing png_ptr->zowner, it does some sanity
  1002.  * checks on the 'mode' flags while doing this.
  1003.  */
  1004. void /* PRIVATE */
  1005. png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
  1006.    png_alloc_size_t input_len, int flush)
  1007. {
  1008.    if (png_ptr->zowner != png_IDAT)
  1009.    {
  1010.       /* First time.   Ensure we have a temporary buffer for compression and
  1011.        * trim the buffer list if it has more than one entry to free memory.
  1012.        * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
  1013.        * created at this point, but the check here is quick and safe.
  1014.        */
  1015.       if (png_ptr->zbuffer_list == NULL)
  1016.       {
  1017.          png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
  1018.             png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
  1019.          png_ptr->zbuffer_list->next = NULL;
  1020.       }
  1021.  
  1022.       else
  1023.          png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
  1024.  
  1025.       /* It is a terminal error if we can't claim the zstream. */
  1026.       if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
  1027.          png_error(png_ptr, png_ptr->zstream.msg);
  1028.  
  1029.       /* The output state is maintained in png_ptr->zstream, so it must be
  1030.        * initialized here after the claim.
  1031.        */
  1032.       png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
  1033.       png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
  1034.    }
  1035.  
  1036.    /* Now loop reading and writing until all the input is consumed or an error
  1037.     * terminates the operation.  The _out values are maintained across calls to
  1038.     * this function, but the input must be reset each time.
  1039.     */
  1040.    png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
  1041.    png_ptr->zstream.avail_in = 0; /* set below */
  1042.    for (;;)
  1043.    {
  1044.       int ret;
  1045.  
  1046.       /* INPUT: from the row data */
  1047.       uInt avail = ZLIB_IO_MAX;
  1048.  
  1049.       if (avail > input_len)
  1050.          avail = (uInt)input_len; /* safe because of the check */
  1051.  
  1052.       png_ptr->zstream.avail_in = avail;
  1053.       input_len -= avail;
  1054.  
  1055.       ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
  1056.  
  1057.       /* Include as-yet unconsumed input */
  1058.       input_len += png_ptr->zstream.avail_in;
  1059.       png_ptr->zstream.avail_in = 0;
  1060.  
  1061.       /* OUTPUT: write complete IDAT chunks when avail_out drops to zero, note
  1062.        * that these two zstream fields are preserved across the calls, therefore
  1063.        * there is no need to set these up on entry to the loop.
  1064.        */
  1065.       if (png_ptr->zstream.avail_out == 0)
  1066.       {
  1067.          png_bytep data = png_ptr->zbuffer_list->output;
  1068.          uInt size = png_ptr->zbuffer_size;
  1069.  
  1070.          /* Write an IDAT containing the data then reset the buffer.  The
  1071.           * first IDAT may need deflate header optimization.
  1072.           */
  1073. #        ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  1074.             if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
  1075.                png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
  1076.                optimize_cmf(data, png_image_size(png_ptr));
  1077. #        endif
  1078.  
  1079.          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
  1080.          png_ptr->mode |= PNG_HAVE_IDAT;
  1081.  
  1082.          png_ptr->zstream.next_out = data;
  1083.          png_ptr->zstream.avail_out = size;
  1084.  
  1085.          /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
  1086.           * the same flush parameter until it has finished output, for NO_FLUSH
  1087.           * it doesn't matter.
  1088.           */
  1089.          if (ret == Z_OK && flush != Z_NO_FLUSH)
  1090.             continue;
  1091.       }
  1092.  
  1093.       /* The order of these checks doesn't matter much; it just effect which
  1094.        * possible error might be detected if multiple things go wrong at once.
  1095.        */
  1096.       if (ret == Z_OK) /* most likely return code! */
  1097.       {
  1098.          /* If all the input has been consumed then just return.  If Z_FINISH
  1099.           * was used as the flush parameter something has gone wrong if we get
  1100.           * here.
  1101.           */
  1102.          if (input_len == 0)
  1103.          {
  1104.             if (flush == Z_FINISH)
  1105.                png_error(png_ptr, "Z_OK on Z_FINISH with output space");
  1106.  
  1107.             return;
  1108.          }
  1109.       }
  1110.  
  1111.       else if (ret == Z_STREAM_END && flush == Z_FINISH)
  1112.       {
  1113.          /* This is the end of the IDAT data; any pending output must be
  1114.           * flushed.  For small PNG files we may still be at the beginning.
  1115.           */
  1116.          png_bytep data = png_ptr->zbuffer_list->output;
  1117.          uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
  1118.  
  1119. #        ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  1120.             if (!(png_ptr->mode & PNG_HAVE_IDAT) &&
  1121.                png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
  1122.                optimize_cmf(data, png_image_size(png_ptr));
  1123. #        endif
  1124.  
  1125.          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
  1126.          png_ptr->zstream.avail_out = 0;
  1127.          png_ptr->zstream.next_out = NULL;
  1128.          png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
  1129.  
  1130.          png_ptr->zowner = 0; /* Release the stream */
  1131.          return;
  1132.       }
  1133.  
  1134.       else
  1135.       {
  1136.          /* This is an error condition. */
  1137.          png_zstream_error(png_ptr, ret);
  1138.          png_error(png_ptr, png_ptr->zstream.msg);
  1139.       }
  1140.    }
  1141. }
  1142.  
  1143. /* Write an IEND chunk */
  1144. void /* PRIVATE */
  1145. png_write_IEND(png_structrp png_ptr)
  1146. {
  1147.    png_debug(1, "in png_write_IEND");
  1148.  
  1149.    png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
  1150.    png_ptr->mode |= PNG_HAVE_IEND;
  1151. }
  1152.  
  1153. #ifdef PNG_WRITE_gAMA_SUPPORTED
  1154. /* Write a gAMA chunk */
  1155. void /* PRIVATE */
  1156. png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
  1157. {
  1158.    png_byte buf[4];
  1159.  
  1160.    png_debug(1, "in png_write_gAMA");
  1161.  
  1162.    /* file_gamma is saved in 1/100,000ths */
  1163.    png_save_uint_32(buf, (png_uint_32)file_gamma);
  1164.    png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
  1165. }
  1166. #endif
  1167.  
  1168. #ifdef PNG_WRITE_sRGB_SUPPORTED
  1169. /* Write a sRGB chunk */
  1170. void /* PRIVATE */
  1171. png_write_sRGB(png_structrp png_ptr, int srgb_intent)
  1172. {
  1173.    png_byte buf[1];
  1174.  
  1175.    png_debug(1, "in png_write_sRGB");
  1176.  
  1177.    if (srgb_intent >= PNG_sRGB_INTENT_LAST)
  1178.       png_warning(png_ptr,
  1179.           "Invalid sRGB rendering intent specified");
  1180.  
  1181.    buf[0]=(png_byte)srgb_intent;
  1182.    png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
  1183. }
  1184. #endif
  1185.  
  1186. #ifdef PNG_WRITE_iCCP_SUPPORTED
  1187. /* Write an iCCP chunk */
  1188. void /* PRIVATE */
  1189. png_write_iCCP(png_structrp png_ptr, png_const_charp name,
  1190.     png_const_bytep profile)
  1191. {
  1192.    png_uint_32 name_len;
  1193.    png_uint_32 profile_len;
  1194.    png_byte new_name[81]; /* 1 byte for the compression byte */
  1195.    compression_state comp;
  1196.  
  1197.    png_debug(1, "in png_write_iCCP");
  1198.  
  1199.    /* These are all internal problems: the profile should have been checked
  1200.     * before when it was stored.
  1201.     */
  1202.    if (profile == NULL)
  1203.       png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
  1204.  
  1205.    profile_len = png_get_uint_32(profile);
  1206.  
  1207.    if (profile_len < 132)
  1208.       png_error(png_ptr, "ICC profile too short");
  1209.  
  1210.    if (profile_len & 0x03)
  1211.       png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
  1212.  
  1213.    {
  1214.       png_uint_32 embedded_profile_len = png_get_uint_32(profile);
  1215.  
  1216.       if (profile_len != embedded_profile_len)
  1217.          png_error(png_ptr, "Profile length does not match profile");
  1218.    }
  1219.  
  1220.    name_len = png_check_keyword(png_ptr, name, new_name);
  1221.  
  1222.    if (name_len == 0)
  1223.       png_error(png_ptr, "iCCP: invalid keyword");
  1224.  
  1225.    new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
  1226.  
  1227.    /* Make sure we include the NULL after the name and the compression type */
  1228.    ++name_len;
  1229.  
  1230.    png_text_compress_init(&comp, profile, profile_len);
  1231.  
  1232.    /* Allow for keyword terminator and compression byte */
  1233.    if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
  1234.       png_error(png_ptr, png_ptr->zstream.msg);
  1235.  
  1236.    png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
  1237.  
  1238.    png_write_chunk_data(png_ptr, new_name, name_len);
  1239.  
  1240.    png_write_compressed_data_out(png_ptr, &comp);
  1241.  
  1242.    png_write_chunk_end(png_ptr);
  1243. }
  1244. #endif
  1245.  
  1246. #ifdef PNG_WRITE_sPLT_SUPPORTED
  1247. /* Write a sPLT chunk */
  1248. void /* PRIVATE */
  1249. png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
  1250. {
  1251.    png_uint_32 name_len;
  1252.    png_byte new_name[80];
  1253.    png_byte entrybuf[10];
  1254.    png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
  1255.    png_size_t palette_size = entry_size * spalette->nentries;
  1256.    png_sPLT_entryp ep;
  1257. #ifndef PNG_POINTER_INDEXING_SUPPORTED
  1258.    int i;
  1259. #endif
  1260.  
  1261.    png_debug(1, "in png_write_sPLT");
  1262.  
  1263.    name_len = png_check_keyword(png_ptr, spalette->name, new_name);
  1264.  
  1265.    if (name_len == 0)
  1266.       png_error(png_ptr, "sPLT: invalid keyword");
  1267.  
  1268.    /* Make sure we include the NULL after the name */
  1269.    png_write_chunk_header(png_ptr, png_sPLT,
  1270.        (png_uint_32)(name_len + 2 + palette_size));
  1271.  
  1272.    png_write_chunk_data(png_ptr, (png_bytep)new_name,
  1273.        (png_size_t)(name_len + 1));
  1274.  
  1275.    png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
  1276.  
  1277.    /* Loop through each palette entry, writing appropriately */
  1278. #ifdef PNG_POINTER_INDEXING_SUPPORTED
  1279.    for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
  1280.    {
  1281.       if (spalette->depth == 8)
  1282.       {
  1283.          entrybuf[0] = (png_byte)ep->red;
  1284.          entrybuf[1] = (png_byte)ep->green;
  1285.          entrybuf[2] = (png_byte)ep->blue;
  1286.          entrybuf[3] = (png_byte)ep->alpha;
  1287.          png_save_uint_16(entrybuf + 4, ep->frequency);
  1288.       }
  1289.  
  1290.       else
  1291.       {
  1292.          png_save_uint_16(entrybuf + 0, ep->red);
  1293.          png_save_uint_16(entrybuf + 2, ep->green);
  1294.          png_save_uint_16(entrybuf + 4, ep->blue);
  1295.          png_save_uint_16(entrybuf + 6, ep->alpha);
  1296.          png_save_uint_16(entrybuf + 8, ep->frequency);
  1297.       }
  1298.  
  1299.       png_write_chunk_data(png_ptr, entrybuf, entry_size);
  1300.    }
  1301. #else
  1302.    ep=spalette->entries;
  1303.    for (i = 0; i>spalette->nentries; i++)
  1304.    {
  1305.       if (spalette->depth == 8)
  1306.       {
  1307.          entrybuf[0] = (png_byte)ep[i].red;
  1308.          entrybuf[1] = (png_byte)ep[i].green;
  1309.          entrybuf[2] = (png_byte)ep[i].blue;
  1310.          entrybuf[3] = (png_byte)ep[i].alpha;
  1311.          png_save_uint_16(entrybuf + 4, ep[i].frequency);
  1312.       }
  1313.  
  1314.       else
  1315.       {
  1316.          png_save_uint_16(entrybuf + 0, ep[i].red);
  1317.          png_save_uint_16(entrybuf + 2, ep[i].green);
  1318.          png_save_uint_16(entrybuf + 4, ep[i].blue);
  1319.          png_save_uint_16(entrybuf + 6, ep[i].alpha);
  1320.          png_save_uint_16(entrybuf + 8, ep[i].frequency);
  1321.       }
  1322.  
  1323.       png_write_chunk_data(png_ptr, entrybuf, entry_size);
  1324.    }
  1325. #endif
  1326.  
  1327.    png_write_chunk_end(png_ptr);
  1328. }
  1329. #endif
  1330.  
  1331. #ifdef PNG_WRITE_sBIT_SUPPORTED
  1332. /* Write the sBIT chunk */
  1333. void /* PRIVATE */
  1334. png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
  1335. {
  1336.    png_byte buf[4];
  1337.    png_size_t size;
  1338.  
  1339.    png_debug(1, "in png_write_sBIT");
  1340.  
  1341.    /* Make sure we don't depend upon the order of PNG_COLOR_8 */
  1342.    if (color_type & PNG_COLOR_MASK_COLOR)
  1343.    {
  1344.       png_byte maxbits;
  1345.  
  1346.       maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
  1347.           png_ptr->usr_bit_depth);
  1348.  
  1349.       if (sbit->red == 0 || sbit->red > maxbits ||
  1350.           sbit->green == 0 || sbit->green > maxbits ||
  1351.           sbit->blue == 0 || sbit->blue > maxbits)
  1352.       {
  1353.          png_warning(png_ptr, "Invalid sBIT depth specified");
  1354.          return;
  1355.       }
  1356.  
  1357.       buf[0] = sbit->red;
  1358.       buf[1] = sbit->green;
  1359.       buf[2] = sbit->blue;
  1360.       size = 3;
  1361.    }
  1362.  
  1363.    else
  1364.    {
  1365.       if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
  1366.       {
  1367.          png_warning(png_ptr, "Invalid sBIT depth specified");
  1368.          return;
  1369.       }
  1370.  
  1371.       buf[0] = sbit->gray;
  1372.       size = 1;
  1373.    }
  1374.  
  1375.    if (color_type & PNG_COLOR_MASK_ALPHA)
  1376.    {
  1377.       if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
  1378.       {
  1379.          png_warning(png_ptr, "Invalid sBIT depth specified");
  1380.          return;
  1381.       }
  1382.  
  1383.       buf[size++] = sbit->alpha;
  1384.    }
  1385.  
  1386.    png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
  1387. }
  1388. #endif
  1389.  
  1390. #ifdef PNG_WRITE_cHRM_SUPPORTED
  1391. /* Write the cHRM chunk */
  1392. void /* PRIVATE */
  1393. png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
  1394. {
  1395.    png_byte buf[32];
  1396.  
  1397.    png_debug(1, "in png_write_cHRM");
  1398.  
  1399.    /* Each value is saved in 1/100,000ths */
  1400.    png_save_int_32(buf,      xy->whitex);
  1401.    png_save_int_32(buf +  4, xy->whitey);
  1402.  
  1403.    png_save_int_32(buf +  8, xy->redx);
  1404.    png_save_int_32(buf + 12, xy->redy);
  1405.  
  1406.    png_save_int_32(buf + 16, xy->greenx);
  1407.    png_save_int_32(buf + 20, xy->greeny);
  1408.  
  1409.    png_save_int_32(buf + 24, xy->bluex);
  1410.    png_save_int_32(buf + 28, xy->bluey);
  1411.  
  1412.    png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
  1413. }
  1414. #endif
  1415.  
  1416. #ifdef PNG_WRITE_tRNS_SUPPORTED
  1417. /* Write the tRNS chunk */
  1418. void /* PRIVATE */
  1419. png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
  1420.     png_const_color_16p tran, int num_trans, int color_type)
  1421. {
  1422.    png_byte buf[6];
  1423.  
  1424.    png_debug(1, "in png_write_tRNS");
  1425.  
  1426.    if (color_type == PNG_COLOR_TYPE_PALETTE)
  1427.    {
  1428.       if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
  1429.       {
  1430.          png_app_warning(png_ptr,
  1431.              "Invalid number of transparent colors specified");
  1432.          return;
  1433.       }
  1434.  
  1435.       /* Write the chunk out as it is */
  1436.       png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
  1437.          (png_size_t)num_trans);
  1438.    }
  1439.  
  1440.    else if (color_type == PNG_COLOR_TYPE_GRAY)
  1441.    {
  1442.       /* One 16 bit value */
  1443.       if (tran->gray >= (1 << png_ptr->bit_depth))
  1444.       {
  1445.          png_app_warning(png_ptr,
  1446.              "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
  1447.  
  1448.          return;
  1449.       }
  1450.  
  1451.       png_save_uint_16(buf, tran->gray);
  1452.       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
  1453.    }
  1454.  
  1455.    else if (color_type == PNG_COLOR_TYPE_RGB)
  1456.    {
  1457.       /* Three 16 bit values */
  1458.       png_save_uint_16(buf, tran->red);
  1459.       png_save_uint_16(buf + 2, tran->green);
  1460.       png_save_uint_16(buf + 4, tran->blue);
  1461. #ifdef PNG_WRITE_16BIT_SUPPORTED
  1462.       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
  1463. #else
  1464.       if (buf[0] | buf[2] | buf[4])
  1465. #endif
  1466.       {
  1467.          png_app_warning(png_ptr,
  1468.            "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
  1469.          return;
  1470.       }
  1471.  
  1472.       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
  1473.    }
  1474.  
  1475.    else
  1476.    {
  1477.       png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
  1478.    }
  1479. }
  1480. #endif
  1481.  
  1482. #ifdef PNG_WRITE_bKGD_SUPPORTED
  1483. /* Write the background chunk */
  1484. void /* PRIVATE */
  1485. png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
  1486. {
  1487.    png_byte buf[6];
  1488.  
  1489.    png_debug(1, "in png_write_bKGD");
  1490.  
  1491.    if (color_type == PNG_COLOR_TYPE_PALETTE)
  1492.    {
  1493.       if (
  1494. #ifdef PNG_MNG_FEATURES_SUPPORTED
  1495.           (png_ptr->num_palette ||
  1496.           (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
  1497. #endif
  1498.          back->index >= png_ptr->num_palette)
  1499.       {
  1500.          png_warning(png_ptr, "Invalid background palette index");
  1501.          return;
  1502.       }
  1503.  
  1504.       buf[0] = back->index;
  1505.       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
  1506.    }
  1507.  
  1508.    else if (color_type & PNG_COLOR_MASK_COLOR)
  1509.    {
  1510.       png_save_uint_16(buf, back->red);
  1511.       png_save_uint_16(buf + 2, back->green);
  1512.       png_save_uint_16(buf + 4, back->blue);
  1513. #ifdef PNG_WRITE_16BIT_SUPPORTED
  1514.       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
  1515. #else
  1516.       if (buf[0] | buf[2] | buf[4])
  1517. #endif
  1518.       {
  1519.          png_warning(png_ptr,
  1520.              "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
  1521.  
  1522.          return;
  1523.       }
  1524.  
  1525.       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
  1526.    }
  1527.  
  1528.    else
  1529.    {
  1530.       if (back->gray >= (1 << png_ptr->bit_depth))
  1531.       {
  1532.          png_warning(png_ptr,
  1533.              "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
  1534.  
  1535.          return;
  1536.       }
  1537.  
  1538.       png_save_uint_16(buf, back->gray);
  1539.       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
  1540.    }
  1541. }
  1542. #endif
  1543.  
  1544. #ifdef PNG_WRITE_hIST_SUPPORTED
  1545. /* Write the histogram */
  1546. void /* PRIVATE */
  1547. png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
  1548. {
  1549.    int i;
  1550.    png_byte buf[3];
  1551.  
  1552.    png_debug(1, "in png_write_hIST");
  1553.  
  1554.    if (num_hist > (int)png_ptr->num_palette)
  1555.    {
  1556.       png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
  1557.           png_ptr->num_palette);
  1558.  
  1559.       png_warning(png_ptr, "Invalid number of histogram entries specified");
  1560.       return;
  1561.    }
  1562.  
  1563.    png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
  1564.  
  1565.    for (i = 0; i < num_hist; i++)
  1566.    {
  1567.       png_save_uint_16(buf, hist[i]);
  1568.       png_write_chunk_data(png_ptr, buf, (png_size_t)2);
  1569.    }
  1570.  
  1571.    png_write_chunk_end(png_ptr);
  1572. }
  1573. #endif
  1574.  
  1575. #ifdef PNG_WRITE_tEXt_SUPPORTED
  1576. /* Write a tEXt chunk */
  1577. void /* PRIVATE */
  1578. png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
  1579.     png_size_t text_len)
  1580. {
  1581.    png_uint_32 key_len;
  1582.    png_byte new_key[80];
  1583.  
  1584.    png_debug(1, "in png_write_tEXt");
  1585.  
  1586.    key_len = png_check_keyword(png_ptr, key, new_key);
  1587.  
  1588.    if (key_len == 0)
  1589.       png_error(png_ptr, "tEXt: invalid keyword");
  1590.  
  1591.    if (text == NULL || *text == '\0')
  1592.       text_len = 0;
  1593.  
  1594.    else
  1595.       text_len = strlen(text);
  1596.  
  1597.    if (text_len > PNG_UINT_31_MAX - (key_len+1))
  1598.       png_error(png_ptr, "tEXt: text too long");
  1599.  
  1600.    /* Make sure we include the 0 after the key */
  1601.    png_write_chunk_header(png_ptr, png_tEXt,
  1602.        (png_uint_32)/*checked above*/(key_len + text_len + 1));
  1603.    /*
  1604.     * We leave it to the application to meet PNG-1.0 requirements on the
  1605.     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
  1606.     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.
  1607.     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1608.     */
  1609.    png_write_chunk_data(png_ptr, new_key, key_len + 1);
  1610.  
  1611.    if (text_len)
  1612.       png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
  1613.  
  1614.    png_write_chunk_end(png_ptr);
  1615. }
  1616. #endif
  1617.  
  1618. #ifdef PNG_WRITE_zTXt_SUPPORTED
  1619. /* Write a compressed text chunk */
  1620. void /* PRIVATE */
  1621. png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
  1622.     png_size_t text_len, int compression)
  1623. {
  1624.    png_uint_32 key_len;
  1625.    png_byte new_key[81];
  1626.    compression_state comp;
  1627.  
  1628.    png_debug(1, "in png_write_zTXt");
  1629.    PNG_UNUSED(text_len) /* Always use strlen */
  1630.  
  1631.    if (compression == PNG_TEXT_COMPRESSION_NONE)
  1632.    {
  1633.       png_write_tEXt(png_ptr, key, text, 0);
  1634.       return;
  1635.    }
  1636.  
  1637.    if (compression != PNG_TEXT_COMPRESSION_zTXt)
  1638.       png_error(png_ptr, "zTXt: invalid compression type");
  1639.  
  1640.    key_len = png_check_keyword(png_ptr, key, new_key);
  1641.  
  1642.    if (key_len == 0)
  1643.       png_error(png_ptr, "zTXt: invalid keyword");
  1644.  
  1645.    /* Add the compression method and 1 for the keyword separator. */
  1646.    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
  1647.    ++key_len;
  1648.  
  1649.    /* Compute the compressed data; do it now for the length */
  1650.    png_text_compress_init(&comp, (png_const_bytep)text,
  1651.       text == NULL ? 0 : strlen(text));
  1652.  
  1653.    if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
  1654.       png_error(png_ptr, png_ptr->zstream.msg);
  1655.  
  1656.    /* Write start of chunk */
  1657.    png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
  1658.  
  1659.    /* Write key */
  1660.    png_write_chunk_data(png_ptr, new_key, key_len);
  1661.  
  1662.    /* Write the compressed data */
  1663.    png_write_compressed_data_out(png_ptr, &comp);
  1664.  
  1665.    /* Close the chunk */
  1666.    png_write_chunk_end(png_ptr);
  1667. }
  1668. #endif
  1669.  
  1670. #ifdef PNG_WRITE_iTXt_SUPPORTED
  1671. /* Write an iTXt chunk */
  1672. void /* PRIVATE */
  1673. png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
  1674.     png_const_charp lang, png_const_charp lang_key, png_const_charp text)
  1675. {
  1676.    png_uint_32 key_len, prefix_len;
  1677.    png_size_t lang_len, lang_key_len;
  1678.    png_byte new_key[82];
  1679.    compression_state comp;
  1680.  
  1681.    png_debug(1, "in png_write_iTXt");
  1682.  
  1683.    key_len = png_check_keyword(png_ptr, key, new_key);
  1684.  
  1685.    if (key_len == 0)
  1686.       png_error(png_ptr, "iTXt: invalid keyword");
  1687.  
  1688.    /* Set the compression flag */
  1689.    switch (compression)
  1690.    {
  1691.       case PNG_ITXT_COMPRESSION_NONE:
  1692.       case PNG_TEXT_COMPRESSION_NONE:
  1693.          compression = new_key[++key_len] = 0; /* no compression */
  1694.          break;
  1695.  
  1696.       case PNG_TEXT_COMPRESSION_zTXt:
  1697.       case PNG_ITXT_COMPRESSION_zTXt:
  1698.          compression = new_key[++key_len] = 1; /* compressed */
  1699.          break;
  1700.  
  1701.       default:
  1702.          png_error(png_ptr, "iTXt: invalid compression");
  1703.    }
  1704.  
  1705.    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
  1706.    ++key_len; /* for the keywod separator */
  1707.  
  1708.    /* We leave it to the application to meet PNG-1.0 requirements on the
  1709.     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
  1710.     * any non-Latin-1 characters except for NEWLINE.  ISO PNG, however,
  1711.     * specifies that the text is UTF-8 and this really doesn't require any
  1712.     * checking.
  1713.     *
  1714.     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1715.     *
  1716.     * TODO: validate the language tag correctly (see the spec.)
  1717.     */
  1718.    if (lang == NULL) lang = ""; /* empty language is valid */
  1719.    lang_len = strlen(lang)+1;
  1720.    if (lang_key == NULL) lang_key = ""; /* may be empty */
  1721.    lang_key_len = strlen(lang_key)+1;
  1722.    if (text == NULL) text = ""; /* may be empty */
  1723.  
  1724.    prefix_len = key_len;
  1725.    if (lang_len > PNG_UINT_31_MAX-prefix_len)
  1726.       prefix_len = PNG_UINT_31_MAX;
  1727.    else
  1728.       prefix_len = (png_uint_32)(prefix_len + lang_len);
  1729.  
  1730.    if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
  1731.       prefix_len = PNG_UINT_31_MAX;
  1732.    else
  1733.       prefix_len = (png_uint_32)(prefix_len + lang_key_len);
  1734.  
  1735.    png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
  1736.  
  1737.    if (compression)
  1738.    {
  1739.       if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
  1740.          png_error(png_ptr, png_ptr->zstream.msg);
  1741.    }
  1742.  
  1743.    else
  1744.    {
  1745.       if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
  1746.          png_error(png_ptr, "iTXt: uncompressed text too long");
  1747.  
  1748.       /* So the string will fit in a chunk: */
  1749.       comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
  1750.    }
  1751.  
  1752.    png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
  1753.  
  1754.    png_write_chunk_data(png_ptr, new_key, key_len);
  1755.  
  1756.    png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
  1757.  
  1758.    png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
  1759.  
  1760.    if (compression)
  1761.       png_write_compressed_data_out(png_ptr, &comp);
  1762.  
  1763.    else
  1764.       png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len);
  1765.  
  1766.    png_write_chunk_end(png_ptr);
  1767. }
  1768. #endif
  1769.  
  1770. #ifdef PNG_WRITE_oFFs_SUPPORTED
  1771. /* Write the oFFs chunk */
  1772. void /* PRIVATE */
  1773. png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
  1774.     int unit_type)
  1775. {
  1776.    png_byte buf[9];
  1777.  
  1778.    png_debug(1, "in png_write_oFFs");
  1779.  
  1780.    if (unit_type >= PNG_OFFSET_LAST)
  1781.       png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
  1782.  
  1783.    png_save_int_32(buf, x_offset);
  1784.    png_save_int_32(buf + 4, y_offset);
  1785.    buf[8] = (png_byte)unit_type;
  1786.  
  1787.    png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
  1788. }
  1789. #endif
  1790. #ifdef PNG_WRITE_pCAL_SUPPORTED
  1791. /* Write the pCAL chunk (described in the PNG extensions document) */
  1792. void /* PRIVATE */
  1793. png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
  1794.     png_int_32 X1, int type, int nparams, png_const_charp units,
  1795.     png_charpp params)
  1796. {
  1797.    png_uint_32 purpose_len;
  1798.    png_size_t units_len, total_len;
  1799.    png_size_tp params_len;
  1800.    png_byte buf[10];
  1801.    png_byte new_purpose[80];
  1802.    int i;
  1803.  
  1804.    png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
  1805.  
  1806.    if (type >= PNG_EQUATION_LAST)
  1807.       png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
  1808.  
  1809.    purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
  1810.  
  1811.    if (purpose_len == 0)
  1812.       png_error(png_ptr, "pCAL: invalid keyword");
  1813.  
  1814.    ++purpose_len; /* terminator */
  1815.  
  1816.    png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
  1817.    units_len = strlen(units) + (nparams == 0 ? 0 : 1);
  1818.    png_debug1(3, "pCAL units length = %d", (int)units_len);
  1819.    total_len = purpose_len + units_len + 10;
  1820.  
  1821.    params_len = (png_size_tp)png_malloc(png_ptr,
  1822.        (png_alloc_size_t)(nparams * (sizeof (png_size_t))));
  1823.  
  1824.    /* Find the length of each parameter, making sure we don't count the
  1825.     * null terminator for the last parameter.
  1826.     */
  1827.    for (i = 0; i < nparams; i++)
  1828.    {
  1829.       params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
  1830.       png_debug2(3, "pCAL parameter %d length = %lu", i,
  1831.           (unsigned long)params_len[i]);
  1832.       total_len += params_len[i];
  1833.    }
  1834.  
  1835.    png_debug1(3, "pCAL total length = %d", (int)total_len);
  1836.    png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
  1837.    png_write_chunk_data(png_ptr, new_purpose, purpose_len);
  1838.    png_save_int_32(buf, X0);
  1839.    png_save_int_32(buf + 4, X1);
  1840.    buf[8] = (png_byte)type;
  1841.    buf[9] = (png_byte)nparams;
  1842.    png_write_chunk_data(png_ptr, buf, (png_size_t)10);
  1843.    png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
  1844.  
  1845.    for (i = 0; i < nparams; i++)
  1846.    {
  1847.       png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
  1848.    }
  1849.  
  1850.    png_free(png_ptr, params_len);
  1851.    png_write_chunk_end(png_ptr);
  1852. }
  1853. #endif
  1854.  
  1855. #ifdef PNG_WRITE_sCAL_SUPPORTED
  1856. /* Write the sCAL chunk */
  1857. void /* PRIVATE */
  1858. png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
  1859.     png_const_charp height)
  1860. {
  1861.    png_byte buf[64];
  1862.    png_size_t wlen, hlen, total_len;
  1863.  
  1864.    png_debug(1, "in png_write_sCAL_s");
  1865.  
  1866.    wlen = strlen(width);
  1867.    hlen = strlen(height);
  1868.    total_len = wlen + hlen + 2;
  1869.  
  1870.    if (total_len > 64)
  1871.    {
  1872.       png_warning(png_ptr, "Can't write sCAL (buffer too small)");
  1873.       return;
  1874.    }
  1875.  
  1876.    buf[0] = (png_byte)unit;
  1877.    memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */
  1878.    memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */
  1879.  
  1880.    png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
  1881.    png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
  1882. }
  1883. #endif
  1884.  
  1885. #ifdef PNG_WRITE_pHYs_SUPPORTED
  1886. /* Write the pHYs chunk */
  1887. void /* PRIVATE */
  1888. png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
  1889.     png_uint_32 y_pixels_per_unit,
  1890.     int unit_type)
  1891. {
  1892.    png_byte buf[9];
  1893.  
  1894.    png_debug(1, "in png_write_pHYs");
  1895.  
  1896.    if (unit_type >= PNG_RESOLUTION_LAST)
  1897.       png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
  1898.  
  1899.    png_save_uint_32(buf, x_pixels_per_unit);
  1900.    png_save_uint_32(buf + 4, y_pixels_per_unit);
  1901.    buf[8] = (png_byte)unit_type;
  1902.  
  1903.    png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
  1904. }
  1905. #endif
  1906.  
  1907. #ifdef PNG_WRITE_tIME_SUPPORTED
  1908. /* Write the tIME chunk.  Use either png_convert_from_struct_tm()
  1909.  * or png_convert_from_time_t(), or fill in the structure yourself.
  1910.  */
  1911. void /* PRIVATE */
  1912. png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
  1913. {
  1914.    png_byte buf[7];
  1915.  
  1916.    png_debug(1, "in png_write_tIME");
  1917.  
  1918.    if (mod_time->month  > 12 || mod_time->month  < 1 ||
  1919.        mod_time->day    > 31 || mod_time->day    < 1 ||
  1920.        mod_time->hour   > 23 || mod_time->second > 60)
  1921.    {
  1922.       png_warning(png_ptr, "Invalid time specified for tIME chunk");
  1923.       return;
  1924.    }
  1925.  
  1926.    png_save_uint_16(buf, mod_time->year);
  1927.    buf[2] = mod_time->month;
  1928.    buf[3] = mod_time->day;
  1929.    buf[4] = mod_time->hour;
  1930.    buf[5] = mod_time->minute;
  1931.    buf[6] = mod_time->second;
  1932.  
  1933.    png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
  1934. }
  1935. #endif
  1936.  
  1937. /* Initializes the row writing capability of libpng */
  1938. void /* PRIVATE */
  1939. png_write_start_row(png_structrp png_ptr)
  1940. {
  1941. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1942.    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1943.  
  1944.    /* Start of interlace block */
  1945.    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1946.  
  1947.    /* Offset to next interlace block */
  1948.    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1949.  
  1950.    /* Start of interlace block in the y direction */
  1951.    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  1952.  
  1953.    /* Offset to next interlace block in the y direction */
  1954.    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  1955. #endif
  1956.  
  1957.    png_alloc_size_t buf_size;
  1958.    int usr_pixel_depth;
  1959.  
  1960.    png_debug(1, "in png_write_start_row");
  1961.  
  1962.    usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
  1963.    buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
  1964.  
  1965.    /* 1.5.6: added to allow checking in the row write code. */
  1966.    png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
  1967.    png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
  1968.  
  1969.    /* Set up row buffer */
  1970.    png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
  1971.  
  1972.    png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
  1973.  
  1974. #ifdef PNG_WRITE_FILTER_SUPPORTED
  1975.    /* Set up filtering buffer, if using this filter */
  1976.    if (png_ptr->do_filter & PNG_FILTER_SUB)
  1977.    {
  1978.       png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
  1979.  
  1980.       png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
  1981.    }
  1982.  
  1983.    /* We only need to keep the previous row if we are using one of these. */
  1984.    if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
  1985.    {
  1986.       /* Set up previous row buffer */
  1987.       png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
  1988.  
  1989.       if (png_ptr->do_filter & PNG_FILTER_UP)
  1990.       {
  1991.          png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
  1992.             png_ptr->rowbytes + 1);
  1993.  
  1994.          png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
  1995.       }
  1996.  
  1997.       if (png_ptr->do_filter & PNG_FILTER_AVG)
  1998.       {
  1999.          png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
  2000.              png_ptr->rowbytes + 1);
  2001.  
  2002.          png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
  2003.       }
  2004.  
  2005.       if (png_ptr->do_filter & PNG_FILTER_PAETH)
  2006.       {
  2007.          png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
  2008.              png_ptr->rowbytes + 1);
  2009.  
  2010.          png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
  2011.       }
  2012.    }
  2013. #endif /* PNG_WRITE_FILTER_SUPPORTED */
  2014.  
  2015. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  2016.    /* If interlaced, we need to set up width and height of pass */
  2017.    if (png_ptr->interlaced)
  2018.    {
  2019.       if (!(png_ptr->transformations & PNG_INTERLACE))
  2020.       {
  2021.          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
  2022.              png_pass_ystart[0]) / png_pass_yinc[0];
  2023.  
  2024.          png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
  2025.              png_pass_start[0]) / png_pass_inc[0];
  2026.       }
  2027.  
  2028.       else
  2029.       {
  2030.          png_ptr->num_rows = png_ptr->height;
  2031.          png_ptr->usr_width = png_ptr->width;
  2032.       }
  2033.    }
  2034.  
  2035.    else
  2036. #endif
  2037.    {
  2038.       png_ptr->num_rows = png_ptr->height;
  2039.       png_ptr->usr_width = png_ptr->width;
  2040.    }
  2041. }
  2042.  
  2043. /* Internal use only.  Called when finished processing a row of data. */
  2044. void /* PRIVATE */
  2045. png_write_finish_row(png_structrp png_ptr)
  2046. {
  2047. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  2048.    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  2049.  
  2050.    /* Start of interlace block */
  2051.    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  2052.  
  2053.    /* Offset to next interlace block */
  2054.    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  2055.  
  2056.    /* Start of interlace block in the y direction */
  2057.    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  2058.  
  2059.    /* Offset to next interlace block in the y direction */
  2060.    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  2061. #endif
  2062.  
  2063.    png_debug(1, "in png_write_finish_row");
  2064.  
  2065.    /* Next row */
  2066.    png_ptr->row_number++;
  2067.  
  2068.    /* See if we are done */
  2069.    if (png_ptr->row_number < png_ptr->num_rows)
  2070.       return;
  2071.  
  2072. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  2073.    /* If interlaced, go to next pass */
  2074.    if (png_ptr->interlaced)
  2075.    {
  2076.       png_ptr->row_number = 0;
  2077.       if (png_ptr->transformations & PNG_INTERLACE)
  2078.       {
  2079.          png_ptr->pass++;
  2080.       }
  2081.  
  2082.       else
  2083.       {
  2084.          /* Loop until we find a non-zero width or height pass */
  2085.          do
  2086.          {
  2087.             png_ptr->pass++;
  2088.  
  2089.             if (png_ptr->pass >= 7)
  2090.                break;
  2091.  
  2092.             png_ptr->usr_width = (png_ptr->width +
  2093.                 png_pass_inc[png_ptr->pass] - 1 -
  2094.                 png_pass_start[png_ptr->pass]) /
  2095.                 png_pass_inc[png_ptr->pass];
  2096.  
  2097.             png_ptr->num_rows = (png_ptr->height +
  2098.                 png_pass_yinc[png_ptr->pass] - 1 -
  2099.                 png_pass_ystart[png_ptr->pass]) /
  2100.                 png_pass_yinc[png_ptr->pass];
  2101.  
  2102.             if (png_ptr->transformations & PNG_INTERLACE)
  2103.                break;
  2104.  
  2105.          } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
  2106.  
  2107.       }
  2108.  
  2109.       /* Reset the row above the image for the next pass */
  2110.       if (png_ptr->pass < 7)
  2111.       {
  2112.          if (png_ptr->prev_row != NULL)
  2113.             memset(png_ptr->prev_row, 0,
  2114.                 (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
  2115.                 png_ptr->usr_bit_depth, png_ptr->width)) + 1);
  2116.  
  2117.          return;
  2118.       }
  2119.    }
  2120. #endif
  2121.  
  2122.    /* If we get here, we've just written the last row, so we need
  2123.       to flush the compressor */
  2124.    png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
  2125. }
  2126.  
  2127. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  2128. /* Pick out the correct pixels for the interlace pass.
  2129.  * The basic idea here is to go through the row with a source
  2130.  * pointer and a destination pointer (sp and dp), and copy the
  2131.  * correct pixels for the pass.  As the row gets compacted,
  2132.  * sp will always be >= dp, so we should never overwrite anything.
  2133.  * See the default: case for the easiest code to understand.
  2134.  */
  2135. void /* PRIVATE */
  2136. png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
  2137. {
  2138.    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  2139.  
  2140.    /* Start of interlace block */
  2141.    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  2142.  
  2143.    /* Offset to next interlace block */
  2144.    static PNG_CONST png_byte  png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  2145.  
  2146.    png_debug(1, "in png_do_write_interlace");
  2147.  
  2148.    /* We don't have to do anything on the last pass (6) */
  2149.    if (pass < 6)
  2150.    {
  2151.       /* Each pixel depth is handled separately */
  2152.       switch (row_info->pixel_depth)
  2153.       {
  2154.          case 1:
  2155.          {
  2156.             png_bytep sp;
  2157.             png_bytep dp;
  2158.             int shift;
  2159.             int d;
  2160.             int value;
  2161.             png_uint_32 i;
  2162.             png_uint_32 row_width = row_info->width;
  2163.  
  2164.             dp = row;
  2165.             d = 0;
  2166.             shift = 7;
  2167.  
  2168.             for (i = png_pass_start[pass]; i < row_width;
  2169.                i += png_pass_inc[pass])
  2170.             {
  2171.                sp = row + (png_size_t)(i >> 3);
  2172.                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
  2173.                d |= (value << shift);
  2174.  
  2175.                if (shift == 0)
  2176.                {
  2177.                   shift = 7;
  2178.                   *dp++ = (png_byte)d;
  2179.                   d = 0;
  2180.                }
  2181.  
  2182.                else
  2183.                   shift--;
  2184.  
  2185.             }
  2186.             if (shift != 7)
  2187.                *dp = (png_byte)d;
  2188.  
  2189.             break;
  2190.          }
  2191.  
  2192.          case 2:
  2193.          {
  2194.             png_bytep sp;
  2195.             png_bytep dp;
  2196.             int shift;
  2197.             int d;
  2198.             int value;
  2199.             png_uint_32 i;
  2200.             png_uint_32 row_width = row_info->width;
  2201.  
  2202.             dp = row;
  2203.             shift = 6;
  2204.             d = 0;
  2205.  
  2206.             for (i = png_pass_start[pass]; i < row_width;
  2207.                i += png_pass_inc[pass])
  2208.             {
  2209.                sp = row + (png_size_t)(i >> 2);
  2210.                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
  2211.                d |= (value << shift);
  2212.  
  2213.                if (shift == 0)
  2214.                {
  2215.                   shift = 6;
  2216.                   *dp++ = (png_byte)d;
  2217.                   d = 0;
  2218.                }
  2219.  
  2220.                else
  2221.                   shift -= 2;
  2222.             }
  2223.             if (shift != 6)
  2224.                *dp = (png_byte)d;
  2225.  
  2226.             break;
  2227.          }
  2228.  
  2229.          case 4:
  2230.          {
  2231.             png_bytep sp;
  2232.             png_bytep dp;
  2233.             int shift;
  2234.             int d;
  2235.             int value;
  2236.             png_uint_32 i;
  2237.             png_uint_32 row_width = row_info->width;
  2238.  
  2239.             dp = row;
  2240.             shift = 4;
  2241.             d = 0;
  2242.             for (i = png_pass_start[pass]; i < row_width;
  2243.                 i += png_pass_inc[pass])
  2244.             {
  2245.                sp = row + (png_size_t)(i >> 1);
  2246.                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
  2247.                d |= (value << shift);
  2248.  
  2249.                if (shift == 0)
  2250.                {
  2251.                   shift = 4;
  2252.                   *dp++ = (png_byte)d;
  2253.                   d = 0;
  2254.                }
  2255.  
  2256.                else
  2257.                   shift -= 4;
  2258.             }
  2259.             if (shift != 4)
  2260.                *dp = (png_byte)d;
  2261.  
  2262.             break;
  2263.          }
  2264.  
  2265.          default:
  2266.          {
  2267.             png_bytep sp;
  2268.             png_bytep dp;
  2269.             png_uint_32 i;
  2270.             png_uint_32 row_width = row_info->width;
  2271.             png_size_t pixel_bytes;
  2272.  
  2273.             /* Start at the beginning */
  2274.             dp = row;
  2275.  
  2276.             /* Find out how many bytes each pixel takes up */
  2277.             pixel_bytes = (row_info->pixel_depth >> 3);
  2278.  
  2279.             /* Loop through the row, only looking at the pixels that matter */
  2280.             for (i = png_pass_start[pass]; i < row_width;
  2281.                i += png_pass_inc[pass])
  2282.             {
  2283.                /* Find out where the original pixel is */
  2284.                sp = row + (png_size_t)i * pixel_bytes;
  2285.  
  2286.                /* Move the pixel */
  2287.                if (dp != sp)
  2288.                   memcpy(dp, sp, pixel_bytes);
  2289.  
  2290.                /* Next pixel */
  2291.                dp += pixel_bytes;
  2292.             }
  2293.             break;
  2294.          }
  2295.       }
  2296.       /* Set new row width */
  2297.       row_info->width = (row_info->width +
  2298.           png_pass_inc[pass] - 1 -
  2299.           png_pass_start[pass]) /
  2300.           png_pass_inc[pass];
  2301.  
  2302.       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
  2303.           row_info->width);
  2304.    }
  2305. }
  2306. #endif
  2307.  
  2308. /* This filters the row, chooses which filter to use, if it has not already
  2309.  * been specified by the application, and then writes the row out with the
  2310.  * chosen filter.
  2311.  */
  2312. static void png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
  2313.    png_size_t row_bytes);
  2314.  
  2315. #define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)
  2316. #define PNG_HISHIFT 10
  2317. #define PNG_LOMASK ((png_uint_32)0xffffL)
  2318. #define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
  2319. void /* PRIVATE */
  2320. png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
  2321. {
  2322.    png_bytep best_row;
  2323. #ifdef PNG_WRITE_FILTER_SUPPORTED
  2324.    png_bytep prev_row, row_buf;
  2325.    png_uint_32 mins, bpp;
  2326.    png_byte filter_to_do = png_ptr->do_filter;
  2327.    png_size_t row_bytes = row_info->rowbytes;
  2328. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2329.    int num_p_filters = png_ptr->num_prev_filters;
  2330. #endif
  2331.  
  2332.    png_debug(1, "in png_write_find_filter");
  2333.  
  2334. #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2335.   if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)
  2336.   {
  2337.      /* These will never be selected so we need not test them. */
  2338.      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);
  2339.   }
  2340. #endif
  2341.  
  2342.    /* Find out how many bytes offset each pixel is */
  2343.    bpp = (row_info->pixel_depth + 7) >> 3;
  2344.  
  2345.    prev_row = png_ptr->prev_row;
  2346. #endif
  2347.    best_row = png_ptr->row_buf;
  2348. #ifdef PNG_WRITE_FILTER_SUPPORTED
  2349.    row_buf = best_row;
  2350.    mins = PNG_MAXSUM;
  2351.  
  2352.    /* The prediction method we use is to find which method provides the
  2353.     * smallest value when summing the absolute values of the distances
  2354.     * from zero, using anything >= 128 as negative numbers.  This is known
  2355.     * as the "minimum sum of absolute differences" heuristic.  Other
  2356.     * heuristics are the "weighted minimum sum of absolute differences"
  2357.     * (experimental and can in theory improve compression), and the "zlib
  2358.     * predictive" method (not implemented yet), which does test compressions
  2359.     * of lines using different filter methods, and then chooses the
  2360.     * (series of) filter(s) that give minimum compressed data size (VERY
  2361.     * computationally expensive).
  2362.     *
  2363.     * GRR 980525:  consider also
  2364.     *
  2365.     *   (1) minimum sum of absolute differences from running average (i.e.,
  2366.     *       keep running sum of non-absolute differences & count of bytes)
  2367.     *       [track dispersion, too?  restart average if dispersion too large?]
  2368.     *
  2369.     *  (1b) minimum sum of absolute differences from sliding average, probably
  2370.     *       with window size <= deflate window (usually 32K)
  2371.     *
  2372.     *   (2) minimum sum of squared differences from zero or running average
  2373.     *       (i.e., ~ root-mean-square approach)
  2374.     */
  2375.  
  2376.  
  2377.    /* We don't need to test the 'no filter' case if this is the only filter
  2378.     * that has been chosen, as it doesn't actually do anything to the data.
  2379.     */
  2380.    if ((filter_to_do & PNG_FILTER_NONE) && filter_to_do != PNG_FILTER_NONE)
  2381.    {
  2382.       png_bytep rp;
  2383.       png_uint_32 sum = 0;
  2384.       png_size_t i;
  2385.       int v;
  2386.  
  2387.       for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
  2388.       {
  2389.          v = *rp;
  2390.          sum += (v < 128) ? v : 256 - v;
  2391.       }
  2392.  
  2393. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2394.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2395.       {
  2396.          png_uint_32 sumhi, sumlo;
  2397.          int j;
  2398.          sumlo = sum & PNG_LOMASK;
  2399.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
  2400.  
  2401.          /* Reduce the sum if we match any of the previous rows */
  2402.          for (j = 0; j < num_p_filters; j++)
  2403.          {
  2404.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
  2405.             {
  2406.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2407.                    PNG_WEIGHT_SHIFT;
  2408.  
  2409.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2410.                    PNG_WEIGHT_SHIFT;
  2411.             }
  2412.          }
  2413.  
  2414.          /* Factor in the cost of this filter (this is here for completeness,
  2415.           * but it makes no sense to have a "cost" for the NONE filter, as
  2416.           * it has the minimum possible computational cost - none).
  2417.           */
  2418.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
  2419.              PNG_COST_SHIFT;
  2420.  
  2421.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
  2422.              PNG_COST_SHIFT;
  2423.  
  2424.          if (sumhi > PNG_HIMASK)
  2425.             sum = PNG_MAXSUM;
  2426.  
  2427.          else
  2428.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2429.       }
  2430. #endif
  2431.       mins = sum;
  2432.    }
  2433.  
  2434.    /* Sub filter */
  2435.    if (filter_to_do == PNG_FILTER_SUB)
  2436.    /* It's the only filter so no testing is needed */
  2437.    {
  2438.       png_bytep rp, lp, dp;
  2439.       png_size_t i;
  2440.  
  2441.       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
  2442.            i++, rp++, dp++)
  2443.       {
  2444.          *dp = *rp;
  2445.       }
  2446.  
  2447.       for (lp = row_buf + 1; i < row_bytes;
  2448.          i++, rp++, lp++, dp++)
  2449.       {
  2450.          *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  2451.       }
  2452.  
  2453.       best_row = png_ptr->sub_row;
  2454.    }
  2455.  
  2456.    else if (filter_to_do & PNG_FILTER_SUB)
  2457.    {
  2458.       png_bytep rp, dp, lp;
  2459.       png_uint_32 sum = 0, lmins = mins;
  2460.       png_size_t i;
  2461.       int v;
  2462.  
  2463. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2464.       /* We temporarily increase the "minimum sum" by the factor we
  2465.        * would reduce the sum of this filter, so that we can do the
  2466.        * early exit comparison without scaling the sum each time.
  2467.        */
  2468.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2469.       {
  2470.          int j;
  2471.          png_uint_32 lmhi, lmlo;
  2472.          lmlo = lmins & PNG_LOMASK;
  2473.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2474.  
  2475.          for (j = 0; j < num_p_filters; j++)
  2476.          {
  2477.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
  2478.             {
  2479.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2480.                    PNG_WEIGHT_SHIFT;
  2481.  
  2482.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2483.                    PNG_WEIGHT_SHIFT;
  2484.             }
  2485.          }
  2486.  
  2487.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2488.              PNG_COST_SHIFT;
  2489.  
  2490.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2491.              PNG_COST_SHIFT;
  2492.  
  2493.          if (lmhi > PNG_HIMASK)
  2494.             lmins = PNG_MAXSUM;
  2495.  
  2496.          else
  2497.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2498.       }
  2499. #endif
  2500.  
  2501.       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
  2502.            i++, rp++, dp++)
  2503.       {
  2504.          v = *dp = *rp;
  2505.  
  2506.          sum += (v < 128) ? v : 256 - v;
  2507.       }
  2508.  
  2509.       for (lp = row_buf + 1; i < row_bytes;
  2510.          i++, rp++, lp++, dp++)
  2511.       {
  2512.          v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  2513.  
  2514.          sum += (v < 128) ? v : 256 - v;
  2515.  
  2516.          if (sum > lmins)  /* We are already worse, don't continue. */
  2517.             break;
  2518.       }
  2519.  
  2520. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2521.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2522.       {
  2523.          int j;
  2524.          png_uint_32 sumhi, sumlo;
  2525.          sumlo = sum & PNG_LOMASK;
  2526.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2527.  
  2528.          for (j = 0; j < num_p_filters; j++)
  2529.          {
  2530.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
  2531.             {
  2532.                sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
  2533.                    PNG_WEIGHT_SHIFT;
  2534.  
  2535.                sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
  2536.                    PNG_WEIGHT_SHIFT;
  2537.             }
  2538.          }
  2539.  
  2540.          sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2541.              PNG_COST_SHIFT;
  2542.  
  2543.          sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
  2544.              PNG_COST_SHIFT;
  2545.  
  2546.          if (sumhi > PNG_HIMASK)
  2547.             sum = PNG_MAXSUM;
  2548.  
  2549.          else
  2550.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2551.       }
  2552. #endif
  2553.  
  2554.       if (sum < mins)
  2555.       {
  2556.          mins = sum;
  2557.          best_row = png_ptr->sub_row;
  2558.       }
  2559.    }
  2560.  
  2561.    /* Up filter */
  2562.    if (filter_to_do == PNG_FILTER_UP)
  2563.    {
  2564.       png_bytep rp, dp, pp;
  2565.       png_size_t i;
  2566.  
  2567.       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
  2568.           pp = prev_row + 1; i < row_bytes;
  2569.           i++, rp++, pp++, dp++)
  2570.       {
  2571.          *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
  2572.       }
  2573.  
  2574.       best_row = png_ptr->up_row;
  2575.    }
  2576.  
  2577.    else if (filter_to_do & PNG_FILTER_UP)
  2578.    {
  2579.       png_bytep rp, dp, pp;
  2580.       png_uint_32 sum = 0, lmins = mins;
  2581.       png_size_t i;
  2582.       int v;
  2583.  
  2584.  
  2585. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2586.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2587.       {
  2588.          int j;
  2589.          png_uint_32 lmhi, lmlo;
  2590.          lmlo = lmins & PNG_LOMASK;
  2591.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2592.  
  2593.          for (j = 0; j < num_p_filters; j++)
  2594.          {
  2595.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
  2596.             {
  2597.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2598.                    PNG_WEIGHT_SHIFT;
  2599.  
  2600.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2601.                    PNG_WEIGHT_SHIFT;
  2602.             }
  2603.          }
  2604.  
  2605.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
  2606.              PNG_COST_SHIFT;
  2607.  
  2608.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
  2609.              PNG_COST_SHIFT;
  2610.  
  2611.          if (lmhi > PNG_HIMASK)
  2612.             lmins = PNG_MAXSUM;
  2613.  
  2614.          else
  2615.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2616.       }
  2617. #endif
  2618.  
  2619.       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
  2620.           pp = prev_row + 1; i < row_bytes; i++)
  2621.       {
  2622.          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2623.  
  2624.          sum += (v < 128) ? v : 256 - v;
  2625.  
  2626.          if (sum > lmins)  /* We are already worse, don't continue. */
  2627.             break;
  2628.       }
  2629.  
  2630. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2631.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2632.       {
  2633.          int j;
  2634.          png_uint_32 sumhi, sumlo;
  2635.          sumlo = sum & PNG_LOMASK;
  2636.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2637.  
  2638.          for (j = 0; j < num_p_filters; j++)
  2639.          {
  2640.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
  2641.             {
  2642.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2643.                    PNG_WEIGHT_SHIFT;
  2644.  
  2645.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2646.                    PNG_WEIGHT_SHIFT;
  2647.             }
  2648.          }
  2649.  
  2650.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
  2651.              PNG_COST_SHIFT;
  2652.  
  2653.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
  2654.              PNG_COST_SHIFT;
  2655.  
  2656.          if (sumhi > PNG_HIMASK)
  2657.             sum = PNG_MAXSUM;
  2658.  
  2659.          else
  2660.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2661.       }
  2662. #endif
  2663.  
  2664.       if (sum < mins)
  2665.       {
  2666.          mins = sum;
  2667.          best_row = png_ptr->up_row;
  2668.       }
  2669.    }
  2670.  
  2671.    /* Avg filter */
  2672.    if (filter_to_do == PNG_FILTER_AVG)
  2673.    {
  2674.       png_bytep rp, dp, pp, lp;
  2675.       png_uint_32 i;
  2676.  
  2677.       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
  2678.            pp = prev_row + 1; i < bpp; i++)
  2679.       {
  2680.          *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  2681.       }
  2682.  
  2683.       for (lp = row_buf + 1; i < row_bytes; i++)
  2684.       {
  2685.          *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
  2686.                  & 0xff);
  2687.       }
  2688.       best_row = png_ptr->avg_row;
  2689.    }
  2690.  
  2691.    else if (filter_to_do & PNG_FILTER_AVG)
  2692.    {
  2693.       png_bytep rp, dp, pp, lp;
  2694.       png_uint_32 sum = 0, lmins = mins;
  2695.       png_size_t i;
  2696.       int v;
  2697.  
  2698. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2699.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2700.       {
  2701.          int j;
  2702.          png_uint_32 lmhi, lmlo;
  2703.          lmlo = lmins & PNG_LOMASK;
  2704.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2705.  
  2706.          for (j = 0; j < num_p_filters; j++)
  2707.          {
  2708.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
  2709.             {
  2710.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2711.                    PNG_WEIGHT_SHIFT;
  2712.  
  2713.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2714.                    PNG_WEIGHT_SHIFT;
  2715.             }
  2716.          }
  2717.  
  2718.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2719.              PNG_COST_SHIFT;
  2720.  
  2721.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2722.              PNG_COST_SHIFT;
  2723.  
  2724.          if (lmhi > PNG_HIMASK)
  2725.             lmins = PNG_MAXSUM;
  2726.  
  2727.          else
  2728.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2729.       }
  2730. #endif
  2731.  
  2732.       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
  2733.            pp = prev_row + 1; i < bpp; i++)
  2734.       {
  2735.          v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  2736.  
  2737.          sum += (v < 128) ? v : 256 - v;
  2738.       }
  2739.  
  2740.       for (lp = row_buf + 1; i < row_bytes; i++)
  2741.       {
  2742.          v = *dp++ =
  2743.              (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
  2744.  
  2745.          sum += (v < 128) ? v : 256 - v;
  2746.  
  2747.          if (sum > lmins)  /* We are already worse, don't continue. */
  2748.             break;
  2749.       }
  2750.  
  2751. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2752.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2753.       {
  2754.          int j;
  2755.          png_uint_32 sumhi, sumlo;
  2756.          sumlo = sum & PNG_LOMASK;
  2757.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2758.  
  2759.          for (j = 0; j < num_p_filters; j++)
  2760.          {
  2761.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
  2762.             {
  2763.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2764.                    PNG_WEIGHT_SHIFT;
  2765.  
  2766.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2767.                    PNG_WEIGHT_SHIFT;
  2768.             }
  2769.          }
  2770.  
  2771.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2772.              PNG_COST_SHIFT;
  2773.  
  2774.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
  2775.              PNG_COST_SHIFT;
  2776.  
  2777.          if (sumhi > PNG_HIMASK)
  2778.             sum = PNG_MAXSUM;
  2779.  
  2780.          else
  2781.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2782.       }
  2783. #endif
  2784.  
  2785.       if (sum < mins)
  2786.       {
  2787.          mins = sum;
  2788.          best_row = png_ptr->avg_row;
  2789.       }
  2790.    }
  2791.  
  2792.    /* Paeth filter */
  2793.    if (filter_to_do == PNG_FILTER_PAETH)
  2794.    {
  2795.       png_bytep rp, dp, pp, cp, lp;
  2796.       png_size_t i;
  2797.  
  2798.       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
  2799.           pp = prev_row + 1; i < bpp; i++)
  2800.       {
  2801.          *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2802.       }
  2803.  
  2804.       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
  2805.       {
  2806.          int a, b, c, pa, pb, pc, p;
  2807.  
  2808.          b = *pp++;
  2809.          c = *cp++;
  2810.          a = *lp++;
  2811.  
  2812.          p = b - c;
  2813.          pc = a - c;
  2814.  
  2815. #ifdef PNG_USE_ABS
  2816.          pa = abs(p);
  2817.          pb = abs(pc);
  2818.          pc = abs(p + pc);
  2819. #else
  2820.          pa = p < 0 ? -p : p;
  2821.          pb = pc < 0 ? -pc : pc;
  2822.          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2823. #endif
  2824.  
  2825.          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2826.  
  2827.          *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2828.       }
  2829.       best_row = png_ptr->paeth_row;
  2830.    }
  2831.  
  2832.    else if (filter_to_do & PNG_FILTER_PAETH)
  2833.    {
  2834.       png_bytep rp, dp, pp, cp, lp;
  2835.       png_uint_32 sum = 0, lmins = mins;
  2836.       png_size_t i;
  2837.       int v;
  2838.  
  2839. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2840.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2841.       {
  2842.          int j;
  2843.          png_uint_32 lmhi, lmlo;
  2844.          lmlo = lmins & PNG_LOMASK;
  2845.          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
  2846.  
  2847.          for (j = 0; j < num_p_filters; j++)
  2848.          {
  2849.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
  2850.             {
  2851.                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
  2852.                    PNG_WEIGHT_SHIFT;
  2853.  
  2854.                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
  2855.                    PNG_WEIGHT_SHIFT;
  2856.             }
  2857.          }
  2858.  
  2859.          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2860.              PNG_COST_SHIFT;
  2861.  
  2862.          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2863.              PNG_COST_SHIFT;
  2864.  
  2865.          if (lmhi > PNG_HIMASK)
  2866.             lmins = PNG_MAXSUM;
  2867.  
  2868.          else
  2869.             lmins = (lmhi << PNG_HISHIFT) + lmlo;
  2870.       }
  2871. #endif
  2872.  
  2873.       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
  2874.           pp = prev_row + 1; i < bpp; i++)
  2875.       {
  2876.          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2877.  
  2878.          sum += (v < 128) ? v : 256 - v;
  2879.       }
  2880.  
  2881.       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
  2882.       {
  2883.          int a, b, c, pa, pb, pc, p;
  2884.  
  2885.          b = *pp++;
  2886.          c = *cp++;
  2887.          a = *lp++;
  2888.  
  2889. #ifndef PNG_SLOW_PAETH
  2890.          p = b - c;
  2891.          pc = a - c;
  2892. #ifdef PNG_USE_ABS
  2893.          pa = abs(p);
  2894.          pb = abs(pc);
  2895.          pc = abs(p + pc);
  2896. #else
  2897.          pa = p < 0 ? -p : p;
  2898.          pb = pc < 0 ? -pc : pc;
  2899.          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2900. #endif
  2901.          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2902. #else /* PNG_SLOW_PAETH */
  2903.          p = a + b - c;
  2904.          pa = abs(p - a);
  2905.          pb = abs(p - b);
  2906.          pc = abs(p - c);
  2907.  
  2908.          if (pa <= pb && pa <= pc)
  2909.             p = a;
  2910.  
  2911.          else if (pb <= pc)
  2912.             p = b;
  2913.  
  2914.          else
  2915.             p = c;
  2916. #endif /* PNG_SLOW_PAETH */
  2917.  
  2918.          v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2919.  
  2920.          sum += (v < 128) ? v : 256 - v;
  2921.  
  2922.          if (sum > lmins)  /* We are already worse, don't continue. */
  2923.             break;
  2924.       }
  2925.  
  2926. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2927.       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
  2928.       {
  2929.          int j;
  2930.          png_uint_32 sumhi, sumlo;
  2931.          sumlo = sum & PNG_LOMASK;
  2932.          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
  2933.  
  2934.          for (j = 0; j < num_p_filters; j++)
  2935.          {
  2936.             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
  2937.             {
  2938.                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
  2939.                    PNG_WEIGHT_SHIFT;
  2940.  
  2941.                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
  2942.                    PNG_WEIGHT_SHIFT;
  2943.             }
  2944.          }
  2945.  
  2946.          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2947.              PNG_COST_SHIFT;
  2948.  
  2949.          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
  2950.              PNG_COST_SHIFT;
  2951.  
  2952.          if (sumhi > PNG_HIMASK)
  2953.             sum = PNG_MAXSUM;
  2954.  
  2955.          else
  2956.             sum = (sumhi << PNG_HISHIFT) + sumlo;
  2957.       }
  2958. #endif
  2959.  
  2960.       if (sum < mins)
  2961.       {
  2962.          best_row = png_ptr->paeth_row;
  2963.       }
  2964.    }
  2965. #endif /* PNG_WRITE_FILTER_SUPPORTED */
  2966.  
  2967.    /* Do the actual writing of the filtered row data from the chosen filter. */
  2968.    png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
  2969.  
  2970. #ifdef PNG_WRITE_FILTER_SUPPORTED
  2971. #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
  2972.    /* Save the type of filter we picked this time for future calculations */
  2973.    if (png_ptr->num_prev_filters > 0)
  2974.    {
  2975.       int j;
  2976.  
  2977.       for (j = 1; j < num_p_filters; j++)
  2978.       {
  2979.          png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
  2980.       }
  2981.  
  2982.       png_ptr->prev_filters[j] = best_row[0];
  2983.    }
  2984. #endif
  2985. #endif /* PNG_WRITE_FILTER_SUPPORTED */
  2986. }
  2987.  
  2988.  
  2989. /* Do the actual writing of a previously filtered row. */
  2990. static void
  2991. png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
  2992.    png_size_t full_row_length/*includes filter byte*/)
  2993. {
  2994.    png_debug(1, "in png_write_filtered_row");
  2995.  
  2996.    png_debug1(2, "filter = %d", filtered_row[0]);
  2997.  
  2998.    png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
  2999.  
  3000.    /* Swap the current and previous rows */
  3001.    if (png_ptr->prev_row != NULL)
  3002.    {
  3003.       png_bytep tptr;
  3004.  
  3005.       tptr = png_ptr->prev_row;
  3006.       png_ptr->prev_row = png_ptr->row_buf;
  3007.       png_ptr->row_buf = tptr;
  3008.    }
  3009.  
  3010.    /* Finish row - updates counters and flushes zlib if last row */
  3011.    png_write_finish_row(png_ptr);
  3012.  
  3013. #ifdef PNG_WRITE_FLUSH_SUPPORTED
  3014.    png_ptr->flush_rows++;
  3015.  
  3016.    if (png_ptr->flush_dist > 0 &&
  3017.        png_ptr->flush_rows >= png_ptr->flush_dist)
  3018.    {
  3019.       png_write_flush(png_ptr);
  3020.    }
  3021. #endif
  3022. }
  3023. #endif /* PNG_WRITE_SUPPORTED */
  3024.