Home | History | Annotate | Download | only in libpng
      1 
      2 /* pngwrite.c - general routines to write a PNG file
      3  *
      4  * Last changed in libpng 1.6.19 [November 12, 2015]
      5  * Copyright (c) 1998-2002,2004,2006-2015 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 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
     16 #  include <errno.h>
     17 #endif /* SIMPLIFIED_WRITE_STDIO */
     18 
     19 #ifdef PNG_WRITE_SUPPORTED
     20 
     21 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
     22 /* Write out all the unknown chunks for the current given location */
     23 static void
     24 write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
     25    unsigned int where)
     26 {
     27    if (info_ptr->unknown_chunks_num != 0)
     28    {
     29       png_const_unknown_chunkp up;
     30 
     31       png_debug(5, "writing extra chunks");
     32 
     33       for (up = info_ptr->unknown_chunks;
     34            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
     35            ++up)
     36          if ((up->location & where) != 0)
     37       {
     38          /* If per-chunk unknown chunk handling is enabled use it, otherwise
     39           * just write the chunks the application has set.
     40           */
     41 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
     42          int keep = png_handle_as_unknown(png_ptr, up->name);
     43 
     44          /* NOTE: this code is radically different from the read side in the
     45           * matter of handling an ancillary unknown chunk.  In the read side
     46           * the default behavior is to discard it, in the code below the default
     47           * behavior is to write it.  Critical chunks are, however, only
     48           * written if explicitly listed or if the default is set to write all
     49           * unknown chunks.
     50           *
     51           * The default handling is also slightly weird - it is not possible to
     52           * stop the writing of all unsafe-to-copy chunks!
     53           *
     54           * TODO: REVIEW: this would seem to be a bug.
     55           */
     56          if (keep != PNG_HANDLE_CHUNK_NEVER &&
     57              ((up->name[3] & 0x20) /* safe-to-copy overrides everything */ ||
     58               keep == PNG_HANDLE_CHUNK_ALWAYS ||
     59               (keep == PNG_HANDLE_CHUNK_AS_DEFAULT &&
     60                png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS)))
     61 #endif
     62          {
     63             /* TODO: review, what is wrong with a zero length unknown chunk? */
     64             if (up->size == 0)
     65                png_warning(png_ptr, "Writing zero-length unknown chunk");
     66 
     67             png_write_chunk(png_ptr, up->name, up->data, up->size);
     68          }
     69       }
     70    }
     71 }
     72 #endif /* WRITE_UNKNOWN_CHUNKS */
     73 
     74 /* Writes all the PNG information.  This is the suggested way to use the
     75  * library.  If you have a new chunk to add, make a function to write it,
     76  * and put it in the correct location here.  If you want the chunk written
     77  * after the image data, put it in png_write_end().  I strongly encourage
     78  * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
     79  * the chunk, as that will keep the code from breaking if you want to just
     80  * write a plain PNG file.  If you have long comments, I suggest writing
     81  * them in png_write_end(), and compressing them.
     82  */
     83 void PNGAPI
     84 png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
     85 {
     86    png_debug(1, "in png_write_info_before_PLTE");
     87 
     88    if (png_ptr == NULL || info_ptr == NULL)
     89       return;
     90 
     91    if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
     92    {
     93       /* Write PNG signature */
     94       png_write_sig(png_ptr);
     95 
     96 #ifdef PNG_MNG_FEATURES_SUPPORTED
     97       if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
     98           png_ptr->mng_features_permitted != 0)
     99       {
    100          png_warning(png_ptr,
    101              "MNG features are not allowed in a PNG datastream");
    102          png_ptr->mng_features_permitted = 0;
    103       }
    104 #endif
    105 
    106       /* Write IHDR information. */
    107       png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
    108           info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
    109           info_ptr->filter_type,
    110 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    111           info_ptr->interlace_type
    112 #else
    113           0
    114 #endif
    115          );
    116 
    117       /* The rest of these check to see if the valid field has the appropriate
    118        * flag set, and if it does, writes the chunk.
    119        *
    120        * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
    121        * the chunks will be written if the WRITE routine is there and
    122        * information * is available in the COLORSPACE. (See
    123        * png_colorspace_sync_info in png.c for where the valid flags get set.)
    124        *
    125        * Under certain circumstances the colorspace can be invalidated without
    126        * syncing the info_struct 'valid' flags; this happens if libpng detects
    127        * an error and calls png_error while the color space is being set, yet
    128        * the application continues writing the PNG.  So check the 'invalid'
    129        * flag here too.
    130        */
    131 #ifdef PNG_GAMMA_SUPPORTED
    132 #  ifdef PNG_WRITE_gAMA_SUPPORTED
    133       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
    134           (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&
    135           (info_ptr->valid & PNG_INFO_gAMA) != 0)
    136          png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
    137 #  endif
    138 #endif
    139 
    140 #ifdef PNG_COLORSPACE_SUPPORTED
    141       /* Write only one of sRGB or an ICC profile.  If a profile was supplied
    142        * and it matches one of the known sRGB ones issue a warning.
    143        */
    144 #  ifdef PNG_WRITE_iCCP_SUPPORTED
    145          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
    146              (info_ptr->valid & PNG_INFO_iCCP) != 0)
    147          {
    148 #    ifdef PNG_WRITE_sRGB_SUPPORTED
    149                if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
    150                   png_app_warning(png_ptr,
    151                      "profile matches sRGB but writing iCCP instead");
    152 #     endif
    153 
    154             png_write_iCCP(png_ptr, info_ptr->iccp_name,
    155                info_ptr->iccp_profile);
    156          }
    157 #     ifdef PNG_WRITE_sRGB_SUPPORTED
    158          else
    159 #     endif
    160 #  endif
    161 
    162 #  ifdef PNG_WRITE_sRGB_SUPPORTED
    163          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
    164              (info_ptr->valid & PNG_INFO_sRGB) != 0)
    165             png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
    166 #  endif /* WRITE_sRGB */
    167 #endif /* COLORSPACE */
    168 
    169 #ifdef PNG_WRITE_sBIT_SUPPORTED
    170          if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
    171             png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
    172 #endif
    173 
    174 #ifdef PNG_COLORSPACE_SUPPORTED
    175 #  ifdef PNG_WRITE_cHRM_SUPPORTED
    176          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
    177              (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
    178              (info_ptr->valid & PNG_INFO_cHRM) != 0)
    179             png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
    180 #  endif
    181 #endif
    182 
    183 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
    184          write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
    185 #endif
    186 
    187       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
    188    }
    189 }
    190 
    191 void PNGAPI
    192 png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
    193 {
    194 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
    195    int i;
    196 #endif
    197 
    198    png_debug(1, "in png_write_info");
    199 
    200    if (png_ptr == NULL || info_ptr == NULL)
    201       return;
    202 
    203    png_write_info_before_PLTE(png_ptr, info_ptr);
    204 
    205    if ((info_ptr->valid & PNG_INFO_PLTE) != 0)
    206       png_write_PLTE(png_ptr, info_ptr->palette,
    207           (png_uint_32)info_ptr->num_palette);
    208 
    209    else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    210       png_error(png_ptr, "Valid palette required for paletted images");
    211 
    212 #ifdef PNG_WRITE_tRNS_SUPPORTED
    213    if ((info_ptr->valid & PNG_INFO_tRNS) !=0)
    214    {
    215 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
    216       /* Invert the alpha channel (in tRNS) */
    217       if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
    218           info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    219       {
    220          int j, jend;
    221 
    222          jend = info_ptr->num_trans;
    223          if (jend > PNG_MAX_PALETTE_LENGTH)
    224             jend = PNG_MAX_PALETTE_LENGTH;
    225 
    226          for (j = 0; j<jend; ++j)
    227             info_ptr->trans_alpha[j] =
    228                (png_byte)(255 - info_ptr->trans_alpha[j]);
    229       }
    230 #endif
    231       png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
    232           info_ptr->num_trans, info_ptr->color_type);
    233    }
    234 #endif
    235 #ifdef PNG_WRITE_bKGD_SUPPORTED
    236    if ((info_ptr->valid & PNG_INFO_bKGD) != 0)
    237       png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
    238 #endif
    239 
    240 #ifdef PNG_WRITE_hIST_SUPPORTED
    241    if ((info_ptr->valid & PNG_INFO_hIST) != 0)
    242       png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
    243 #endif
    244 
    245 #ifdef PNG_WRITE_oFFs_SUPPORTED
    246    if ((info_ptr->valid & PNG_INFO_oFFs) != 0)
    247       png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
    248           info_ptr->offset_unit_type);
    249 #endif
    250 
    251 #ifdef PNG_WRITE_pCAL_SUPPORTED
    252    if ((info_ptr->valid & PNG_INFO_pCAL) != 0)
    253       png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
    254           info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
    255           info_ptr->pcal_units, info_ptr->pcal_params);
    256 #endif
    257 
    258 #ifdef PNG_WRITE_sCAL_SUPPORTED
    259    if ((info_ptr->valid & PNG_INFO_sCAL) != 0)
    260       png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
    261           info_ptr->scal_s_width, info_ptr->scal_s_height);
    262 #endif /* sCAL */
    263 
    264 #ifdef PNG_WRITE_pHYs_SUPPORTED
    265    if ((info_ptr->valid & PNG_INFO_pHYs) != 0)
    266       png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
    267           info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
    268 #endif /* pHYs */
    269 
    270 #ifdef PNG_WRITE_tIME_SUPPORTED
    271    if ((info_ptr->valid & PNG_INFO_tIME) != 0)
    272    {
    273       png_write_tIME(png_ptr, &(info_ptr->mod_time));
    274       png_ptr->mode |= PNG_WROTE_tIME;
    275    }
    276 #endif /* tIME */
    277 
    278 #ifdef PNG_WRITE_sPLT_SUPPORTED
    279    if ((info_ptr->valid & PNG_INFO_sPLT) != 0)
    280       for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
    281          png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
    282 #endif /* sPLT */
    283 
    284 #ifdef PNG_WRITE_TEXT_SUPPORTED
    285    /* Check to see if we need to write text chunks */
    286    for (i = 0; i < info_ptr->num_text; i++)
    287    {
    288       png_debug2(2, "Writing header text chunk %d, type %d", i,
    289           info_ptr->text[i].compression);
    290       /* An internationalized chunk? */
    291       if (info_ptr->text[i].compression > 0)
    292       {
    293 #ifdef PNG_WRITE_iTXt_SUPPORTED
    294          /* Write international chunk */
    295          png_write_iTXt(png_ptr,
    296              info_ptr->text[i].compression,
    297              info_ptr->text[i].key,
    298              info_ptr->text[i].lang,
    299              info_ptr->text[i].lang_key,
    300              info_ptr->text[i].text);
    301          /* Mark this chunk as written */
    302          if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
    303             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
    304          else
    305             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
    306 #else
    307          png_warning(png_ptr, "Unable to write international text");
    308 #endif
    309       }
    310 
    311       /* If we want a compressed text chunk */
    312       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
    313       {
    314 #ifdef PNG_WRITE_zTXt_SUPPORTED
    315          /* Write compressed chunk */
    316          png_write_zTXt(png_ptr, info_ptr->text[i].key,
    317              info_ptr->text[i].text, info_ptr->text[i].compression);
    318          /* Mark this chunk as written */
    319          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
    320 #else
    321          png_warning(png_ptr, "Unable to write compressed text");
    322 #endif
    323       }
    324 
    325       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
    326       {
    327 #ifdef PNG_WRITE_tEXt_SUPPORTED
    328          /* Write uncompressed chunk */
    329          png_write_tEXt(png_ptr, info_ptr->text[i].key,
    330              info_ptr->text[i].text,
    331              0);
    332          /* Mark this chunk as written */
    333          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
    334 #else
    335          /* Can't get here */
    336          png_warning(png_ptr, "Unable to write uncompressed text");
    337 #endif
    338       }
    339    }
    340 #endif /* tEXt */
    341 
    342 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
    343    write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);
    344 #endif
    345 }
    346 
    347 /* Writes the end of the PNG file.  If you don't want to write comments or
    348  * time information, you can pass NULL for info.  If you already wrote these
    349  * in png_write_info(), do not write them again here.  If you have long
    350  * comments, I suggest writing them here, and compressing them.
    351  */
    352 void PNGAPI
    353 png_write_end(png_structrp png_ptr, png_inforp info_ptr)
    354 {
    355    png_debug(1, "in png_write_end");
    356 
    357    if (png_ptr == NULL)
    358       return;
    359 
    360    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
    361       png_error(png_ptr, "No IDATs written into file");
    362 
    363 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
    364    if (png_ptr->num_palette_max > png_ptr->num_palette)
    365       png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");
    366 #endif
    367 
    368    /* See if user wants us to write information chunks */
    369    if (info_ptr != NULL)
    370    {
    371 #ifdef PNG_WRITE_TEXT_SUPPORTED
    372       int i; /* local index variable */
    373 #endif
    374 #ifdef PNG_WRITE_tIME_SUPPORTED
    375       /* Check to see if user has supplied a time chunk */
    376       if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&
    377           (png_ptr->mode & PNG_WROTE_tIME) == 0)
    378          png_write_tIME(png_ptr, &(info_ptr->mod_time));
    379 
    380 #endif
    381 #ifdef PNG_WRITE_TEXT_SUPPORTED
    382       /* Loop through comment chunks */
    383       for (i = 0; i < info_ptr->num_text; i++)
    384       {
    385          png_debug2(2, "Writing trailer text chunk %d, type %d", i,
    386             info_ptr->text[i].compression);
    387          /* An internationalized chunk? */
    388          if (info_ptr->text[i].compression > 0)
    389          {
    390 #ifdef PNG_WRITE_iTXt_SUPPORTED
    391             /* Write international chunk */
    392             png_write_iTXt(png_ptr,
    393                 info_ptr->text[i].compression,
    394                 info_ptr->text[i].key,
    395                 info_ptr->text[i].lang,
    396                 info_ptr->text[i].lang_key,
    397                 info_ptr->text[i].text);
    398             /* Mark this chunk as written */
    399             if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
    400                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
    401             else
    402                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
    403 #else
    404             png_warning(png_ptr, "Unable to write international text");
    405 #endif
    406          }
    407 
    408          else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
    409          {
    410 #ifdef PNG_WRITE_zTXt_SUPPORTED
    411             /* Write compressed chunk */
    412             png_write_zTXt(png_ptr, info_ptr->text[i].key,
    413                 info_ptr->text[i].text, info_ptr->text[i].compression);
    414             /* Mark this chunk as written */
    415             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
    416 #else
    417             png_warning(png_ptr, "Unable to write compressed text");
    418 #endif
    419          }
    420 
    421          else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
    422          {
    423 #ifdef PNG_WRITE_tEXt_SUPPORTED
    424             /* Write uncompressed chunk */
    425             png_write_tEXt(png_ptr, info_ptr->text[i].key,
    426                 info_ptr->text[i].text, 0);
    427             /* Mark this chunk as written */
    428             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
    429 #else
    430             png_warning(png_ptr, "Unable to write uncompressed text");
    431 #endif
    432          }
    433       }
    434 #endif
    435 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
    436       write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);
    437 #endif
    438    }
    439 
    440    png_ptr->mode |= PNG_AFTER_IDAT;
    441 
    442    /* Write end of PNG file */
    443    png_write_IEND(png_ptr);
    444 
    445    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
    446     * and restored again in libpng-1.2.30, may cause some applications that
    447     * do not set png_ptr->output_flush_fn to crash.  If your application
    448     * experiences a problem, please try building libpng with
    449     * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
    450     * png-mng-implement at lists.sf.net .
    451     */
    452 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    453 #  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED
    454    png_flush(png_ptr);
    455 #  endif
    456 #endif
    457 }
    458 
    459 #ifdef PNG_CONVERT_tIME_SUPPORTED
    460 void PNGAPI
    461 png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
    462 {
    463    png_debug(1, "in png_convert_from_struct_tm");
    464 
    465    ptime->year = (png_uint_16)(1900 + ttime->tm_year);
    466    ptime->month = (png_byte)(ttime->tm_mon + 1);
    467    ptime->day = (png_byte)ttime->tm_mday;
    468    ptime->hour = (png_byte)ttime->tm_hour;
    469    ptime->minute = (png_byte)ttime->tm_min;
    470    ptime->second = (png_byte)ttime->tm_sec;
    471 }
    472 
    473 void PNGAPI
    474 png_convert_from_time_t(png_timep ptime, time_t ttime)
    475 {
    476    struct tm *tbuf;
    477 
    478    png_debug(1, "in png_convert_from_time_t");
    479 
    480    tbuf = gmtime(&ttime);
    481    png_convert_from_struct_tm(ptime, tbuf);
    482 }
    483 #endif
    484 
    485 /* Initialize png_ptr structure, and allocate any memory needed */
    486 PNG_FUNCTION(png_structp,PNGAPI
    487 png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
    488     png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
    489 {
    490 #ifndef PNG_USER_MEM_SUPPORTED
    491    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
    492        error_fn, warn_fn, NULL, NULL, NULL);
    493 #else
    494    return png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
    495        warn_fn, NULL, NULL, NULL);
    496 }
    497 
    498 /* Alternate initialize png_ptr structure, and allocate any memory needed */
    499 PNG_FUNCTION(png_structp,PNGAPI
    500 png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
    501     png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
    502     png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
    503 {
    504    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
    505        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
    506 #endif /* USER_MEM */
    507    if (png_ptr != NULL)
    508    {
    509       /* Set the zlib control values to defaults; they can be overridden by the
    510        * application after the struct has been created.
    511        */
    512       png_ptr->zbuffer_size = PNG_ZBUF_SIZE;
    513 
    514       /* The 'zlib_strategy' setting is irrelevant because png_default_claim in
    515        * pngwutil.c defaults it according to whether or not filters will be
    516        * used, and ignores this setting.
    517        */
    518       png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;
    519       png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;
    520       png_ptr->zlib_mem_level = 8;
    521       png_ptr->zlib_window_bits = 15;
    522       png_ptr->zlib_method = 8;
    523 
    524 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
    525       png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;
    526       png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;
    527       png_ptr->zlib_text_mem_level = 8;
    528       png_ptr->zlib_text_window_bits = 15;
    529       png_ptr->zlib_text_method = 8;
    530 #endif /* WRITE_COMPRESSED_TEXT */
    531 
    532       /* This is a highly dubious configuration option; by default it is off,
    533        * but it may be appropriate for private builds that are testing
    534        * extensions not conformant to the current specification, or of
    535        * applications that must not fail to write at all costs!
    536        */
    537 #ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED
    538       /* In stable builds only warn if an application error can be completely
    539        * handled.
    540        */
    541       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
    542 #endif
    543 
    544       /* App warnings are warnings in release (or release candidate) builds but
    545        * are errors during development.
    546        */
    547 #if PNG_RELEASE_BUILD
    548       png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
    549 #endif
    550 
    551       /* TODO: delay this, it can be done in png_init_io() (if the app doesn't
    552        * do it itself) avoiding setting the default function if it is not
    553        * required.
    554        */
    555       png_set_write_fn(png_ptr, NULL, NULL, NULL);
    556    }
    557 
    558    return png_ptr;
    559 }
    560 
    561 
    562 /* Write a few rows of image data.  If the image is interlaced,
    563  * either you will have to write the 7 sub images, or, if you
    564  * have called png_set_interlace_handling(), you will have to
    565  * "write" the image seven times.
    566  */
    567 void PNGAPI
    568 png_write_rows(png_structrp png_ptr, png_bytepp row,
    569     png_uint_32 num_rows)
    570 {
    571    png_uint_32 i; /* row counter */
    572    png_bytepp rp; /* row pointer */
    573 
    574    png_debug(1, "in png_write_rows");
    575 
    576    if (png_ptr == NULL)
    577       return;
    578 
    579    /* Loop through the rows */
    580    for (i = 0, rp = row; i < num_rows; i++, rp++)
    581    {
    582       png_write_row(png_ptr, *rp);
    583    }
    584 }
    585 
    586 /* Write the image.  You only need to call this function once, even
    587  * if you are writing an interlaced image.
    588  */
    589 void PNGAPI
    590 png_write_image(png_structrp png_ptr, png_bytepp image)
    591 {
    592    png_uint_32 i; /* row index */
    593    int pass, num_pass; /* pass variables */
    594    png_bytepp rp; /* points to current row */
    595 
    596    if (png_ptr == NULL)
    597       return;
    598 
    599    png_debug(1, "in png_write_image");
    600 
    601 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    602    /* Initialize interlace handling.  If image is not interlaced,
    603     * this will set pass to 1
    604     */
    605    num_pass = png_set_interlace_handling(png_ptr);
    606 #else
    607    num_pass = 1;
    608 #endif
    609    /* Loop through passes */
    610    for (pass = 0; pass < num_pass; pass++)
    611    {
    612       /* Loop through image */
    613       for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
    614       {
    615          png_write_row(png_ptr, *rp);
    616       }
    617    }
    618 }
    619 
    620 #ifdef PNG_MNG_FEATURES_SUPPORTED
    621 /* Performs intrapixel differencing  */
    622 static void
    623 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
    624 {
    625    png_debug(1, "in png_do_write_intrapixel");
    626 
    627    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
    628    {
    629       int bytes_per_pixel;
    630       png_uint_32 row_width = row_info->width;
    631       if (row_info->bit_depth == 8)
    632       {
    633          png_bytep rp;
    634          png_uint_32 i;
    635 
    636          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
    637             bytes_per_pixel = 3;
    638 
    639          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
    640             bytes_per_pixel = 4;
    641 
    642          else
    643             return;
    644 
    645          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
    646          {
    647             *(rp)     = (png_byte)(*rp       - *(rp + 1));
    648             *(rp + 2) = (png_byte)(*(rp + 2) - *(rp + 1));
    649          }
    650       }
    651 
    652 #ifdef PNG_WRITE_16BIT_SUPPORTED
    653       else if (row_info->bit_depth == 16)
    654       {
    655          png_bytep rp;
    656          png_uint_32 i;
    657 
    658          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
    659             bytes_per_pixel = 6;
    660 
    661          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
    662             bytes_per_pixel = 8;
    663 
    664          else
    665             return;
    666 
    667          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
    668          {
    669             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
    670             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
    671             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
    672             png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
    673             png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
    674             *(rp    ) = (png_byte)(red >> 8);
    675             *(rp + 1) = (png_byte)red;
    676             *(rp + 4) = (png_byte)(blue >> 8);
    677             *(rp + 5) = (png_byte)blue;
    678          }
    679       }
    680 #endif /* WRITE_16BIT */
    681    }
    682 }
    683 #endif /* MNG_FEATURES */
    684 
    685 /* Called by user to write a row of image data */
    686 void PNGAPI
    687 png_write_row(png_structrp png_ptr, png_const_bytep row)
    688 {
    689    /* 1.5.6: moved from png_struct to be a local structure: */
    690    png_row_info row_info;
    691 
    692    if (png_ptr == NULL)
    693       return;
    694 
    695    png_debug2(1, "in png_write_row (row %u, pass %d)",
    696       png_ptr->row_number, png_ptr->pass);
    697 
    698    /* Initialize transformations and other stuff if first time */
    699    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
    700    {
    701       /* Make sure we wrote the header info */
    702       if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
    703          png_error(png_ptr,
    704              "png_write_info was never called before png_write_row");
    705 
    706       /* Check for transforms that have been set but were defined out */
    707 #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
    708       if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
    709          png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
    710 #endif
    711 
    712 #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
    713       if ((png_ptr->transformations & PNG_FILLER) != 0)
    714          png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
    715 #endif
    716 #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
    717     defined(PNG_READ_PACKSWAP_SUPPORTED)
    718       if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
    719          png_warning(png_ptr,
    720              "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
    721 #endif
    722 
    723 #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
    724       if ((png_ptr->transformations & PNG_PACK) != 0)
    725          png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
    726 #endif
    727 
    728 #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
    729       if ((png_ptr->transformations & PNG_SHIFT) != 0)
    730          png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
    731 #endif
    732 
    733 #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
    734       if ((png_ptr->transformations & PNG_BGR) != 0)
    735          png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
    736 #endif
    737 
    738 #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
    739       if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
    740          png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
    741 #endif
    742 
    743       png_write_start_row(png_ptr);
    744    }
    745 
    746 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    747    /* If interlaced and not interested in row, return */
    748    if (png_ptr->interlaced != 0 &&
    749        (png_ptr->transformations & PNG_INTERLACE) != 0)
    750    {
    751       switch (png_ptr->pass)
    752       {
    753          case 0:
    754             if ((png_ptr->row_number & 0x07) != 0)
    755             {
    756                png_write_finish_row(png_ptr);
    757                return;
    758             }
    759             break;
    760 
    761          case 1:
    762             if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)
    763             {
    764                png_write_finish_row(png_ptr);
    765                return;
    766             }
    767             break;
    768 
    769          case 2:
    770             if ((png_ptr->row_number & 0x07) != 4)
    771             {
    772                png_write_finish_row(png_ptr);
    773                return;
    774             }
    775             break;
    776 
    777          case 3:
    778             if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)
    779             {
    780                png_write_finish_row(png_ptr);
    781                return;
    782             }
    783             break;
    784 
    785          case 4:
    786             if ((png_ptr->row_number & 0x03) != 2)
    787             {
    788                png_write_finish_row(png_ptr);
    789                return;
    790             }
    791             break;
    792 
    793          case 5:
    794             if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)
    795             {
    796                png_write_finish_row(png_ptr);
    797                return;
    798             }
    799             break;
    800 
    801          case 6:
    802             if ((png_ptr->row_number & 0x01) == 0)
    803             {
    804                png_write_finish_row(png_ptr);
    805                return;
    806             }
    807             break;
    808 
    809          default: /* error: ignore it */
    810             break;
    811       }
    812    }
    813 #endif
    814 
    815    /* Set up row info for transformations */
    816    row_info.color_type = png_ptr->color_type;
    817    row_info.width = png_ptr->usr_width;
    818    row_info.channels = png_ptr->usr_channels;
    819    row_info.bit_depth = png_ptr->usr_bit_depth;
    820    row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
    821    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
    822 
    823    png_debug1(3, "row_info->color_type = %d", row_info.color_type);
    824    png_debug1(3, "row_info->width = %u", row_info.width);
    825    png_debug1(3, "row_info->channels = %d", row_info.channels);
    826    png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth);
    827    png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth);
    828    png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes);
    829 
    830    /* Copy user's row into buffer, leaving room for filter byte. */
    831    memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);
    832 
    833 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    834    /* Handle interlacing */
    835    if (png_ptr->interlaced && png_ptr->pass < 6 &&
    836        (png_ptr->transformations & PNG_INTERLACE) != 0)
    837    {
    838       png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);
    839       /* This should always get caught above, but still ... */
    840       if (row_info.width == 0)
    841       {
    842          png_write_finish_row(png_ptr);
    843          return;
    844       }
    845    }
    846 #endif
    847 
    848 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
    849    /* Handle other transformations */
    850    if (png_ptr->transformations != 0)
    851       png_do_write_transformations(png_ptr, &row_info);
    852 #endif
    853 
    854    /* At this point the row_info pixel depth must match the 'transformed' depth,
    855     * which is also the output depth.
    856     */
    857    if (row_info.pixel_depth != png_ptr->pixel_depth ||
    858        row_info.pixel_depth != png_ptr->transformed_pixel_depth)
    859       png_error(png_ptr, "internal write transform logic error");
    860 
    861 #ifdef PNG_MNG_FEATURES_SUPPORTED
    862    /* Write filter_method 64 (intrapixel differencing) only if
    863     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
    864     * 2. Libpng did not write a PNG signature (this filter_method is only
    865     *    used in PNG datastreams that are embedded in MNG datastreams) and
    866     * 3. The application called png_permit_mng_features with a mask that
    867     *    included PNG_FLAG_MNG_FILTER_64 and
    868     * 4. The filter_method is 64 and
    869     * 5. The color_type is RGB or RGBA
    870     */
    871    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
    872        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
    873    {
    874       /* Intrapixel differencing */
    875       png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);
    876    }
    877 #endif
    878 
    879 /* Added at libpng-1.5.10 */
    880 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
    881    /* Check for out-of-range palette index */
    882    if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&
    883        png_ptr->num_palette_max >= 0)
    884       png_do_check_palette_indexes(png_ptr, &row_info);
    885 #endif
    886 
    887    /* Find a filter if necessary, filter the row and write it out. */
    888    png_write_find_filter(png_ptr, &row_info);
    889 
    890    if (png_ptr->write_row_fn != NULL)
    891       (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
    892 }
    893 
    894 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    895 /* Set the automatic flush interval or 0 to turn flushing off */
    896 void PNGAPI
    897 png_set_flush(png_structrp png_ptr, int nrows)
    898 {
    899    png_debug(1, "in png_set_flush");
    900 
    901    if (png_ptr == NULL)
    902       return;
    903 
    904    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
    905 }
    906 
    907 /* Flush the current output buffers now */
    908 void PNGAPI
    909 png_write_flush(png_structrp png_ptr)
    910 {
    911    png_debug(1, "in png_write_flush");
    912 
    913    if (png_ptr == NULL)
    914       return;
    915 
    916    /* We have already written out all of the data */
    917    if (png_ptr->row_number >= png_ptr->num_rows)
    918       return;
    919 
    920    png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);
    921    png_ptr->flush_rows = 0;
    922    png_flush(png_ptr);
    923 }
    924 #endif /* WRITE_FLUSH */
    925 
    926 /* Free any memory used in png_ptr struct without freeing the struct itself. */
    927 static void
    928 png_write_destroy(png_structrp png_ptr)
    929 {
    930    png_debug(1, "in png_write_destroy");
    931 
    932    /* Free any memory zlib uses */
    933    if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
    934       deflateEnd(&png_ptr->zstream);
    935 
    936    /* Free our memory.  png_free checks NULL for us. */
    937    png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
    938    png_free(png_ptr, png_ptr->row_buf);
    939    png_ptr->row_buf = NULL;
    940 #ifdef PNG_WRITE_FILTER_SUPPORTED
    941    png_free(png_ptr, png_ptr->prev_row);
    942    png_free(png_ptr, png_ptr->try_row);
    943    png_free(png_ptr, png_ptr->tst_row);
    944    png_ptr->prev_row = NULL;
    945    png_ptr->try_row = NULL;
    946    png_ptr->tst_row = NULL;
    947 #endif
    948 
    949 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
    950    png_free(png_ptr, png_ptr->chunk_list);
    951    png_ptr->chunk_list = NULL;
    952 #endif
    953 
    954    /* The error handling and memory handling information is left intact at this
    955     * point: the jmp_buf may still have to be freed.  See png_destroy_png_struct
    956     * for how this happens.
    957     */
    958 }
    959 
    960 /* Free all memory used by the write.
    961  * In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for
    962  * *png_ptr_ptr.  Prior to 1.6.0 it would accept such a value and it would free
    963  * the passed in info_structs but it would quietly fail to free any of the data
    964  * inside them.  In 1.6.0 it quietly does nothing (it has to be quiet because it
    965  * has no png_ptr.)
    966  */
    967 void PNGAPI
    968 png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
    969 {
    970    png_debug(1, "in png_destroy_write_struct");
    971 
    972    if (png_ptr_ptr != NULL)
    973    {
    974       png_structrp png_ptr = *png_ptr_ptr;
    975 
    976       if (png_ptr != NULL) /* added in libpng 1.6.0 */
    977       {
    978          png_destroy_info_struct(png_ptr, info_ptr_ptr);
    979 
    980          *png_ptr_ptr = NULL;
    981          png_write_destroy(png_ptr);
    982          png_destroy_png_struct(png_ptr);
    983       }
    984    }
    985 }
    986 
    987 /* Allow the application to select one or more row filters to use. */
    988 void PNGAPI
    989 png_set_filter(png_structrp png_ptr, int method, int filters)
    990 {
    991    png_debug(1, "in png_set_filter");
    992 
    993    if (png_ptr == NULL)
    994       return;
    995 
    996 #ifdef PNG_MNG_FEATURES_SUPPORTED
    997    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
    998        (method == PNG_INTRAPIXEL_DIFFERENCING))
    999       method = PNG_FILTER_TYPE_BASE;
   1000 
   1001 #endif
   1002    if (method == PNG_FILTER_TYPE_BASE)
   1003    {
   1004       switch (filters & (PNG_ALL_FILTERS | 0x07))
   1005       {
   1006 #ifdef PNG_WRITE_FILTER_SUPPORTED
   1007          case 5:
   1008          case 6:
   1009          case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
   1010             /* FALL THROUGH */
   1011 #endif /* WRITE_FILTER */
   1012          case PNG_FILTER_VALUE_NONE:
   1013             png_ptr->do_filter = PNG_FILTER_NONE; break;
   1014 
   1015 #ifdef PNG_WRITE_FILTER_SUPPORTED
   1016          case PNG_FILTER_VALUE_SUB:
   1017             png_ptr->do_filter = PNG_FILTER_SUB; break;
   1018 
   1019          case PNG_FILTER_VALUE_UP:
   1020             png_ptr->do_filter = PNG_FILTER_UP; break;
   1021 
   1022          case PNG_FILTER_VALUE_AVG:
   1023             png_ptr->do_filter = PNG_FILTER_AVG; break;
   1024 
   1025          case PNG_FILTER_VALUE_PAETH:
   1026             png_ptr->do_filter = PNG_FILTER_PAETH; break;
   1027 
   1028          default:
   1029             png_ptr->do_filter = (png_byte)filters; break;
   1030 #else
   1031          default:
   1032             png_app_error(png_ptr, "Unknown row filter for method 0");
   1033 #endif /* WRITE_FILTER */
   1034       }
   1035 
   1036 #ifdef PNG_WRITE_FILTER_SUPPORTED
   1037       /* If we have allocated the row_buf, this means we have already started
   1038        * with the image and we should have allocated all of the filter buffers
   1039        * that have been selected.  If prev_row isn't already allocated, then
   1040        * it is too late to start using the filters that need it, since we
   1041        * will be missing the data in the previous row.  If an application
   1042        * wants to start and stop using particular filters during compression,
   1043        * it should start out with all of the filters, and then remove them
   1044        * or add them back after the start of compression.
   1045        *
   1046        * NOTE: this is a nasty constraint on the code, because it means that the
   1047        * prev_row buffer must be maintained even if there are currently no
   1048        * 'prev_row' requiring filters active.
   1049        */
   1050       if (png_ptr->row_buf != NULL)
   1051       {
   1052          int num_filters;
   1053          png_alloc_size_t buf_size;
   1054 
   1055          /* Repeat the checks in png_write_start_row; 1 pixel high or wide
   1056           * images cannot benefit from certain filters.  If this isn't done here
   1057           * the check below will fire on 1 pixel high images.
   1058           */
   1059          if (png_ptr->height == 1)
   1060             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
   1061 
   1062          if (png_ptr->width == 1)
   1063             filters &= ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
   1064 
   1065          if ((filters & (PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH)) != 0
   1066             && png_ptr->prev_row == NULL)
   1067          {
   1068             /* This is the error case, however it is benign - the previous row
   1069              * is not available so the filter can't be used.  Just warn here.
   1070              */
   1071             png_app_warning(png_ptr,
   1072                "png_set_filter: UP/AVG/PAETH cannot be added after start");
   1073             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
   1074          }
   1075 
   1076          num_filters = 0;
   1077 
   1078          if (filters & PNG_FILTER_SUB)
   1079             num_filters++;
   1080 
   1081          if (filters & PNG_FILTER_UP)
   1082             num_filters++;
   1083 
   1084          if (filters & PNG_FILTER_AVG)
   1085             num_filters++;
   1086 
   1087          if (filters & PNG_FILTER_PAETH)
   1088             num_filters++;
   1089 
   1090          /* Allocate needed row buffers if they have not already been
   1091           * allocated.
   1092           */
   1093          buf_size = PNG_ROWBYTES(png_ptr->usr_channels * png_ptr->usr_bit_depth,
   1094              png_ptr->width) + 1;
   1095 
   1096          if (png_ptr->try_row == NULL)
   1097             png_ptr->try_row = png_voidcast(png_bytep,
   1098                png_malloc(png_ptr, buf_size));
   1099 
   1100          if (num_filters > 1)
   1101          {
   1102             if (png_ptr->tst_row == NULL)
   1103                png_ptr->tst_row = png_voidcast(png_bytep,
   1104                   png_malloc(png_ptr, buf_size));
   1105          }
   1106       }
   1107       png_ptr->do_filter = (png_byte)filters;
   1108 #endif
   1109    }
   1110    else
   1111       png_error(png_ptr, "Unknown custom filter method");
   1112 }
   1113 
   1114 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
   1115 /* Provide floating and fixed point APIs */
   1116 #ifdef PNG_FLOATING_POINT_SUPPORTED
   1117 void PNGAPI
   1118 png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
   1119     int num_weights, png_const_doublep filter_weights,
   1120     png_const_doublep filter_costs)
   1121 {
   1122    PNG_UNUSED(png_ptr)
   1123    PNG_UNUSED(heuristic_method)
   1124    PNG_UNUSED(num_weights)
   1125    PNG_UNUSED(filter_weights)
   1126    PNG_UNUSED(filter_costs)
   1127 }
   1128 #endif /* FLOATING_POINT */
   1129 
   1130 #ifdef PNG_FIXED_POINT_SUPPORTED
   1131 void PNGAPI
   1132 png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
   1133     int num_weights, png_const_fixed_point_p filter_weights,
   1134     png_const_fixed_point_p filter_costs)
   1135 {
   1136    PNG_UNUSED(png_ptr)
   1137    PNG_UNUSED(heuristic_method)
   1138    PNG_UNUSED(num_weights)
   1139    PNG_UNUSED(filter_weights)
   1140    PNG_UNUSED(filter_costs)
   1141 }
   1142 #endif /* FIXED_POINT */
   1143 #endif /* WRITE_WEIGHTED_FILTER */
   1144 
   1145 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
   1146 void PNGAPI
   1147 png_set_compression_level(png_structrp png_ptr, int level)
   1148 {
   1149    png_debug(1, "in png_set_compression_level");
   1150 
   1151    if (png_ptr == NULL)
   1152       return;
   1153 
   1154    png_ptr->zlib_level = level;
   1155 }
   1156 
   1157 void PNGAPI
   1158 png_set_compression_mem_level(png_structrp png_ptr, int mem_level)
   1159 {
   1160    png_debug(1, "in png_set_compression_mem_level");
   1161 
   1162    if (png_ptr == NULL)
   1163       return;
   1164 
   1165    png_ptr->zlib_mem_level = mem_level;
   1166 }
   1167 
   1168 void PNGAPI
   1169 png_set_compression_strategy(png_structrp png_ptr, int strategy)
   1170 {
   1171    png_debug(1, "in png_set_compression_strategy");
   1172 
   1173    if (png_ptr == NULL)
   1174       return;
   1175 
   1176    /* The flag setting here prevents the libpng dynamic selection of strategy.
   1177     */
   1178    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
   1179    png_ptr->zlib_strategy = strategy;
   1180 }
   1181 
   1182 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
   1183  * smaller value of window_bits if it can do so safely.
   1184  */
   1185 void PNGAPI
   1186 png_set_compression_window_bits(png_structrp png_ptr, int window_bits)
   1187 {
   1188    if (png_ptr == NULL)
   1189       return;
   1190 
   1191    /* Prior to 1.6.0 this would warn but then set the window_bits value. This
   1192     * meant that negative window bits values could be selected that would cause
   1193     * libpng to write a non-standard PNG file with raw deflate or gzip
   1194     * compressed IDAT or ancillary chunks.  Such files can be read and there is
   1195     * no warning on read, so this seems like a very bad idea.
   1196     */
   1197    if (window_bits > 15)
   1198    {
   1199       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
   1200       window_bits = 15;
   1201    }
   1202 
   1203    else if (window_bits < 8)
   1204    {
   1205       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
   1206       window_bits = 8;
   1207    }
   1208 
   1209    png_ptr->zlib_window_bits = window_bits;
   1210 }
   1211 
   1212 void PNGAPI
   1213 png_set_compression_method(png_structrp png_ptr, int method)
   1214 {
   1215    png_debug(1, "in png_set_compression_method");
   1216 
   1217    if (png_ptr == NULL)
   1218       return;
   1219 
   1220    /* This would produce an invalid PNG file if it worked, but it doesn't and
   1221     * deflate will fault it, so it is harmless to just warn here.
   1222     */
   1223    if (method != 8)
   1224       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
   1225 
   1226    png_ptr->zlib_method = method;
   1227 }
   1228 #endif /* WRITE_CUSTOMIZE_COMPRESSION */
   1229 
   1230 /* The following were added to libpng-1.5.4 */
   1231 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
   1232 void PNGAPI
   1233 png_set_text_compression_level(png_structrp png_ptr, int level)
   1234 {
   1235    png_debug(1, "in png_set_text_compression_level");
   1236 
   1237    if (png_ptr == NULL)
   1238       return;
   1239 
   1240    png_ptr->zlib_text_level = level;
   1241 }
   1242 
   1243 void PNGAPI
   1244 png_set_text_compression_mem_level(png_structrp png_ptr, int mem_level)
   1245 {
   1246    png_debug(1, "in png_set_text_compression_mem_level");
   1247 
   1248    if (png_ptr == NULL)
   1249       return;
   1250 
   1251    png_ptr->zlib_text_mem_level = mem_level;
   1252 }
   1253 
   1254 void PNGAPI
   1255 png_set_text_compression_strategy(png_structrp png_ptr, int strategy)
   1256 {
   1257    png_debug(1, "in png_set_text_compression_strategy");
   1258 
   1259    if (png_ptr == NULL)
   1260       return;
   1261 
   1262    png_ptr->zlib_text_strategy = strategy;
   1263 }
   1264 
   1265 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
   1266  * smaller value of window_bits if it can do so safely.
   1267  */
   1268 void PNGAPI
   1269 png_set_text_compression_window_bits(png_structrp png_ptr, int window_bits)
   1270 {
   1271    if (png_ptr == NULL)
   1272       return;
   1273 
   1274    if (window_bits > 15)
   1275    {
   1276       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
   1277       window_bits = 15;
   1278    }
   1279 
   1280    else if (window_bits < 8)
   1281    {
   1282       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
   1283       window_bits = 8;
   1284    }
   1285 
   1286    png_ptr->zlib_text_window_bits = window_bits;
   1287 }
   1288 
   1289 void PNGAPI
   1290 png_set_text_compression_method(png_structrp png_ptr, int method)
   1291 {
   1292    png_debug(1, "in png_set_text_compression_method");
   1293 
   1294    if (png_ptr == NULL)
   1295       return;
   1296 
   1297    if (method != 8)
   1298       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
   1299 
   1300    png_ptr->zlib_text_method = method;
   1301 }
   1302 #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
   1303 /* end of API added to libpng-1.5.4 */
   1304 
   1305 void PNGAPI
   1306 png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn)
   1307 {
   1308    if (png_ptr == NULL)
   1309       return;
   1310 
   1311    png_ptr->write_row_fn = write_row_fn;
   1312 }
   1313 
   1314 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
   1315 void PNGAPI
   1316 png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
   1317     write_user_transform_fn)
   1318 {
   1319    png_debug(1, "in png_set_write_user_transform_fn");
   1320 
   1321    if (png_ptr == NULL)
   1322       return;
   1323 
   1324    png_ptr->transformations |= PNG_USER_TRANSFORM;
   1325    png_ptr->write_user_transform_fn = write_user_transform_fn;
   1326 }
   1327 #endif
   1328 
   1329 
   1330 #ifdef PNG_INFO_IMAGE_SUPPORTED
   1331 void PNGAPI
   1332 png_write_png(png_structrp png_ptr, png_inforp info_ptr,
   1333     int transforms, voidp params)
   1334 {
   1335    if (png_ptr == NULL || info_ptr == NULL)
   1336       return;
   1337 
   1338    if ((info_ptr->valid & PNG_INFO_IDAT) == 0)
   1339    {
   1340       png_app_error(png_ptr, "no rows for png_write_image to write");
   1341       return;
   1342    }
   1343 
   1344    /* Write the file header information. */
   1345    png_write_info(png_ptr, info_ptr);
   1346 
   1347    /* ------ these transformations don't touch the info structure ------- */
   1348 
   1349    /* Invert monochrome pixels */
   1350    if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
   1351 #ifdef PNG_WRITE_INVERT_SUPPORTED
   1352       png_set_invert_mono(png_ptr);
   1353 #else
   1354       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
   1355 #endif
   1356 
   1357    /* Shift the pixels up to a legal bit depth and fill in
   1358     * as appropriate to correctly scale the image.
   1359     */
   1360    if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
   1361 #ifdef PNG_WRITE_SHIFT_SUPPORTED
   1362       if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
   1363          png_set_shift(png_ptr, &info_ptr->sig_bit);
   1364 #else
   1365       png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
   1366 #endif
   1367 
   1368    /* Pack pixels into bytes */
   1369    if ((transforms & PNG_TRANSFORM_PACKING) != 0)
   1370 #ifdef PNG_WRITE_PACK_SUPPORTED
   1371       png_set_packing(png_ptr);
   1372 #else
   1373       png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
   1374 #endif
   1375 
   1376    /* Swap location of alpha bytes from ARGB to RGBA */
   1377    if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
   1378 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
   1379       png_set_swap_alpha(png_ptr);
   1380 #else
   1381       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
   1382 #endif
   1383 
   1384    /* Remove a filler (X) from XRGB/RGBX/AG/GA into to convert it into
   1385     * RGB, note that the code expects the input color type to be G or RGB; no
   1386     * alpha channel.
   1387     */
   1388    if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
   1389        PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
   1390    {
   1391 #ifdef PNG_WRITE_FILLER_SUPPORTED
   1392       if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
   1393       {
   1394          if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
   1395             png_app_error(png_ptr,
   1396                 "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
   1397 
   1398          /* Continue if ignored - this is the pre-1.6.10 behavior */
   1399          png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
   1400       }
   1401 
   1402       else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
   1403          png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
   1404 #else
   1405       png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported");
   1406 #endif
   1407    }
   1408 
   1409    /* Flip BGR pixels to RGB */
   1410    if ((transforms & PNG_TRANSFORM_BGR) != 0)
   1411 #ifdef PNG_WRITE_BGR_SUPPORTED
   1412       png_set_bgr(png_ptr);
   1413 #else
   1414       png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
   1415 #endif
   1416 
   1417    /* Swap bytes of 16-bit files to most significant byte first */
   1418    if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
   1419 #ifdef PNG_WRITE_SWAP_SUPPORTED
   1420       png_set_swap(png_ptr);
   1421 #else
   1422       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
   1423 #endif
   1424 
   1425    /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */
   1426    if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
   1427 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
   1428       png_set_packswap(png_ptr);
   1429 #else
   1430       png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
   1431 #endif
   1432 
   1433    /* Invert the alpha channel from opacity to transparency */
   1434    if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
   1435 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
   1436       png_set_invert_alpha(png_ptr);
   1437 #else
   1438       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
   1439 #endif
   1440 
   1441    /* ----------------------- end of transformations ------------------- */
   1442 
   1443    /* Write the bits */
   1444    png_write_image(png_ptr, info_ptr->row_pointers);
   1445 
   1446    /* It is REQUIRED to call this to finish writing the rest of the file */
   1447    png_write_end(png_ptr, info_ptr);
   1448 
   1449    PNG_UNUSED(params)
   1450 }
   1451 #endif
   1452 
   1453 
   1454 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
   1455 /* Initialize the write structure - general purpose utility. */
   1456 static int
   1457 png_image_write_init(png_imagep image)
   1458 {
   1459    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
   1460        png_safe_error, png_safe_warning);
   1461 
   1462    if (png_ptr != NULL)
   1463    {
   1464       png_infop info_ptr = png_create_info_struct(png_ptr);
   1465 
   1466       if (info_ptr != NULL)
   1467       {
   1468          png_controlp control = png_voidcast(png_controlp,
   1469              png_malloc_warn(png_ptr, (sizeof *control)));
   1470 
   1471          if (control != NULL)
   1472          {
   1473             memset(control, 0, (sizeof *control));
   1474 
   1475             control->png_ptr = png_ptr;
   1476             control->info_ptr = info_ptr;
   1477             control->for_write = 1;
   1478 
   1479             image->opaque = control;
   1480             return 1;
   1481          }
   1482 
   1483          /* Error clean up */
   1484          png_destroy_info_struct(png_ptr, &info_ptr);
   1485       }
   1486 
   1487       png_destroy_write_struct(&png_ptr, NULL);
   1488    }
   1489 
   1490    return png_image_error(image, "png_image_write_: out of memory");
   1491 }
   1492 
   1493 /* Arguments to png_image_write_main: */
   1494 typedef struct
   1495 {
   1496    /* Arguments: */
   1497    png_imagep      image;
   1498    png_const_voidp buffer;
   1499    png_int_32      row_stride;
   1500    png_const_voidp colormap;
   1501    int             convert_to_8bit;
   1502    /* Local variables: */
   1503    png_const_voidp first_row;
   1504    ptrdiff_t       row_bytes;
   1505    png_voidp       local_row;
   1506    /* Byte count for memory writing */
   1507    png_bytep        memory;
   1508    png_alloc_size_t memory_bytes; /* not used for STDIO */
   1509    png_alloc_size_t output_bytes; /* running total */
   1510 } png_image_write_control;
   1511 
   1512 /* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to
   1513  * do any necessary byte swapping.  The component order is defined by the
   1514  * png_image format value.
   1515  */
   1516 static int
   1517 png_write_image_16bit(png_voidp argument)
   1518 {
   1519    png_image_write_control *display = png_voidcast(png_image_write_control*,
   1520        argument);
   1521    png_imagep image = display->image;
   1522    png_structrp png_ptr = image->opaque->png_ptr;
   1523 
   1524    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
   1525        display->first_row);
   1526    png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
   1527    png_uint_16p row_end;
   1528    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
   1529    int aindex = 0;
   1530    png_uint_32 y = image->height;
   1531 
   1532    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
   1533    {
   1534 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
   1535       if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
   1536       {
   1537          aindex = -1;
   1538          ++input_row; /* To point to the first component */
   1539          ++output_row;
   1540       }
   1541          else
   1542             aindex = channels;
   1543 #     else
   1544          aindex = channels;
   1545 #     endif
   1546    }
   1547 
   1548    else
   1549       png_error(png_ptr, "png_write_image: internal call error");
   1550 
   1551    /* Work out the output row end and count over this, note that the increment
   1552     * above to 'row' means that row_end can actually be beyond the end of the
   1553     * row; this is correct.
   1554     */
   1555    row_end = output_row + image->width * (channels+1);
   1556 
   1557    while (y-- > 0)
   1558    {
   1559       png_const_uint_16p in_ptr = input_row;
   1560       png_uint_16p out_ptr = output_row;
   1561 
   1562       while (out_ptr < row_end)
   1563       {
   1564          const png_uint_16 alpha = in_ptr[aindex];
   1565          png_uint_32 reciprocal = 0;
   1566          int c;
   1567 
   1568          out_ptr[aindex] = alpha;
   1569 
   1570          /* Calculate a reciprocal.  The correct calculation is simply
   1571           * component/alpha*65535 << 15. (I.e. 15 bits of precision); this
   1572           * allows correct rounding by adding .5 before the shift.  'reciprocal'
   1573           * is only initialized when required.
   1574           */
   1575          if (alpha > 0 && alpha < 65535)
   1576             reciprocal = ((0xffff<<15)+(alpha>>1))/alpha;
   1577 
   1578          c = channels;
   1579          do /* always at least one channel */
   1580          {
   1581             png_uint_16 component = *in_ptr++;
   1582 
   1583             /* The following gives 65535 for an alpha of 0, which is fine,
   1584              * otherwise if 0/0 is represented as some other value there is more
   1585              * likely to be a discontinuity which will probably damage
   1586              * compression when moving from a fully transparent area to a
   1587              * nearly transparent one.  (The assumption here is that opaque
   1588              * areas tend not to be 0 intensity.)
   1589              */
   1590             if (component >= alpha)
   1591                component = 65535;
   1592 
   1593             /* component<alpha, so component/alpha is less than one and
   1594              * component*reciprocal is less than 2^31.
   1595              */
   1596             else if (component > 0 && alpha < 65535)
   1597             {
   1598                png_uint_32 calc = component * reciprocal;
   1599                calc += 16384; /* round to nearest */
   1600                component = (png_uint_16)(calc >> 15);
   1601             }
   1602 
   1603             *out_ptr++ = component;
   1604          }
   1605          while (--c > 0);
   1606 
   1607          /* Skip to next component (skip the intervening alpha channel) */
   1608          ++in_ptr;
   1609          ++out_ptr;
   1610       }
   1611 
   1612       png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row));
   1613       input_row += display->row_bytes/(sizeof (png_uint_16));
   1614    }
   1615 
   1616    return 1;
   1617 }
   1618 
   1619 /* Given 16-bit input (1 to 4 channels) write 8-bit output.  If an alpha channel
   1620  * is present it must be removed from the components, the components are then
   1621  * written in sRGB encoding.  No components are added or removed.
   1622  *
   1623  * Calculate an alpha reciprocal to reverse pre-multiplication.  As above the
   1624  * calculation can be done to 15 bits of accuracy; however, the output needs to
   1625  * be scaled in the range 0..255*65535, so include that scaling here.
   1626  */
   1627 #   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
   1628 
   1629 static png_byte
   1630 png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
   1631    png_uint_32 reciprocal/*from the above macro*/)
   1632 {
   1633    /* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
   1634     * is represented as some other value there is more likely to be a
   1635     * discontinuity which will probably damage compression when moving from a
   1636     * fully transparent area to a nearly transparent one.  (The assumption here
   1637     * is that opaque areas tend not to be 0 intensity.)
   1638     *
   1639     * There is a rounding problem here; if alpha is less than 128 it will end up
   1640     * as 0 when scaled to 8 bits.  To avoid introducing spurious colors into the
   1641     * output change for this too.
   1642     */
   1643    if (component >= alpha || alpha < 128)
   1644       return 255;
   1645 
   1646    /* component<alpha, so component/alpha is less than one and
   1647     * component*reciprocal is less than 2^31.
   1648     */
   1649    else if (component > 0)
   1650    {
   1651       /* The test is that alpha/257 (rounded) is less than 255, the first value
   1652        * that becomes 255 is 65407.
   1653        * NOTE: this must agree with the PNG_DIV257 macro (which must, therefore,
   1654        * be exact!)  [Could also test reciprocal != 0]
   1655        */
   1656       if (alpha < 65407)
   1657       {
   1658          component *= reciprocal;
   1659          component += 64; /* round to nearest */
   1660          component >>= 7;
   1661       }
   1662 
   1663       else
   1664          component *= 255;
   1665 
   1666       /* Convert the component to sRGB. */
   1667       return (png_byte)PNG_sRGB_FROM_LINEAR(component);
   1668    }
   1669 
   1670    else
   1671       return 0;
   1672 }
   1673 
   1674 static int
   1675 png_write_image_8bit(png_voidp argument)
   1676 {
   1677    png_image_write_control *display = png_voidcast(png_image_write_control*,
   1678        argument);
   1679    png_imagep image = display->image;
   1680    png_structrp png_ptr = image->opaque->png_ptr;
   1681 
   1682    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
   1683        display->first_row);
   1684    png_bytep output_row = png_voidcast(png_bytep, display->local_row);
   1685    png_uint_32 y = image->height;
   1686    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
   1687 
   1688    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
   1689    {
   1690       png_bytep row_end;
   1691       int aindex;
   1692 
   1693 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
   1694       if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
   1695       {
   1696          aindex = -1;
   1697          ++input_row; /* To point to the first component */
   1698          ++output_row;
   1699       }
   1700 
   1701       else
   1702 #   endif
   1703       aindex = channels;
   1704 
   1705       /* Use row_end in place of a loop counter: */
   1706       row_end = output_row + image->width * (channels+1);
   1707 
   1708       while (y-- > 0)
   1709       {
   1710          png_const_uint_16p in_ptr = input_row;
   1711          png_bytep out_ptr = output_row;
   1712 
   1713          while (out_ptr < row_end)
   1714          {
   1715             png_uint_16 alpha = in_ptr[aindex];
   1716             png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
   1717             png_uint_32 reciprocal = 0;
   1718             int c;
   1719 
   1720             /* Scale and write the alpha channel. */
   1721             out_ptr[aindex] = alphabyte;
   1722 
   1723             if (alphabyte > 0 && alphabyte < 255)
   1724                reciprocal = UNP_RECIPROCAL(alpha);
   1725 
   1726             c = channels;
   1727             do /* always at least one channel */
   1728                *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
   1729             while (--c > 0);
   1730 
   1731             /* Skip to next component (skip the intervening alpha channel) */
   1732             ++in_ptr;
   1733             ++out_ptr;
   1734          } /* while out_ptr < row_end */
   1735 
   1736          png_write_row(png_ptr, png_voidcast(png_const_bytep,
   1737              display->local_row));
   1738          input_row += display->row_bytes/(sizeof (png_uint_16));
   1739       } /* while y */
   1740    }
   1741 
   1742    else
   1743    {
   1744       /* No alpha channel, so the row_end really is the end of the row and it
   1745        * is sufficient to loop over the components one by one.
   1746        */
   1747       png_bytep row_end = output_row + image->width * channels;
   1748 
   1749       while (y-- > 0)
   1750       {
   1751          png_const_uint_16p in_ptr = input_row;
   1752          png_bytep out_ptr = output_row;
   1753 
   1754          while (out_ptr < row_end)
   1755          {
   1756             png_uint_32 component = *in_ptr++;
   1757 
   1758             component *= 255;
   1759             *out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component);
   1760          }
   1761 
   1762          png_write_row(png_ptr, output_row);
   1763          input_row += display->row_bytes/(sizeof (png_uint_16));
   1764       }
   1765    }
   1766 
   1767    return 1;
   1768 }
   1769 
   1770 static void
   1771 png_image_set_PLTE(png_image_write_control *display)
   1772 {
   1773    const png_imagep image = display->image;
   1774    const void *cmap = display->colormap;
   1775    const int entries = image->colormap_entries > 256 ? 256 :
   1776        (int)image->colormap_entries;
   1777 
   1778    /* NOTE: the caller must check for cmap != NULL and entries != 0 */
   1779    const png_uint_32 format = image->format;
   1780    const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
   1781 
   1782 #   if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
   1783       defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
   1784       const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
   1785           (format & PNG_FORMAT_FLAG_ALPHA) != 0;
   1786 #   else
   1787 #     define afirst 0
   1788 #   endif
   1789 
   1790 #   ifdef PNG_FORMAT_BGR_SUPPORTED
   1791       const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
   1792 #   else
   1793 #     define bgr 0
   1794 #   endif
   1795 
   1796    int i, num_trans;
   1797    png_color palette[256];
   1798    png_byte tRNS[256];
   1799 
   1800    memset(tRNS, 255, (sizeof tRNS));
   1801    memset(palette, 0, (sizeof palette));
   1802 
   1803    for (i=num_trans=0; i<entries; ++i)
   1804    {
   1805       /* This gets automatically converted to sRGB with reversal of the
   1806        * pre-multiplication if the color-map has an alpha channel.
   1807        */
   1808       if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
   1809       {
   1810          png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap);
   1811 
   1812          entry += i * channels;
   1813 
   1814          if ((channels & 1) != 0) /* no alpha */
   1815          {
   1816             if (channels >= 3) /* RGB */
   1817             {
   1818                palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
   1819                    entry[(2 ^ bgr)]);
   1820                palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
   1821                    entry[1]);
   1822                palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
   1823                    entry[bgr]);
   1824             }
   1825 
   1826             else /* Gray */
   1827                palette[i].blue = palette[i].red = palette[i].green =
   1828                   (png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
   1829          }
   1830 
   1831          else /* alpha */
   1832          {
   1833             png_uint_16 alpha = entry[afirst ? 0 : channels-1];
   1834             png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
   1835             png_uint_32 reciprocal = 0;
   1836 
   1837             /* Calculate a reciprocal, as in the png_write_image_8bit code above
   1838              * this is designed to produce a value scaled to 255*65535 when
   1839              * divided by 128 (i.e. asr 7).
   1840              */
   1841             if (alphabyte > 0 && alphabyte < 255)
   1842                reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha;
   1843 
   1844             tRNS[i] = alphabyte;
   1845             if (alphabyte < 255)
   1846                num_trans = i+1;
   1847 
   1848             if (channels >= 3) /* RGB */
   1849             {
   1850                palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
   1851                   alpha, reciprocal);
   1852                palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
   1853                   reciprocal);
   1854                palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
   1855                   reciprocal);
   1856             }
   1857 
   1858             else /* gray */
   1859                palette[i].blue = palette[i].red = palette[i].green =
   1860                   png_unpremultiply(entry[afirst], alpha, reciprocal);
   1861          }
   1862       }
   1863 
   1864       else /* Color-map has sRGB values */
   1865       {
   1866          png_const_bytep entry = png_voidcast(png_const_bytep, cmap);
   1867 
   1868          entry += i * channels;
   1869 
   1870          switch (channels)
   1871          {
   1872             case 4:
   1873                tRNS[i] = entry[afirst ? 0 : 3];
   1874                if (tRNS[i] < 255)
   1875                   num_trans = i+1;
   1876                /* FALL THROUGH */
   1877             case 3:
   1878                palette[i].blue = entry[afirst + (2 ^ bgr)];
   1879                palette[i].green = entry[afirst + 1];
   1880                palette[i].red = entry[afirst + bgr];
   1881                break;
   1882 
   1883             case 2:
   1884                tRNS[i] = entry[1 ^ afirst];
   1885                if (tRNS[i] < 255)
   1886                   num_trans = i+1;
   1887                /* FALL THROUGH */
   1888             case 1:
   1889                palette[i].blue = palette[i].red = palette[i].green =
   1890                   entry[afirst];
   1891                break;
   1892 
   1893             default:
   1894                break;
   1895          }
   1896       }
   1897    }
   1898 
   1899 #   ifdef afirst
   1900 #     undef afirst
   1901 #   endif
   1902 #   ifdef bgr
   1903 #     undef bgr
   1904 #   endif
   1905 
   1906    png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
   1907       entries);
   1908 
   1909    if (num_trans > 0)
   1910       png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS,
   1911          num_trans, NULL);
   1912 
   1913    image->colormap_entries = entries;
   1914 }
   1915 
   1916 static int
   1917 png_image_write_main(png_voidp argument)
   1918 {
   1919    png_image_write_control *display = png_voidcast(png_image_write_control*,
   1920       argument);
   1921    png_imagep image = display->image;
   1922    png_structrp png_ptr = image->opaque->png_ptr;
   1923    png_inforp info_ptr = image->opaque->info_ptr;
   1924    png_uint_32 format = image->format;
   1925 
   1926    /* The following four ints are actually booleans */
   1927    int colormap = (format & PNG_FORMAT_FLAG_COLORMAP);
   1928    int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR); /* input */
   1929    int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
   1930    int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
   1931 
   1932 #   ifdef PNG_BENIGN_ERRORS_SUPPORTED
   1933       /* Make sure we error out on any bad situation */
   1934       png_set_benign_errors(png_ptr, 0/*error*/);
   1935 #   endif
   1936 
   1937    /* Default the 'row_stride' parameter if required, also check the row stride
   1938     * and total image size to ensure that they are within the system limits.
   1939     */
   1940    {
   1941       const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
   1942 
   1943       if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
   1944       {
   1945          png_uint_32 check;
   1946          const png_uint_32 png_row_stride = image->width * channels;
   1947 
   1948          if (display->row_stride == 0)
   1949             display->row_stride = (png_int_32)/*SAFE*/png_row_stride;
   1950 
   1951          if (display->row_stride < 0)
   1952             check = -display->row_stride;
   1953 
   1954          else
   1955             check = display->row_stride;
   1956 
   1957          if (check >= png_row_stride)
   1958          {
   1959             /* Now check for overflow of the image buffer calculation; this
   1960              * limits the whole image size to 32 bits for API compatibility with
   1961              * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
   1962              */
   1963             if (image->height > 0xFFFFFFFF/png_row_stride)
   1964                png_error(image->opaque->png_ptr, "memory image too large");
   1965          }
   1966 
   1967          else
   1968             png_error(image->opaque->png_ptr, "supplied row stride too small");
   1969       }
   1970 
   1971       else
   1972          png_error(image->opaque->png_ptr, "image row stride too large");
   1973    }
   1974 
   1975    /* Set the required transforms then write the rows in the correct order. */
   1976    if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
   1977    {
   1978       if (display->colormap != NULL && image->colormap_entries > 0)
   1979       {
   1980          png_uint_32 entries = image->colormap_entries;
   1981 
   1982          png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
   1983             entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)),
   1984             PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
   1985             PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
   1986 
   1987          png_image_set_PLTE(display);
   1988       }
   1989 
   1990       else
   1991          png_error(image->opaque->png_ptr,
   1992             "no color-map for color-mapped image");
   1993    }
   1994 
   1995    else
   1996       png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
   1997          write_16bit ? 16 : 8,
   1998          ((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) +
   1999          ((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0),
   2000          PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
   2001 
   2002    /* Counter-intuitively the data transformations must be called *after*
   2003     * png_write_info, not before as in the read code, but the 'set' functions
   2004     * must still be called before.  Just set the color space information, never
   2005     * write an interlaced image.
   2006     */
   2007 
   2008    if (write_16bit != 0)
   2009    {
   2010       /* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */
   2011       png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR);
   2012 
   2013       if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
   2014          png_set_cHRM_fixed(png_ptr, info_ptr,
   2015             /* color      x       y */
   2016             /* white */ 31270, 32900,
   2017             /* red   */ 64000, 33000,
   2018             /* green */ 30000, 60000,
   2019             /* blue  */ 15000,  6000
   2020          );
   2021    }
   2022 
   2023    else if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
   2024       png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
   2025 
   2026    /* Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
   2027     * space must still be gamma encoded.
   2028     */
   2029    else
   2030       png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE);
   2031 
   2032    /* Write the file header. */
   2033    png_write_info(png_ptr, info_ptr);
   2034 
   2035    /* Now set up the data transformations (*after* the header is written),
   2036     * remove the handled transformations from the 'format' flags for checking.
   2037     *
   2038     * First check for a little endian system if writing 16-bit files.
   2039     */
   2040    if (write_16bit != 0)
   2041    {
   2042       PNG_CONST png_uint_16 le = 0x0001;
   2043 
   2044       if ((*(png_const_bytep) & le) != 0)
   2045          png_set_swap(png_ptr);
   2046    }
   2047 
   2048 #   ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
   2049       if ((format & PNG_FORMAT_FLAG_BGR) != 0)
   2050       {
   2051          if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
   2052             png_set_bgr(png_ptr);
   2053          format &= ~PNG_FORMAT_FLAG_BGR;
   2054       }
   2055 #   endif
   2056 
   2057 #   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
   2058       if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
   2059       {
   2060          if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
   2061             png_set_swap_alpha(png_ptr);
   2062          format &= ~PNG_FORMAT_FLAG_AFIRST;
   2063       }
   2064 #   endif
   2065 
   2066    /* If there are 16 or fewer color-map entries we wrote a lower bit depth
   2067     * above, but the application data is still byte packed.
   2068     */
   2069    if (colormap != 0 && image->colormap_entries <= 16)
   2070       png_set_packing(png_ptr);
   2071 
   2072    /* That should have handled all (both) the transforms. */
   2073    if ((format & ~(png_uint_32)(PNG_FORMAT_FLAG_COLOR | PNG_FORMAT_FLAG_LINEAR |
   2074          PNG_FORMAT_FLAG_ALPHA | PNG_FORMAT_FLAG_COLORMAP)) != 0)
   2075       png_error(png_ptr, "png_write_image: unsupported transformation");
   2076 
   2077    {
   2078       png_const_bytep row = png_voidcast(png_const_bytep, display->buffer);
   2079       ptrdiff_t row_bytes = display->row_stride;
   2080 
   2081       if (linear != 0)
   2082          row_bytes *= (sizeof (png_uint_16));
   2083 
   2084       if (row_bytes < 0)
   2085          row += (image->height-1) * (-row_bytes);
   2086 
   2087       display->first_row = row;
   2088       display->row_bytes = row_bytes;
   2089    }
   2090 
   2091    /* Apply 'fast' options if the flag is set. */
   2092    if ((image->flags & PNG_IMAGE_FLAG_FAST) != 0)
   2093    {
   2094       png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS);
   2095       /* NOTE: determined by experiment using pngstest, this reflects some
   2096        * balance between the time to write the image once and the time to read
   2097        * it about 50 times.  The speed-up in pngstest was about 10-20% of the
   2098        * total (user) time on a heavily loaded system.
   2099        */
   2100 #   ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
   2101       png_set_compression_level(png_ptr, 3);
   2102 #   endif
   2103    }
   2104 
   2105    /* Check for the cases that currently require a pre-transform on the row
   2106     * before it is written.  This only applies when the input is 16-bit and
   2107     * either there is an alpha channel or it is converted to 8-bit.
   2108     */
   2109    if ((linear != 0 && alpha != 0 ) ||
   2110        (colormap == 0 && display->convert_to_8bit != 0))
   2111    {
   2112       png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
   2113          png_get_rowbytes(png_ptr, info_ptr)));
   2114       int result;
   2115 
   2116       display->local_row = row;
   2117       if (write_16bit != 0)
   2118          result = png_safe_execute(image, png_write_image_16bit, display);
   2119       else
   2120          result = png_safe_execute(image, png_write_image_8bit, display);
   2121       display->local_row = NULL;
   2122 
   2123       png_free(png_ptr, row);
   2124 
   2125       /* Skip the 'write_end' on error: */
   2126       if (result == 0)
   2127          return 0;
   2128    }
   2129 
   2130    /* Otherwise this is the case where the input is in a format currently
   2131     * supported by the rest of the libpng write code; call it directly.
   2132     */
   2133    else
   2134    {
   2135       png_const_bytep row = png_voidcast(png_const_bytep, display->first_row);
   2136       ptrdiff_t row_bytes = display->row_bytes;
   2137       png_uint_32 y = image->height;
   2138 
   2139       while (y-- > 0)
   2140       {
   2141          png_write_row(png_ptr, row);
   2142          row += row_bytes;
   2143       }
   2144    }
   2145 
   2146    png_write_end(png_ptr, info_ptr);
   2147    return 1;
   2148 }
   2149 
   2150 
   2151 static void (PNGCBAPI
   2152 image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data,
   2153    png_size_t size)
   2154 {
   2155    png_image_write_control *display = png_voidcast(png_image_write_control*,
   2156       png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/);
   2157    const png_alloc_size_t ob = display->output_bytes;
   2158 
   2159    /* Check for overflow; this should never happen: */
   2160    if (size <= ((png_alloc_size_t)-1) - ob)
   2161    {
   2162       /* I don't think libpng ever does this, but just in case: */
   2163       if (size > 0)
   2164       {
   2165          if (display->memory_bytes >= ob+size) /* writing */
   2166             memcpy(display->memory+ob, data, size);
   2167 
   2168          /* Always update the size: */
   2169          display->output_bytes = ob+size;
   2170       }
   2171    }
   2172 
   2173    else
   2174       png_error(png_ptr, "png_image_write_to_memory: PNG too big");
   2175 }
   2176 
   2177 static void (PNGCBAPI
   2178 image_memory_flush)(png_structp png_ptr)
   2179 {
   2180    PNG_UNUSED(png_ptr)
   2181 }
   2182 
   2183 static int
   2184 png_image_write_memory(png_voidp argument)
   2185 {
   2186    png_image_write_control *display = png_voidcast(png_image_write_control*,
   2187       argument);
   2188 
   2189    /* The rest of the memory-specific init and write_main in an error protected
   2190     * environment.  This case needs to use callbacks for the write operations
   2191     * since libpng has no built in support for writing to memory.
   2192     */
   2193    png_set_write_fn(display->image->opaque->png_ptr, display/*io_ptr*/,
   2194          image_memory_write, image_memory_flush);
   2195 
   2196    return png_image_write_main(display);
   2197 }
   2198 
   2199 int PNGAPI
   2200 png_image_write_to_memory(png_imagep image, void *memory,
   2201    png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
   2202    const void *buffer, png_int_32 row_stride, const void *colormap)
   2203 {
   2204    /* Write the image to the given buffer, or count the bytes if it is NULL */
   2205    if (image != NULL && image->version == PNG_IMAGE_VERSION)
   2206    {
   2207       if (memory_bytes != NULL && buffer != NULL)
   2208       {
   2209          /* This is to give the caller an easier error detection in the NULL
   2210           * case and guard against uninitialized variable problems:
   2211           */
   2212          if (memory == NULL)
   2213             *memory_bytes = 0;
   2214 
   2215          if (png_image_write_init(image) != 0)
   2216          {
   2217             png_image_write_control display;
   2218             int result;
   2219 
   2220             memset(&display, 0, (sizeof display));
   2221             display.image = image;
   2222             display.buffer = buffer;
   2223             display.row_stride = row_stride;
   2224             display.colormap = colormap;
   2225             display.convert_to_8bit = convert_to_8bit;
   2226             display.memory = png_voidcast(png_bytep, memory);
   2227             display.memory_bytes = *memory_bytes;
   2228             display.output_bytes = 0;
   2229 
   2230             result = png_safe_execute(image, png_image_write_memory, &display);
   2231             png_image_free(image);
   2232 
   2233             /* write_memory returns true even if we ran out of buffer. */
   2234             if (result)
   2235             {
   2236                /* On out-of-buffer this function returns '0' but still updates
   2237                 * memory_bytes:
   2238                 */
   2239                if (memory != NULL && display.output_bytes > *memory_bytes)
   2240                   result = 0;
   2241 
   2242                *memory_bytes = display.output_bytes;
   2243             }
   2244 
   2245             return result;
   2246          }
   2247 
   2248          else
   2249             return 0;
   2250       }
   2251 
   2252       else
   2253          return png_image_error(image,
   2254             "png_image_write_to_memory: invalid argument");
   2255    }
   2256 
   2257    else if (image != NULL)
   2258       return png_image_error(image,
   2259          "png_image_write_to_memory: incorrect PNG_IMAGE_VERSION");
   2260 
   2261    else
   2262       return 0;
   2263 }
   2264 
   2265 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
   2266 int PNGAPI
   2267 png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
   2268    const void *buffer, png_int_32 row_stride, const void *colormap)
   2269 {
   2270    /* Write the image to the given (FILE*). */
   2271    if (image != NULL && image->version == PNG_IMAGE_VERSION)
   2272    {
   2273       if (file != NULL && buffer != NULL)
   2274       {
   2275          if (png_image_write_init(image) != 0)
   2276          {
   2277             png_image_write_control display;
   2278             int result;
   2279 
   2280             /* This is slightly evil, but png_init_io doesn't do anything other
   2281              * than this and we haven't changed the standard IO functions so
   2282              * this saves a 'safe' function.
   2283              */
   2284             image->opaque->png_ptr->io_ptr = file;
   2285 
   2286             memset(&display, 0, (sizeof display));
   2287             display.image = image;
   2288             display.buffer = buffer;
   2289             display.row_stride = row_stride;
   2290             display.colormap = colormap;
   2291             display.convert_to_8bit = convert_to_8bit;
   2292 
   2293             result = png_safe_execute(image, png_image_write_main, &display);
   2294             png_image_free(image);
   2295             return result;
   2296          }
   2297 
   2298          else
   2299             return 0;
   2300       }
   2301 
   2302       else
   2303          return png_image_error(image,
   2304             "png_image_write_to_stdio: invalid argument");
   2305    }
   2306 
   2307    else if (image != NULL)
   2308       return png_image_error(image,
   2309          "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
   2310 
   2311    else
   2312       return 0;
   2313 }
   2314 
   2315 int PNGAPI
   2316 png_image_write_to_file(png_imagep image, const char *file_name,
   2317    int convert_to_8bit, const void *buffer, png_int_32 row_stride,
   2318    const void *colormap)
   2319 {
   2320    /* Write the image to the named file. */
   2321    if (image != NULL && image->version == PNG_IMAGE_VERSION)
   2322    {
   2323       if (file_name != NULL && buffer != NULL)
   2324       {
   2325          FILE *fp = fopen(file_name, "wb");
   2326 
   2327          if (fp != NULL)
   2328          {
   2329             if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
   2330                row_stride, colormap) != 0)
   2331             {
   2332                int error; /* from fflush/fclose */
   2333 
   2334                /* Make sure the file is flushed correctly. */
   2335                if (fflush(fp) == 0 && ferror(fp) == 0)
   2336                {
   2337                   if (fclose(fp) == 0)
   2338                      return 1;
   2339 
   2340                   error = errno; /* from fclose */
   2341                }
   2342 
   2343                else
   2344                {
   2345                   error = errno; /* from fflush or ferror */
   2346                   (void)fclose(fp);
   2347                }
   2348 
   2349                (void)remove(file_name);
   2350                /* The image has already been cleaned up; this is just used to
   2351                 * set the error (because the original write succeeded).
   2352                 */
   2353                return png_image_error(image, strerror(error));
   2354             }
   2355 
   2356             else
   2357             {
   2358                /* Clean up: just the opened file. */
   2359                (void)fclose(fp);
   2360                (void)remove(file_name);
   2361                return 0;
   2362             }
   2363          }
   2364 
   2365          else
   2366             return png_image_error(image, strerror(errno));
   2367       }
   2368 
   2369       else
   2370          return png_image_error(image,
   2371             "png_image_write_to_file: invalid argument");
   2372    }
   2373 
   2374    else if (image != NULL)
   2375       return png_image_error(image,
   2376          "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
   2377 
   2378    else
   2379       return 0;
   2380 }
   2381 #endif /* SIMPLIFIED_WRITE_STDIO */
   2382 #endif /* SIMPLIFIED_WRITE */
   2383 #endif /* WRITE */
   2384