1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.  Oracle designates this

     7  * particular file as subject to the "Classpath" exception as provided

     8  * by Oracle in the LICENSE file that accompanied this code.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  */

    24 

    25 /* pngwrite.c - general routines to write a PNG file

    26  *

    27  * This file is available under and governed by the GNU General Public

    28  * License version 2 only, as published by the Free Software Foundation.

    29  * However, the following notice accompanied the original version of this

    30  * file and, per its terms, should not be removed:

    31  *

    32  * Last changed in libpng 1.6.19 [November 12, 2015]

    33  * Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson

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

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

    36  *

    37  * This code is released under the libpng license.

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

    39  * and license in png.h

    40  */

    41 

    42 #include "pngpriv.h"

    43 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED

    44 #  include <errno.h>

    45 #endif /* SIMPLIFIED_WRITE_STDIO */

    46 

    47 #ifdef PNG_WRITE_SUPPORTED

    48 

    49 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

    50 /* Write out all the unknown chunks for the current given location */

    51 static void

    52 write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,

    53    unsigned int where)

    54 {

    55    if (info_ptr->unknown_chunks_num != 0)

    56    {

    57       png_const_unknown_chunkp up;

    58 

    59       png_debug(5, "writing extra chunks");

    60 

    61       for (up = info_ptr->unknown_chunks;

    62            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

    63            ++up)

    64          if ((up->location & where) != 0)

    65       {

    66          /* If per-chunk unknown chunk handling is enabled use it, otherwise

    67           * just write the chunks the application has set.

    68           */

    69 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED

    70          int keep = png_handle_as_unknown(png_ptr, up->name);

    71 

    72          /* NOTE: this code is radically different from the read side in the

    73           * matter of handling an ancillary unknown chunk.  In the read side

    74           * the default behavior is to discard it, in the code below the default

    75           * behavior is to write it.  Critical chunks are, however, only

    76           * written if explicitly listed or if the default is set to write all

    77           * unknown chunks.

    78           *

    79           * The default handling is also slightly weird - it is not possible to

    80           * stop the writing of all unsafe-to-copy chunks!

    81           *

    82           * TODO: REVIEW: this would seem to be a bug.

    83           */

    84          if (keep != PNG_HANDLE_CHUNK_NEVER &&

    85              ((up->name[3] & 0x20) /* safe-to-copy overrides everything */ ||

    86               keep == PNG_HANDLE_CHUNK_ALWAYS ||

    87               (keep == PNG_HANDLE_CHUNK_AS_DEFAULT &&

    88                png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS)))

    89 #endif

    90          {

    91             /* TODO: review, what is wrong with a zero length unknown chunk? */

    92             if (up->size == 0)

    93                png_warning(png_ptr, "Writing zero-length unknown chunk");

    94 

    95             png_write_chunk(png_ptr, up->name, up->data, up->size);

    96          }

    97       }

    98    }

    99 }

   100 #endif /* WRITE_UNKNOWN_CHUNKS */

   101 

   102 /* Writes all the PNG information.  This is the suggested way to use the

   103  * library.  If you have a new chunk to add, make a function to write it,

   104  * and put it in the correct location here.  If you want the chunk written

   105  * after the image data, put it in png_write_end().  I strongly encourage

   106  * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing

   107  * the chunk, as that will keep the code from breaking if you want to just

   108  * write a plain PNG file.  If you have long comments, I suggest writing

   109  * them in png_write_end(), and compressing them.

   110  */

   111 void PNGAPI

   112 png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)

   113 {

   114    png_debug(1, "in png_write_info_before_PLTE");

   115 

   116    if (png_ptr == NULL || info_ptr == NULL)

   117       return;

   118 

   119    if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)

   120    {

   121       /* Write PNG signature */

   122       png_write_sig(png_ptr);

   123 

   124 #ifdef PNG_MNG_FEATURES_SUPPORTED

   125       if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \

   126           png_ptr->mng_features_permitted != 0)

   127       {

   128          png_warning(png_ptr,

   129              "MNG features are not allowed in a PNG datastream");

   130          png_ptr->mng_features_permitted = 0;

   131       }

   132 #endif

   133 

   134       /* Write IHDR information. */

   135       png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,

   136           info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,

   137           info_ptr->filter_type,

   138 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   139           info_ptr->interlace_type

   140 #else

   141           0

   142 #endif

   143          );

   144 

   145       /* The rest of these check to see if the valid field has the appropriate

   146        * flag set, and if it does, writes the chunk.

   147        *

   148        * 1.6.0: COLORSPACE support controls the writing of these chunks too, and

   149        * the chunks will be written if the WRITE routine is there and

   150        * information * is available in the COLORSPACE. (See

   151        * png_colorspace_sync_info in png.c for where the valid flags get set.)

   152        *

   153        * Under certain circumstances the colorspace can be invalidated without

   154        * syncing the info_struct 'valid' flags; this happens if libpng detects

   155        * an error and calls png_error while the color space is being set, yet

   156        * the application continues writing the PNG.  So check the 'invalid'

   157        * flag here too.

   158        */

   159 #ifdef PNG_GAMMA_SUPPORTED

   160 #  ifdef PNG_WRITE_gAMA_SUPPORTED

   161       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&

   162           (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&

   163           (info_ptr->valid & PNG_INFO_gAMA) != 0)

   164          png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);

   165 #  endif

   166 #endif

   167 

   168 #ifdef PNG_COLORSPACE_SUPPORTED

   169       /* Write only one of sRGB or an ICC profile.  If a profile was supplied

   170        * and it matches one of the known sRGB ones issue a warning.

   171        */

   172 #  ifdef PNG_WRITE_iCCP_SUPPORTED

   173          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&

   174              (info_ptr->valid & PNG_INFO_iCCP) != 0)

   175          {

   176 #    ifdef PNG_WRITE_sRGB_SUPPORTED

   177                if ((info_ptr->valid & PNG_INFO_sRGB) != 0)

   178                   png_app_warning(png_ptr,

   179                      "profile matches sRGB but writing iCCP instead");

   180 #     endif

   181 

   182             png_write_iCCP(png_ptr, info_ptr->iccp_name,

   183                info_ptr->iccp_profile);

   184          }

   185 #     ifdef PNG_WRITE_sRGB_SUPPORTED

   186          else

   187 #     endif

   188 #  endif

   189 

   190 #  ifdef PNG_WRITE_sRGB_SUPPORTED

   191          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&

   192              (info_ptr->valid & PNG_INFO_sRGB) != 0)

   193             png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);

   194 #  endif /* WRITE_sRGB */

   195 #endif /* COLORSPACE */

   196 

   197 #ifdef PNG_WRITE_sBIT_SUPPORTED

   198          if ((info_ptr->valid & PNG_INFO_sBIT) != 0)

   199             png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);

   200 #endif

   201 

   202 #ifdef PNG_COLORSPACE_SUPPORTED

   203 #  ifdef PNG_WRITE_cHRM_SUPPORTED

   204          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&

   205              (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&

   206              (info_ptr->valid & PNG_INFO_cHRM) != 0)

   207             png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);

   208 #  endif

   209 #endif

   210 

   211 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

   212          write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);

   213 #endif

   214 

   215       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;

   216    }

   217 }

   218 

   219 void PNGAPI

   220 png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)

   221 {

   222 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

   223    int i;

   224 #endif

   225 

   226    png_debug(1, "in png_write_info");

   227 

   228    if (png_ptr == NULL || info_ptr == NULL)

   229       return;

   230 

   231    png_write_info_before_PLTE(png_ptr, info_ptr);

   232 

   233    if ((info_ptr->valid & PNG_INFO_PLTE) != 0)

   234       png_write_PLTE(png_ptr, info_ptr->palette,

   235           (png_uint_32)info_ptr->num_palette);

   236 

   237    else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

   238       png_error(png_ptr, "Valid palette required for paletted images");

   239 

   240 #ifdef PNG_WRITE_tRNS_SUPPORTED

   241    if ((info_ptr->valid & PNG_INFO_tRNS) !=0)

   242    {

   243 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED

   244       /* Invert the alpha channel (in tRNS) */

   245       if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&

   246           info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

   247       {

   248          int j, jend;

   249 

   250          jend = info_ptr->num_trans;

   251          if (jend > PNG_MAX_PALETTE_LENGTH)

   252             jend = PNG_MAX_PALETTE_LENGTH;

   253 

   254          for (j = 0; j<jend; ++j)

   255             info_ptr->trans_alpha[j] =

   256                (png_byte)(255 - info_ptr->trans_alpha[j]);

   257       }

   258 #endif

   259       png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),

   260           info_ptr->num_trans, info_ptr->color_type);

   261    }

   262 #endif

   263 #ifdef PNG_WRITE_bKGD_SUPPORTED

   264    if ((info_ptr->valid & PNG_INFO_bKGD) != 0)

   265       png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);

   266 #endif

   267 

   268 #ifdef PNG_WRITE_hIST_SUPPORTED

   269    if ((info_ptr->valid & PNG_INFO_hIST) != 0)

   270       png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);

   271 #endif

   272 

   273 #ifdef PNG_WRITE_oFFs_SUPPORTED

   274    if ((info_ptr->valid & PNG_INFO_oFFs) != 0)

   275       png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,

   276           info_ptr->offset_unit_type);

   277 #endif

   278 

   279 #ifdef PNG_WRITE_pCAL_SUPPORTED

   280    if ((info_ptr->valid & PNG_INFO_pCAL) != 0)

   281       png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,

   282           info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,

   283           info_ptr->pcal_units, info_ptr->pcal_params);

   284 #endif

   285 

   286 #ifdef PNG_WRITE_sCAL_SUPPORTED

   287    if ((info_ptr->valid & PNG_INFO_sCAL) != 0)

   288       png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,

   289           info_ptr->scal_s_width, info_ptr->scal_s_height);

   290 #endif /* sCAL */

   291 

   292 #ifdef PNG_WRITE_pHYs_SUPPORTED

   293    if ((info_ptr->valid & PNG_INFO_pHYs) != 0)

   294       png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,

   295           info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);

   296 #endif /* pHYs */

   297 

   298 #ifdef PNG_WRITE_tIME_SUPPORTED

   299    if ((info_ptr->valid & PNG_INFO_tIME) != 0)

   300    {

   301       png_write_tIME(png_ptr, &(info_ptr->mod_time));

   302       png_ptr->mode |= PNG_WROTE_tIME;

   303    }

   304 #endif /* tIME */

   305 

   306 #ifdef PNG_WRITE_sPLT_SUPPORTED

   307    if ((info_ptr->valid & PNG_INFO_sPLT) != 0)

   308       for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)

   309          png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);

   310 #endif /* sPLT */

   311 

   312 #ifdef PNG_WRITE_TEXT_SUPPORTED

   313    /* Check to see if we need to write text chunks */

   314    for (i = 0; i < info_ptr->num_text; i++)

   315    {

   316       png_debug2(2, "Writing header text chunk %d, type %d", i,

   317           info_ptr->text[i].compression);

   318       /* An internationalized chunk? */

   319       if (info_ptr->text[i].compression > 0)

   320       {

   321 #ifdef PNG_WRITE_iTXt_SUPPORTED

   322          /* Write international chunk */

   323          png_write_iTXt(png_ptr,

   324              info_ptr->text[i].compression,

   325              info_ptr->text[i].key,

   326              info_ptr->text[i].lang,

   327              info_ptr->text[i].lang_key,

   328              info_ptr->text[i].text);

   329          /* Mark this chunk as written */

   330          if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

   331             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

   332          else

   333             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

   334 #else

   335          png_warning(png_ptr, "Unable to write international text");

   336 #endif

   337       }

   338 

   339       /* If we want a compressed text chunk */

   340       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)

   341       {

   342 #ifdef PNG_WRITE_zTXt_SUPPORTED

   343          /* Write compressed chunk */

   344          png_write_zTXt(png_ptr, info_ptr->text[i].key,

   345              info_ptr->text[i].text, info_ptr->text[i].compression);

   346          /* Mark this chunk as written */

   347          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

   348 #else

   349          png_warning(png_ptr, "Unable to write compressed text");

   350 #endif

   351       }

   352 

   353       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

   354       {

   355 #ifdef PNG_WRITE_tEXt_SUPPORTED

   356          /* Write uncompressed chunk */

   357          png_write_tEXt(png_ptr, info_ptr->text[i].key,

   358              info_ptr->text[i].text,

   359              0);

   360          /* Mark this chunk as written */

   361          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

   362 #else

   363          /* Can't get here */

   364          png_warning(png_ptr, "Unable to write uncompressed text");

   365 #endif

   366       }

   367    }

   368 #endif /* tEXt */

   369 

   370 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

   371    write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);

   372 #endif

   373 }

   374 

   375 /* Writes the end of the PNG file.  If you don't want to write comments or

   376  * time information, you can pass NULL for info.  If you already wrote these

   377  * in png_write_info(), do not write them again here.  If you have long

   378  * comments, I suggest writing them here, and compressing them.

   379  */

   380 void PNGAPI

   381 png_write_end(png_structrp png_ptr, png_inforp info_ptr)

   382 {

   383    png_debug(1, "in png_write_end");

   384 

   385    if (png_ptr == NULL)

   386       return;

   387 

   388    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)

   389       png_error(png_ptr, "No IDATs written into file");

   390 

   391 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED

   392    if (png_ptr->num_palette_max > png_ptr->num_palette)

   393       png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");

   394 #endif

   395 

   396    /* See if user wants us to write information chunks */

   397    if (info_ptr != NULL)

   398    {

   399 #ifdef PNG_WRITE_TEXT_SUPPORTED

   400       int i; /* local index variable */

   401 #endif

   402 #ifdef PNG_WRITE_tIME_SUPPORTED

   403       /* Check to see if user has supplied a time chunk */

   404       if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&

   405           (png_ptr->mode & PNG_WROTE_tIME) == 0)

   406          png_write_tIME(png_ptr, &(info_ptr->mod_time));

   407 

   408 #endif

   409 #ifdef PNG_WRITE_TEXT_SUPPORTED

   410       /* Loop through comment chunks */

   411       for (i = 0; i < info_ptr->num_text; i++)

   412       {

   413          png_debug2(2, "Writing trailer text chunk %d, type %d", i,

   414             info_ptr->text[i].compression);

   415          /* An internationalized chunk? */

   416          if (info_ptr->text[i].compression > 0)

   417          {

   418 #ifdef PNG_WRITE_iTXt_SUPPORTED

   419             /* Write international chunk */

   420             png_write_iTXt(png_ptr,

   421                 info_ptr->text[i].compression,

   422                 info_ptr->text[i].key,

   423                 info_ptr->text[i].lang,

   424                 info_ptr->text[i].lang_key,

   425                 info_ptr->text[i].text);

   426             /* Mark this chunk as written */

   427             if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

   428                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

   429             else

   430                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

   431 #else

   432             png_warning(png_ptr, "Unable to write international text");

   433 #endif

   434          }

   435 

   436          else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)

   437          {

   438 #ifdef PNG_WRITE_zTXt_SUPPORTED

   439             /* Write compressed chunk */

   440             png_write_zTXt(png_ptr, info_ptr->text[i].key,

   441                 info_ptr->text[i].text, info_ptr->text[i].compression);

   442             /* Mark this chunk as written */

   443             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

   444 #else

   445             png_warning(png_ptr, "Unable to write compressed text");

   446 #endif

   447          }

   448 

   449          else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

   450          {

   451 #ifdef PNG_WRITE_tEXt_SUPPORTED

   452             /* Write uncompressed chunk */

   453             png_write_tEXt(png_ptr, info_ptr->text[i].key,

   454                 info_ptr->text[i].text, 0);

   455             /* Mark this chunk as written */

   456             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

   457 #else

   458             png_warning(png_ptr, "Unable to write uncompressed text");

   459 #endif

   460          }

   461       }

   462 #endif

   463 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

   464       write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);

   465 #endif

   466    }

   467 

   468    png_ptr->mode |= PNG_AFTER_IDAT;

   469 

   470    /* Write end of PNG file */

   471    png_write_IEND(png_ptr);

   472 

   473    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,

   474     * and restored again in libpng-1.2.30, may cause some applications that

   475     * do not set png_ptr->output_flush_fn to crash.  If your application

   476     * experiences a problem, please try building libpng with

   477     * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to

   478     * png-mng-implement at lists.sf.net .

   479     */

   480 #ifdef PNG_WRITE_FLUSH_SUPPORTED

   481 #  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED

   482    png_flush(png_ptr);

   483 #  endif

   484 #endif

   485 }

   486 

   487 #ifdef PNG_CONVERT_tIME_SUPPORTED

   488 void PNGAPI

   489 png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)

   490 {

   491    png_debug(1, "in png_convert_from_struct_tm");

   492 

   493    ptime->year = (png_uint_16)(1900 + ttime->tm_year);

   494    ptime->month = (png_byte)(ttime->tm_mon + 1);

   495    ptime->day = (png_byte)ttime->tm_mday;

   496    ptime->hour = (png_byte)ttime->tm_hour;

   497    ptime->minute = (png_byte)ttime->tm_min;

   498    ptime->second = (png_byte)ttime->tm_sec;

   499 }

   500 

   501 void PNGAPI

   502 png_convert_from_time_t(png_timep ptime, time_t ttime)

   503 {

   504    struct tm *tbuf;

   505 

   506    png_debug(1, "in png_convert_from_time_t");

   507 

   508    tbuf = gmtime(&ttime);

   509    png_convert_from_struct_tm(ptime, tbuf);

   510 }

   511 #endif

   512 

   513 /* Initialize png_ptr structure, and allocate any memory needed */

   514 PNG_FUNCTION(png_structp,PNGAPI

   515 png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,

   516     png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)

   517 {

   518 #ifndef PNG_USER_MEM_SUPPORTED

   519    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

   520        error_fn, warn_fn, NULL, NULL, NULL);

   521 #else

   522    return png_create_write_struct_2(user_png_ver, error_ptr, error_fn,

   523        warn_fn, NULL, NULL, NULL);

   524 }

   525 

   526 /* Alternate initialize png_ptr structure, and allocate any memory needed */

   527 PNG_FUNCTION(png_structp,PNGAPI

   528 png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,

   529     png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

   530     png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)

   531 {

   532    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

   533        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);

   534 #endif /* USER_MEM */

   535    if (png_ptr != NULL)

   536    {

   537       /* Set the zlib control values to defaults; they can be overridden by the

   538        * application after the struct has been created.

   539        */

   540       png_ptr->zbuffer_size = PNG_ZBUF_SIZE;

   541 

   542       /* The 'zlib_strategy' setting is irrelevant because png_default_claim in

   543        * pngwutil.c defaults it according to whether or not filters will be

   544        * used, and ignores this setting.

   545        */

   546       png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;

   547       png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;

   548       png_ptr->zlib_mem_level = 8;

   549       png_ptr->zlib_window_bits = 15;

   550       png_ptr->zlib_method = 8;

   551 

   552 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED

   553       png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;

   554       png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;

   555       png_ptr->zlib_text_mem_level = 8;

   556       png_ptr->zlib_text_window_bits = 15;

   557       png_ptr->zlib_text_method = 8;

   558 #endif /* WRITE_COMPRESSED_TEXT */

   559 

   560       /* This is a highly dubious configuration option; by default it is off,

   561        * but it may be appropriate for private builds that are testing

   562        * extensions not conformant to the current specification, or of

   563        * applications that must not fail to write at all costs!

   564        */

   565 #ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED

   566       /* In stable builds only warn if an application error can be completely

   567        * handled.

   568        */

   569       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

   570 #endif

   571 

   572       /* App warnings are warnings in release (or release candidate) builds but

   573        * are errors during development.

   574        */

   575 #if PNG_RELEASE_BUILD

   576       png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;

   577 #endif

   578 

   579       /* TODO: delay this, it can be done in png_init_io() (if the app doesn't

   580        * do it itself) avoiding setting the default function if it is not

   581        * required.

   582        */

   583       png_set_write_fn(png_ptr, NULL, NULL, NULL);

   584    }

   585 

   586    return png_ptr;

   587 }

   588 

   589 

   590 /* Write a few rows of image data.  If the image is interlaced,

   591  * either you will have to write the 7 sub images, or, if you

   592  * have called png_set_interlace_handling(), you will have to

   593  * "write" the image seven times.

   594  */

   595 void PNGAPI

   596 png_write_rows(png_structrp png_ptr, png_bytepp row,

   597     png_uint_32 num_rows)

   598 {

   599    png_uint_32 i; /* row counter */

   600    png_bytepp rp; /* row pointer */

   601 

   602    png_debug(1, "in png_write_rows");

   603 

   604    if (png_ptr == NULL)

   605       return;

   606 

   607    /* Loop through the rows */

   608    for (i = 0, rp = row; i < num_rows; i++, rp++)

   609    {

   610       png_write_row(png_ptr, *rp);

   611    }

   612 }

   613 

   614 /* Write the image.  You only need to call this function once, even

   615  * if you are writing an interlaced image.

   616  */

   617 void PNGAPI

   618 png_write_image(png_structrp png_ptr, png_bytepp image)

   619 {

   620    png_uint_32 i; /* row index */

   621    int pass, num_pass; /* pass variables */

   622    png_bytepp rp; /* points to current row */

   623 

   624    if (png_ptr == NULL)

   625       return;

   626 

   627    png_debug(1, "in png_write_image");

   628 

   629 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   630    /* Initialize interlace handling.  If image is not interlaced,

   631     * this will set pass to 1

   632     */

   633    num_pass = png_set_interlace_handling(png_ptr);

   634 #else

   635    num_pass = 1;

   636 #endif

   637    /* Loop through passes */

   638    for (pass = 0; pass < num_pass; pass++)

   639    {

   640       /* Loop through image */

   641       for (i = 0, rp = image; i < png_ptr->height; i++, rp++)

   642       {

   643          png_write_row(png_ptr, *rp);

   644       }

   645    }

   646 }

   647 

   648 #ifdef PNG_MNG_FEATURES_SUPPORTED

   649 /* Performs intrapixel differencing  */

   650 static void

   651 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)

   652 {

   653    png_debug(1, "in png_do_write_intrapixel");

   654 

   655    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)

   656    {

   657       int bytes_per_pixel;

   658       png_uint_32 row_width = row_info->width;

   659       if (row_info->bit_depth == 8)

   660       {

   661          png_bytep rp;

   662          png_uint_32 i;

   663 

   664          if (row_info->color_type == PNG_COLOR_TYPE_RGB)

   665             bytes_per_pixel = 3;

   666 

   667          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

   668             bytes_per_pixel = 4;

   669 

   670          else

   671             return;

   672 

   673          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

   674          {

   675             *(rp)     = (png_byte)(*rp       - *(rp + 1));

   676             *(rp + 2) = (png_byte)(*(rp + 2) - *(rp + 1));

   677          }

   678       }

   679 

   680 #ifdef PNG_WRITE_16BIT_SUPPORTED

   681       else if (row_info->bit_depth == 16)

   682       {

   683          png_bytep rp;

   684          png_uint_32 i;

   685 

   686          if (row_info->color_type == PNG_COLOR_TYPE_RGB)

   687             bytes_per_pixel = 6;

   688 

   689          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

   690             bytes_per_pixel = 8;

   691 

   692          else

   693             return;

   694 

   695          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

   696          {

   697             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);

   698             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

   699             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

   700             png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);

   701             png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);

   702             *(rp    ) = (png_byte)(red >> 8);

   703             *(rp + 1) = (png_byte)red;

   704             *(rp + 4) = (png_byte)(blue >> 8);

   705             *(rp + 5) = (png_byte)blue;

   706          }

   707       }

   708 #endif /* WRITE_16BIT */

   709    }

   710 }

   711 #endif /* MNG_FEATURES */

   712 

   713 /* Called by user to write a row of image data */

   714 void PNGAPI

   715 png_write_row(png_structrp png_ptr, png_const_bytep row)

   716 {

   717    /* 1.5.6: moved from png_struct to be a local structure: */

   718    png_row_info row_info;

   719 

   720    if (png_ptr == NULL)

   721       return;

   722 

   723    png_debug2(1, "in png_write_row (row %u, pass %d)",

   724       png_ptr->row_number, png_ptr->pass);

   725 

   726    /* Initialize transformations and other stuff if first time */

   727    if (png_ptr->row_number == 0 && png_ptr->pass == 0)

   728    {

   729       /* Make sure we wrote the header info */

   730       if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)

   731          png_error(png_ptr,

   732              "png_write_info was never called before png_write_row");

   733 

   734       /* Check for transforms that have been set but were defined out */

   735 #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)

   736       if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)

   737          png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");

   738 #endif

   739 

   740 #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)

   741       if ((png_ptr->transformations & PNG_FILLER) != 0)

   742          png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");

   743 #endif

   744 #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \

   745     defined(PNG_READ_PACKSWAP_SUPPORTED)

   746       if ((png_ptr->transformations & PNG_PACKSWAP) != 0)

   747          png_warning(png_ptr,

   748              "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");

   749 #endif

   750 

   751 #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)

   752       if ((png_ptr->transformations & PNG_PACK) != 0)

   753          png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");

   754 #endif

   755 

   756 #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)

   757       if ((png_ptr->transformations & PNG_SHIFT) != 0)

   758          png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");

   759 #endif

   760 

   761 #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)

   762       if ((png_ptr->transformations & PNG_BGR) != 0)

   763          png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");

   764 #endif

   765 

   766 #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)

   767       if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)

   768          png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");

   769 #endif

   770 

   771       png_write_start_row(png_ptr);

   772    }

   773 

   774 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   775    /* If interlaced and not interested in row, return */

   776    if (png_ptr->interlaced != 0 &&

   777        (png_ptr->transformations & PNG_INTERLACE) != 0)

   778    {

   779       switch (png_ptr->pass)

   780       {

   781          case 0:

   782             if ((png_ptr->row_number & 0x07) != 0)

   783             {

   784                png_write_finish_row(png_ptr);

   785                return;

   786             }

   787             break;

   788 

   789          case 1:

   790             if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)

   791             {

   792                png_write_finish_row(png_ptr);

   793                return;

   794             }

   795             break;

   796 

   797          case 2:

   798             if ((png_ptr->row_number & 0x07) != 4)

   799             {

   800                png_write_finish_row(png_ptr);

   801                return;

   802             }

   803             break;

   804 

   805          case 3:

   806             if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)

   807             {

   808                png_write_finish_row(png_ptr);

   809                return;

   810             }

   811             break;

   812 

   813          case 4:

   814             if ((png_ptr->row_number & 0x03) != 2)

   815             {

   816                png_write_finish_row(png_ptr);

   817                return;

   818             }

   819             break;

   820 

   821          case 5:

   822             if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)

   823             {

   824                png_write_finish_row(png_ptr);

   825                return;

   826             }

   827             break;

   828 

   829          case 6:

   830             if ((png_ptr->row_number & 0x01) == 0)

   831             {

   832                png_write_finish_row(png_ptr);

   833                return;

   834             }

   835             break;

   836 

   837          default: /* error: ignore it */

   838             break;

   839       }

   840    }

   841 #endif

   842 

   843    /* Set up row info for transformations */

   844    row_info.color_type = png_ptr->color_type;

   845    row_info.width = png_ptr->usr_width;

   846    row_info.channels = png_ptr->usr_channels;

   847    row_info.bit_depth = png_ptr->usr_bit_depth;

   848    row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);

   849    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);

   850 

   851    png_debug1(3, "row_info->color_type = %d", row_info.color_type);

   852    png_debug1(3, "row_info->width = %u", row_info.width);

   853    png_debug1(3, "row_info->channels = %d", row_info.channels);

   854    png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth);

   855    png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth);

   856    png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes);

   857 

   858    /* Copy user's row into buffer, leaving room for filter byte. */

   859    memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);

   860 

   861 #ifdef PNG_WRITE_INTERLACING_SUPPORTED

   862    /* Handle interlacing */

   863    if (png_ptr->interlaced && png_ptr->pass < 6 &&

   864        (png_ptr->transformations & PNG_INTERLACE) != 0)

   865    {

   866       png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);

   867       /* This should always get caught above, but still ... */

   868       if (row_info.width == 0)

   869       {

   870          png_write_finish_row(png_ptr);

   871          return;

   872       }

   873    }

   874 #endif

   875 

   876 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED

   877    /* Handle other transformations */

   878    if (png_ptr->transformations != 0)

   879       png_do_write_transformations(png_ptr, &row_info);

   880 #endif

   881 

   882    /* At this point the row_info pixel depth must match the 'transformed' depth,

   883     * which is also the output depth.

   884     */

   885    if (row_info.pixel_depth != png_ptr->pixel_depth ||

   886        row_info.pixel_depth != png_ptr->transformed_pixel_depth)

   887       png_error(png_ptr, "internal write transform logic error");

   888 

   889 #ifdef PNG_MNG_FEATURES_SUPPORTED

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

   891     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

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

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

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

   895     *    included PNG_FLAG_MNG_FILTER_64 and

   896     * 4. The filter_method is 64 and

   897     * 5. The color_type is RGB or RGBA

   898     */

   899    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&

   900        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

   901    {

   902       /* Intrapixel differencing */

   903       png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);

   904    }

   905 #endif

   906 

   907 /* Added at libpng-1.5.10 */

   908 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED

   909    /* Check for out-of-range palette index */

   910    if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&

   911        png_ptr->num_palette_max >= 0)

   912       png_do_check_palette_indexes(png_ptr, &row_info);

   913 #endif

   914 

   915    /* Find a filter if necessary, filter the row and write it out. */

   916    png_write_find_filter(png_ptr, &row_info);

   917 

   918    if (png_ptr->write_row_fn != NULL)

   919       (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

   920 }

   921 

   922 #ifdef PNG_WRITE_FLUSH_SUPPORTED

   923 /* Set the automatic flush interval or 0 to turn flushing off */

   924 void PNGAPI

   925 png_set_flush(png_structrp png_ptr, int nrows)

   926 {

   927    png_debug(1, "in png_set_flush");

   928 

   929    if (png_ptr == NULL)

   930       return;

   931 

   932    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);

   933 }

   934 

   935 /* Flush the current output buffers now */

   936 void PNGAPI

   937 png_write_flush(png_structrp png_ptr)

   938 {

   939    png_debug(1, "in png_write_flush");

   940 

   941    if (png_ptr == NULL)

   942       return;

   943 

   944    /* We have already written out all of the data */

   945    if (png_ptr->row_number >= png_ptr->num_rows)

   946       return;

   947 

   948    png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);

   949    png_ptr->flush_rows = 0;

   950    png_flush(png_ptr);

   951 }

   952 #endif /* WRITE_FLUSH */

   953 

   954 /* Free any memory used in png_ptr struct without freeing the struct itself. */

   955 static void

   956 png_write_destroy(png_structrp png_ptr)

   957 {

   958    png_debug(1, "in png_write_destroy");

   959 

   960    /* Free any memory zlib uses */

   961    if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)

   962       deflateEnd(&png_ptr->zstream);

   963 

   964    /* Free our memory.  png_free checks NULL for us. */

   965    png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);

   966    png_free(png_ptr, png_ptr->row_buf);

   967    png_ptr->row_buf = NULL;

   968 #ifdef PNG_WRITE_FILTER_SUPPORTED

   969    png_free(png_ptr, png_ptr->prev_row);

   970    png_free(png_ptr, png_ptr->try_row);

   971    png_free(png_ptr, png_ptr->tst_row);

   972    png_ptr->prev_row = NULL;

   973    png_ptr->try_row = NULL;

   974    png_ptr->tst_row = NULL;

   975 #endif

   976 

   977 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED

   978    png_free(png_ptr, png_ptr->chunk_list);

   979    png_ptr->chunk_list = NULL;

   980 #endif

   981 

   982    /* The error handling and memory handling information is left intact at this

   983     * point: the jmp_buf may still have to be freed.  See png_destroy_png_struct

   984     * for how this happens.

   985     */

   986 }

   987 

   988 /* Free all memory used by the write.

   989  * In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for

   990  * *png_ptr_ptr.  Prior to 1.6.0 it would accept such a value and it would free

   991  * the passed in info_structs but it would quietly fail to free any of the data

   992  * inside them.  In 1.6.0 it quietly does nothing (it has to be quiet because it

   993  * has no png_ptr.)

   994  */

   995 void PNGAPI

   996 png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

   997 {

   998    png_debug(1, "in png_destroy_write_struct");

   999 

  1000    if (png_ptr_ptr != NULL)

  1001    {

  1002       png_structrp png_ptr = *png_ptr_ptr;

  1003 

  1004       if (png_ptr != NULL) /* added in libpng 1.6.0 */

  1005       {

  1006          png_destroy_info_struct(png_ptr, info_ptr_ptr);

  1007 

  1008          *png_ptr_ptr = NULL;

  1009          png_write_destroy(png_ptr);

  1010          png_destroy_png_struct(png_ptr);

  1011       }

  1012    }

  1013 }

  1014 

  1015 /* Allow the application to select one or more row filters to use. */

  1016 void PNGAPI

  1017 png_set_filter(png_structrp png_ptr, int method, int filters)

  1018 {

  1019    png_debug(1, "in png_set_filter");

  1020 

  1021    if (png_ptr == NULL)

  1022       return;

  1023 

  1024 #ifdef PNG_MNG_FEATURES_SUPPORTED

  1025    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&

  1026        (method == PNG_INTRAPIXEL_DIFFERENCING))

  1027       method = PNG_FILTER_TYPE_BASE;

  1028 

  1029 #endif

  1030    if (method == PNG_FILTER_TYPE_BASE)

  1031    {

  1032       switch (filters & (PNG_ALL_FILTERS | 0x07))

  1033       {

  1034 #ifdef PNG_WRITE_FILTER_SUPPORTED

  1035          case 5:

  1036          case 6:

  1037          case 7: png_app_error(png_ptr, "Unknown row filter for method 0");

  1038             /* FALL THROUGH */

  1039 #endif /* WRITE_FILTER */

  1040          case PNG_FILTER_VALUE_NONE:

  1041             png_ptr->do_filter = PNG_FILTER_NONE; break;

  1042 

  1043 #ifdef PNG_WRITE_FILTER_SUPPORTED

  1044          case PNG_FILTER_VALUE_SUB:

  1045             png_ptr->do_filter = PNG_FILTER_SUB; break;

  1046 

  1047          case PNG_FILTER_VALUE_UP:

  1048             png_ptr->do_filter = PNG_FILTER_UP; break;

  1049 

  1050          case PNG_FILTER_VALUE_AVG:

  1051             png_ptr->do_filter = PNG_FILTER_AVG; break;

  1052 

  1053          case PNG_FILTER_VALUE_PAETH:

  1054             png_ptr->do_filter = PNG_FILTER_PAETH; break;

  1055 

  1056          default:

  1057             png_ptr->do_filter = (png_byte)filters; break;

  1058 #else

  1059          default:

  1060             png_app_error(png_ptr, "Unknown row filter for method 0");

  1061 #endif /* WRITE_FILTER */

  1062       }

  1063 

  1064 #ifdef PNG_WRITE_FILTER_SUPPORTED

  1065       /* If we have allocated the row_buf, this means we have already started

  1066        * with the image and we should have allocated all of the filter buffers

  1067        * that have been selected.  If prev_row isn't already allocated, then

  1068        * it is too late to start using the filters that need it, since we

  1069        * will be missing the data in the previous row.  If an application

  1070        * wants to start and stop using particular filters during compression,

  1071        * it should start out with all of the filters, and then remove them

  1072        * or add them back after the start of compression.

  1073        *

  1074        * NOTE: this is a nasty constraint on the code, because it means that the

  1075        * prev_row buffer must be maintained even if there are currently no

  1076        * 'prev_row' requiring filters active.

  1077        */

  1078       if (png_ptr->row_buf != NULL)

  1079       {

  1080          int num_filters;

  1081          png_alloc_size_t buf_size;

  1082 

  1083          /* Repeat the checks in png_write_start_row; 1 pixel high or wide

  1084           * images cannot benefit from certain filters.  If this isn't done here

  1085           * the check below will fire on 1 pixel high images.

  1086           */

  1087          if (png_ptr->height == 1)

  1088             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);

  1089 

  1090          if (png_ptr->width == 1)

  1091             filters &= ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);

  1092 

  1093          if ((filters & (PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH)) != 0

  1094             && png_ptr->prev_row == NULL)

  1095          {

  1096             /* This is the error case, however it is benign - the previous row

  1097              * is not available so the filter can't be used.  Just warn here.

  1098              */

  1099             png_app_warning(png_ptr,

  1100                "png_set_filter: UP/AVG/PAETH cannot be added after start");

  1101             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);

  1102          }

  1103 

  1104          num_filters = 0;

  1105 

  1106          if (filters & PNG_FILTER_SUB)

  1107             num_filters++;

  1108 

  1109          if (filters & PNG_FILTER_UP)

  1110             num_filters++;

  1111 

  1112          if (filters & PNG_FILTER_AVG)

  1113             num_filters++;

  1114 

  1115          if (filters & PNG_FILTER_PAETH)

  1116             num_filters++;

  1117 

  1118          /* Allocate needed row buffers if they have not already been

  1119           * allocated.

  1120           */

  1121          buf_size = PNG_ROWBYTES(png_ptr->usr_channels * png_ptr->usr_bit_depth,

  1122              png_ptr->width) + 1;

  1123 

  1124          if (png_ptr->try_row == NULL)

  1125             png_ptr->try_row = png_voidcast(png_bytep,

  1126                png_malloc(png_ptr, buf_size));

  1127 

  1128          if (num_filters > 1)

  1129          {

  1130             if (png_ptr->tst_row == NULL)

  1131                png_ptr->tst_row = png_voidcast(png_bytep,

  1132                   png_malloc(png_ptr, buf_size));

  1133          }

  1134       }