"Fossies" - the Fresh Open Source Software Archive

Member "stella-6.0.2/src/libpng/pngread.c" (11 Oct 2019, 142155 Bytes) of package /linux/privat/stella-6.0.2-src.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "pngread.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 5.1.3_vs_6.0.

    1 
    2 /* pngread.c - read a PNG file
    3  *
    4  * Copyright (c) 2018 Cosmin Truta
    5  * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
    6  * Copyright (c) 1996-1997 Andreas Dilger
    7  * 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  * This file contains routines that an application calls directly to
   14  * read a PNG file or stream.
   15  */
   16 
   17 #include "pngpriv.h"
   18 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
   19 #  include <errno.h>
   20 #endif
   21 
   22 #ifdef PNG_READ_SUPPORTED
   23 
   24 /* Create a PNG structure for reading, and allocate any memory needed. */
   25 PNG_FUNCTION(png_structp,PNGAPI
   26 png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
   27     png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
   28 {
   29 #ifndef PNG_USER_MEM_SUPPORTED
   30    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
   31         error_fn, warn_fn, NULL, NULL, NULL);
   32 #else
   33    return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
   34         warn_fn, NULL, NULL, NULL);
   35 }
   36 
   37 /* Alternate create PNG structure for reading, and allocate any memory
   38  * needed.
   39  */
   40 PNG_FUNCTION(png_structp,PNGAPI
   41 png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
   42     png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
   43     png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
   44 {
   45    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
   46        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
   47 #endif /* USER_MEM */
   48 
   49    if (png_ptr != NULL)
   50    {
   51       png_ptr->mode = PNG_IS_READ_STRUCT;
   52 
   53       /* Added in libpng-1.6.0; this can be used to detect a read structure if
   54        * required (it will be zero in a write structure.)
   55        */
   56 #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
   57          png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
   58 #     endif
   59 
   60 #     ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED
   61          png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
   62 
   63          /* In stable builds only warn if an application error can be completely
   64           * handled.
   65           */
   66 #        if PNG_RELEASE_BUILD
   67             png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
   68 #        endif
   69 #     endif
   70 
   71       /* TODO: delay this, it can be done in png_init_io (if the app doesn't
   72        * do it itself) avoiding setting the default function if it is not
   73        * required.
   74        */
   75       png_set_read_fn(png_ptr, NULL, NULL);
   76    }
   77 
   78    return png_ptr;
   79 }
   80 
   81 
   82 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
   83 /* Read the information before the actual image data.  This has been
   84  * changed in v0.90 to allow reading a file that already has the magic
   85  * bytes read from the stream.  You can tell libpng how many bytes have
   86  * been read from the beginning of the stream (up to the maximum of 8)
   87  * via png_set_sig_bytes(), and we will only check the remaining bytes
   88  * here.  The application can then have access to the signature bytes we
   89  * read if it is determined that this isn't a valid PNG file.
   90  */
   91 void PNGAPI
   92 png_read_info(png_structrp png_ptr, png_inforp info_ptr)
   93 {
   94 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
   95    int keep;
   96 #endif
   97 
   98    png_debug(1, "in png_read_info");
   99 
  100    if (png_ptr == NULL || info_ptr == NULL)
  101       return;
  102 
  103    /* Read and check the PNG file signature. */
  104    png_read_sig(png_ptr, info_ptr);
  105 
  106    for (;;)
  107    {
  108       png_uint_32 length = png_read_chunk_header(png_ptr);
  109       png_uint_32 chunk_name = png_ptr->chunk_name;
  110 
  111       /* IDAT logic needs to happen here to simplify getting the two flags
  112        * right.
  113        */
  114       if (chunk_name == png_IDAT)
  115       {
  116          if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
  117             png_chunk_error(png_ptr, "Missing IHDR before IDAT");
  118 
  119          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  120              (png_ptr->mode & PNG_HAVE_PLTE) == 0)
  121             png_chunk_error(png_ptr, "Missing PLTE before IDAT");
  122 
  123          else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
  124             png_chunk_benign_error(png_ptr, "Too many IDATs found");
  125 
  126          png_ptr->mode |= PNG_HAVE_IDAT;
  127       }
  128 
  129       else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
  130       {
  131          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
  132          png_ptr->mode |= PNG_AFTER_IDAT;
  133       }
  134 
  135       /* This should be a binary subdivision search or a hash for
  136        * matching the chunk name rather than a linear search.
  137        */
  138       if (chunk_name == png_IHDR)
  139          png_handle_IHDR(png_ptr, info_ptr, length);
  140 
  141       else if (chunk_name == png_IEND)
  142          png_handle_IEND(png_ptr, info_ptr, length);
  143 
  144 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  145       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
  146       {
  147          png_handle_unknown(png_ptr, info_ptr, length, keep);
  148 
  149          if (chunk_name == png_PLTE)
  150             png_ptr->mode |= PNG_HAVE_PLTE;
  151 
  152          else if (chunk_name == png_IDAT)
  153          {
  154             png_ptr->idat_size = 0; /* It has been consumed */
  155             break;
  156          }
  157       }
  158 #endif
  159       else if (chunk_name == png_PLTE)
  160          png_handle_PLTE(png_ptr, info_ptr, length);
  161 
  162       else if (chunk_name == png_IDAT)
  163       {
  164          png_ptr->idat_size = length;
  165          break;
  166       }
  167 
  168 #ifdef PNG_READ_bKGD_SUPPORTED
  169       else if (chunk_name == png_bKGD)
  170          png_handle_bKGD(png_ptr, info_ptr, length);
  171 #endif
  172 
  173 #ifdef PNG_READ_cHRM_SUPPORTED
  174       else if (chunk_name == png_cHRM)
  175          png_handle_cHRM(png_ptr, info_ptr, length);
  176 #endif
  177 
  178 #ifdef PNG_READ_eXIf_SUPPORTED
  179       else if (chunk_name == png_eXIf)
  180          png_handle_eXIf(png_ptr, info_ptr, length);
  181 #endif
  182 
  183 #ifdef PNG_READ_gAMA_SUPPORTED
  184       else if (chunk_name == png_gAMA)
  185          png_handle_gAMA(png_ptr, info_ptr, length);
  186 #endif
  187 
  188 #ifdef PNG_READ_hIST_SUPPORTED
  189       else if (chunk_name == png_hIST)
  190          png_handle_hIST(png_ptr, info_ptr, length);
  191 #endif
  192 
  193 #ifdef PNG_READ_oFFs_SUPPORTED
  194       else if (chunk_name == png_oFFs)
  195          png_handle_oFFs(png_ptr, info_ptr, length);
  196 #endif
  197 
  198 #ifdef PNG_READ_pCAL_SUPPORTED
  199       else if (chunk_name == png_pCAL)
  200          png_handle_pCAL(png_ptr, info_ptr, length);
  201 #endif
  202 
  203 #ifdef PNG_READ_sCAL_SUPPORTED
  204       else if (chunk_name == png_sCAL)
  205          png_handle_sCAL(png_ptr, info_ptr, length);
  206 #endif
  207 
  208 #ifdef PNG_READ_pHYs_SUPPORTED
  209       else if (chunk_name == png_pHYs)
  210          png_handle_pHYs(png_ptr, info_ptr, length);
  211 #endif
  212 
  213 #ifdef PNG_READ_sBIT_SUPPORTED
  214       else if (chunk_name == png_sBIT)
  215          png_handle_sBIT(png_ptr, info_ptr, length);
  216 #endif
  217 
  218 #ifdef PNG_READ_sRGB_SUPPORTED
  219       else if (chunk_name == png_sRGB)
  220          png_handle_sRGB(png_ptr, info_ptr, length);
  221 #endif
  222 
  223 #ifdef PNG_READ_iCCP_SUPPORTED
  224       else if (chunk_name == png_iCCP)
  225          png_handle_iCCP(png_ptr, info_ptr, length);
  226 #endif
  227 
  228 #ifdef PNG_READ_sPLT_SUPPORTED
  229       else if (chunk_name == png_sPLT)
  230          png_handle_sPLT(png_ptr, info_ptr, length);
  231 #endif
  232 
  233 #ifdef PNG_READ_tEXt_SUPPORTED
  234       else if (chunk_name == png_tEXt)
  235          png_handle_tEXt(png_ptr, info_ptr, length);
  236 #endif
  237 
  238 #ifdef PNG_READ_tIME_SUPPORTED
  239       else if (chunk_name == png_tIME)
  240          png_handle_tIME(png_ptr, info_ptr, length);
  241 #endif
  242 
  243 #ifdef PNG_READ_tRNS_SUPPORTED
  244       else if (chunk_name == png_tRNS)
  245          png_handle_tRNS(png_ptr, info_ptr, length);
  246 #endif
  247 
  248 #ifdef PNG_READ_zTXt_SUPPORTED
  249       else if (chunk_name == png_zTXt)
  250          png_handle_zTXt(png_ptr, info_ptr, length);
  251 #endif
  252 
  253 #ifdef PNG_READ_iTXt_SUPPORTED
  254       else if (chunk_name == png_iTXt)
  255          png_handle_iTXt(png_ptr, info_ptr, length);
  256 #endif
  257 
  258       else
  259          png_handle_unknown(png_ptr, info_ptr, length,
  260              PNG_HANDLE_CHUNK_AS_DEFAULT);
  261    }
  262 }
  263 #endif /* SEQUENTIAL_READ */
  264 
  265 /* Optional call to update the users info_ptr structure */
  266 void PNGAPI
  267 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
  268 {
  269    png_debug(1, "in png_read_update_info");
  270 
  271    if (png_ptr != NULL)
  272    {
  273       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
  274       {
  275          png_read_start_row(png_ptr);
  276 
  277 #        ifdef PNG_READ_TRANSFORMS_SUPPORTED
  278             png_read_transform_info(png_ptr, info_ptr);
  279 #        else
  280             PNG_UNUSED(info_ptr)
  281 #        endif
  282       }
  283 
  284       /* New in 1.6.0 this avoids the bug of doing the initializations twice */
  285       else
  286          png_app_error(png_ptr,
  287              "png_read_update_info/png_start_read_image: duplicate call");
  288    }
  289 }
  290 
  291 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  292 /* Initialize palette, background, etc, after transformations
  293  * are set, but before any reading takes place.  This allows
  294  * the user to obtain a gamma-corrected palette, for example.
  295  * If the user doesn't call this, we will do it ourselves.
  296  */
  297 void PNGAPI
  298 png_start_read_image(png_structrp png_ptr)
  299 {
  300    png_debug(1, "in png_start_read_image");
  301 
  302    if (png_ptr != NULL)
  303    {
  304       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
  305          png_read_start_row(png_ptr);
  306 
  307       /* New in 1.6.0 this avoids the bug of doing the initializations twice */
  308       else
  309          png_app_error(png_ptr,
  310              "png_start_read_image/png_read_update_info: duplicate call");
  311    }
  312 }
  313 #endif /* SEQUENTIAL_READ */
  314 
  315 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  316 #ifdef PNG_MNG_FEATURES_SUPPORTED
  317 /* Undoes intrapixel differencing,
  318  * NOTE: this is apparently only supported in the 'sequential' reader.
  319  */
  320 static void
  321 png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
  322 {
  323    png_debug(1, "in png_do_read_intrapixel");
  324 
  325    if (
  326        (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
  327    {
  328       int bytes_per_pixel;
  329       png_uint_32 row_width = row_info->width;
  330 
  331       if (row_info->bit_depth == 8)
  332       {
  333          png_bytep rp;
  334          png_uint_32 i;
  335 
  336          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  337             bytes_per_pixel = 3;
  338 
  339          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  340             bytes_per_pixel = 4;
  341 
  342          else
  343             return;
  344 
  345          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  346          {
  347             *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);
  348             *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);
  349          }
  350       }
  351       else if (row_info->bit_depth == 16)
  352       {
  353          png_bytep rp;
  354          png_uint_32 i;
  355 
  356          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  357             bytes_per_pixel = 6;
  358 
  359          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  360             bytes_per_pixel = 8;
  361 
  362          else
  363             return;
  364 
  365          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
  366          {
  367             png_uint_32 s0   = (png_uint_32)(*(rp    ) << 8) | *(rp + 1);
  368             png_uint_32 s1   = (png_uint_32)(*(rp + 2) << 8) | *(rp + 3);
  369             png_uint_32 s2   = (png_uint_32)(*(rp + 4) << 8) | *(rp + 5);
  370             png_uint_32 red  = (s0 + s1 + 65536) & 0xffff;
  371             png_uint_32 blue = (s2 + s1 + 65536) & 0xffff;
  372             *(rp    ) = (png_byte)((red >> 8) & 0xff);
  373             *(rp + 1) = (png_byte)(red & 0xff);
  374             *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
  375             *(rp + 5) = (png_byte)(blue & 0xff);
  376          }
  377       }
  378    }
  379 }
  380 #endif /* MNG_FEATURES */
  381 
  382 void PNGAPI
  383 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
  384 {
  385    png_row_info row_info;
  386 
  387    if (png_ptr == NULL)
  388       return;
  389 
  390    png_debug2(1, "in png_read_row (row %lu, pass %d)",
  391        (unsigned long)png_ptr->row_number, png_ptr->pass);
  392 
  393    /* png_read_start_row sets the information (in particular iwidth) for this
  394     * interlace pass.
  395     */
  396    if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
  397       png_read_start_row(png_ptr);
  398 
  399    /* 1.5.6: row_info moved out of png_struct to a local here. */
  400    row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
  401    row_info.color_type = png_ptr->color_type;
  402    row_info.bit_depth = png_ptr->bit_depth;
  403    row_info.channels = png_ptr->channels;
  404    row_info.pixel_depth = png_ptr->pixel_depth;
  405    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
  406 
  407 #ifdef PNG_WARNINGS_SUPPORTED
  408    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
  409    {
  410    /* Check for transforms that have been set but were defined out */
  411 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
  412    if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
  413       png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
  414 #endif
  415 
  416 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
  417    if ((png_ptr->transformations & PNG_FILLER) != 0)
  418       png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
  419 #endif
  420 
  421 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
  422     !defined(PNG_READ_PACKSWAP_SUPPORTED)
  423    if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
  424       png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
  425 #endif
  426 
  427 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
  428    if ((png_ptr->transformations & PNG_PACK) != 0)
  429       png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
  430 #endif
  431 
  432 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
  433    if ((png_ptr->transformations & PNG_SHIFT) != 0)
  434       png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
  435 #endif
  436 
  437 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
  438    if ((png_ptr->transformations & PNG_BGR) != 0)
  439       png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
  440 #endif
  441 
  442 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
  443    if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
  444       png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
  445 #endif
  446    }
  447 #endif /* WARNINGS */
  448 
  449 #ifdef PNG_READ_INTERLACING_SUPPORTED
  450    /* If interlaced and we do not need a new row, combine row and return.
  451     * Notice that the pixels we have from previous rows have been transformed
  452     * already; we can only combine like with like (transformed or
  453     * untransformed) and, because of the libpng API for interlaced images, this
  454     * means we must transform before de-interlacing.
  455     */
  456    if (png_ptr->interlaced != 0 &&
  457        (png_ptr->transformations & PNG_INTERLACE) != 0)
  458    {
  459       switch (png_ptr->pass)
  460       {
  461          case 0:
  462             if (png_ptr->row_number & 0x07)
  463             {
  464                if (dsp_row != NULL)
  465                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  466                png_read_finish_row(png_ptr);
  467                return;
  468             }
  469             break;
  470 
  471          case 1:
  472             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
  473             {
  474                if (dsp_row != NULL)
  475                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  476 
  477                png_read_finish_row(png_ptr);
  478                return;
  479             }
  480             break;
  481 
  482          case 2:
  483             if ((png_ptr->row_number & 0x07) != 4)
  484             {
  485                if (dsp_row != NULL && (png_ptr->row_number & 4))
  486                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  487 
  488                png_read_finish_row(png_ptr);
  489                return;
  490             }
  491             break;
  492 
  493          case 3:
  494             if ((png_ptr->row_number & 3) || png_ptr->width < 3)
  495             {
  496                if (dsp_row != NULL)
  497                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  498 
  499                png_read_finish_row(png_ptr);
  500                return;
  501             }
  502             break;
  503 
  504          case 4:
  505             if ((png_ptr->row_number & 3) != 2)
  506             {
  507                if (dsp_row != NULL && (png_ptr->row_number & 2))
  508                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  509 
  510                png_read_finish_row(png_ptr);
  511                return;
  512             }
  513             break;
  514 
  515          case 5:
  516             if ((png_ptr->row_number & 1) || png_ptr->width < 2)
  517             {
  518                if (dsp_row != NULL)
  519                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
  520 
  521                png_read_finish_row(png_ptr);
  522                return;
  523             }
  524             break;
  525 
  526          default:
  527          case 6:
  528             if ((png_ptr->row_number & 1) == 0)
  529             {
  530                png_read_finish_row(png_ptr);
  531                return;
  532             }
  533             break;
  534       }
  535    }
  536 #endif
  537 
  538    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
  539       png_error(png_ptr, "Invalid attempt to read row data");
  540 
  541    /* Fill the row with IDAT data: */
  542    png_ptr->row_buf[0]=255; /* to force error if no data was found */
  543    png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
  544 
  545    if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
  546    {
  547       if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
  548          png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
  549              png_ptr->prev_row + 1, png_ptr->row_buf[0]);
  550       else
  551          png_error(png_ptr, "bad adaptive filter value");
  552    }
  553 
  554    /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
  555     * 1.5.6, while the buffer really is this big in current versions of libpng
  556     * it may not be in the future, so this was changed just to copy the
  557     * interlaced count:
  558     */
  559    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
  560 
  561 #ifdef PNG_MNG_FEATURES_SUPPORTED
  562    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
  563        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
  564    {
  565       /* Intrapixel differencing */
  566       png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
  567    }
  568 #endif
  569 
  570 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
  571    if (png_ptr->transformations)
  572       png_do_read_transformations(png_ptr, &row_info);
  573 #endif
  574 
  575    /* The transformed pixel depth should match the depth now in row_info. */
  576    if (png_ptr->transformed_pixel_depth == 0)
  577    {
  578       png_ptr->transformed_pixel_depth = row_info.pixel_depth;
  579       if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
  580          png_error(png_ptr, "sequential row overflow");
  581    }
  582 
  583    else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
  584       png_error(png_ptr, "internal sequential row size calculation error");
  585 
  586 #ifdef PNG_READ_INTERLACING_SUPPORTED
  587    /* Expand interlaced rows to full size */
  588    if (png_ptr->interlaced != 0 &&
  589       (png_ptr->transformations & PNG_INTERLACE) != 0)
  590    {
  591       if (png_ptr->pass < 6)
  592          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
  593              png_ptr->transformations);
  594 
  595       if (dsp_row != NULL)
  596          png_combine_row(png_ptr, dsp_row, 1/*display*/);
  597 
  598       if (row != NULL)
  599          png_combine_row(png_ptr, row, 0/*row*/);
  600    }
  601 
  602    else
  603 #endif
  604    {
  605       if (row != NULL)
  606          png_combine_row(png_ptr, row, -1/*ignored*/);
  607 
  608       if (dsp_row != NULL)
  609          png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
  610    }
  611    png_read_finish_row(png_ptr);
  612 
  613    if (png_ptr->read_row_fn != NULL)
  614       (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
  615 
  616 }
  617 #endif /* SEQUENTIAL_READ */
  618 
  619 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  620 /* Read one or more rows of image data.  If the image is interlaced,
  621  * and png_set_interlace_handling() has been called, the rows need to
  622  * contain the contents of the rows from the previous pass.  If the
  623  * image has alpha or transparency, and png_handle_alpha()[*] has been
  624  * called, the rows contents must be initialized to the contents of the
  625  * screen.
  626  *
  627  * "row" holds the actual image, and pixels are placed in it
  628  * as they arrive.  If the image is displayed after each pass, it will
  629  * appear to "sparkle" in.  "display_row" can be used to display a
  630  * "chunky" progressive image, with finer detail added as it becomes
  631  * available.  If you do not want this "chunky" display, you may pass
  632  * NULL for display_row.  If you do not want the sparkle display, and
  633  * you have not called png_handle_alpha(), you may pass NULL for rows.
  634  * If you have called png_handle_alpha(), and the image has either an
  635  * alpha channel or a transparency chunk, you must provide a buffer for
  636  * rows.  In this case, you do not have to provide a display_row buffer
  637  * also, but you may.  If the image is not interlaced, or if you have
  638  * not called png_set_interlace_handling(), the display_row buffer will
  639  * be ignored, so pass NULL to it.
  640  *
  641  * [*] png_handle_alpha() does not exist yet, as of this version of libpng
  642  */
  643 
  644 void PNGAPI
  645 png_read_rows(png_structrp png_ptr, png_bytepp row,
  646     png_bytepp display_row, png_uint_32 num_rows)
  647 {
  648    png_uint_32 i;
  649    png_bytepp rp;
  650    png_bytepp dp;
  651 
  652    png_debug(1, "in png_read_rows");
  653 
  654    if (png_ptr == NULL)
  655       return;
  656 
  657    rp = row;
  658    dp = display_row;
  659    if (rp != NULL && dp != NULL)
  660       for (i = 0; i < num_rows; i++)
  661       {
  662          png_bytep rptr = *rp++;
  663          png_bytep dptr = *dp++;
  664 
  665          png_read_row(png_ptr, rptr, dptr);
  666       }
  667 
  668    else if (rp != NULL)
  669       for (i = 0; i < num_rows; i++)
  670       {
  671          png_bytep rptr = *rp;
  672          png_read_row(png_ptr, rptr, NULL);
  673          rp++;
  674       }
  675 
  676    else if (dp != NULL)
  677       for (i = 0; i < num_rows; i++)
  678       {
  679          png_bytep dptr = *dp;
  680          png_read_row(png_ptr, NULL, dptr);
  681          dp++;
  682       }
  683 }
  684 #endif /* SEQUENTIAL_READ */
  685 
  686 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  687 /* Read the entire image.  If the image has an alpha channel or a tRNS
  688  * chunk, and you have called png_handle_alpha()[*], you will need to
  689  * initialize the image to the current image that PNG will be overlaying.
  690  * We set the num_rows again here, in case it was incorrectly set in
  691  * png_read_start_row() by a call to png_read_update_info() or
  692  * png_start_read_image() if png_set_interlace_handling() wasn't called
  693  * prior to either of these functions like it should have been.  You can
  694  * only call this function once.  If you desire to have an image for
  695  * each pass of a interlaced image, use png_read_rows() instead.
  696  *
  697  * [*] png_handle_alpha() does not exist yet, as of this version of libpng
  698  */
  699 void PNGAPI
  700 png_read_image(png_structrp png_ptr, png_bytepp image)
  701 {
  702    png_uint_32 i, image_height;
  703    int pass, j;
  704    png_bytepp rp;
  705 
  706    png_debug(1, "in png_read_image");
  707 
  708    if (png_ptr == NULL)
  709       return;
  710 
  711 #ifdef PNG_READ_INTERLACING_SUPPORTED
  712    if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
  713    {
  714       pass = png_set_interlace_handling(png_ptr);
  715       /* And make sure transforms are initialized. */
  716       png_start_read_image(png_ptr);
  717    }
  718    else
  719    {
  720       if (png_ptr->interlaced != 0 &&
  721           (png_ptr->transformations & PNG_INTERLACE) == 0)
  722       {
  723          /* Caller called png_start_read_image or png_read_update_info without
  724           * first turning on the PNG_INTERLACE transform.  We can fix this here,
  725           * but the caller should do it!
  726           */
  727          png_warning(png_ptr, "Interlace handling should be turned on when "
  728              "using png_read_image");
  729          /* Make sure this is set correctly */
  730          png_ptr->num_rows = png_ptr->height;
  731       }
  732 
  733       /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in
  734        * the above error case.
  735        */
  736       pass = png_set_interlace_handling(png_ptr);
  737    }
  738 #else
  739    if (png_ptr->interlaced)
  740       png_error(png_ptr,
  741           "Cannot read interlaced image -- interlace handler disabled");
  742 
  743    pass = 1;
  744 #endif
  745 
  746    image_height=png_ptr->height;
  747 
  748    for (j = 0; j < pass; j++)
  749    {
  750       rp = image;
  751       for (i = 0; i < image_height; i++)
  752       {
  753          png_read_row(png_ptr, *rp, NULL);
  754          rp++;
  755       }
  756    }
  757 }
  758 #endif /* SEQUENTIAL_READ */
  759 
  760 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
  761 /* Read the end of the PNG file.  Will not read past the end of the
  762  * file, will verify the end is accurate, and will read any comments
  763  * or time information at the end of the file, if info is not NULL.
  764  */
  765 void PNGAPI
  766 png_read_end(png_structrp png_ptr, png_inforp info_ptr)
  767 {
  768 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  769    int keep;
  770 #endif
  771 
  772    png_debug(1, "in png_read_end");
  773 
  774    if (png_ptr == NULL)
  775       return;
  776 
  777    /* If png_read_end is called in the middle of reading the rows there may
  778     * still be pending IDAT data and an owned zstream.  Deal with this here.
  779     */
  780 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  781    if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
  782 #endif
  783       png_read_finish_IDAT(png_ptr);
  784 
  785 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
  786    /* Report invalid palette index; added at libng-1.5.10 */
  787    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  788        png_ptr->num_palette_max > png_ptr->num_palette)
  789       png_benign_error(png_ptr, "Read palette index exceeding num_palette");
  790 #endif
  791 
  792    do
  793    {
  794       png_uint_32 length = png_read_chunk_header(png_ptr);
  795       png_uint_32 chunk_name = png_ptr->chunk_name;
  796 
  797       if (chunk_name != png_IDAT)
  798          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
  799 
  800       if (chunk_name == png_IEND)
  801          png_handle_IEND(png_ptr, info_ptr, length);
  802 
  803       else if (chunk_name == png_IHDR)
  804          png_handle_IHDR(png_ptr, info_ptr, length);
  805 
  806       else if (info_ptr == NULL)
  807          png_crc_finish(png_ptr, length);
  808 
  809 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  810       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
  811       {
  812          if (chunk_name == png_IDAT)
  813          {
  814             if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
  815                 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
  816                png_benign_error(png_ptr, ".Too many IDATs found");
  817          }
  818          png_handle_unknown(png_ptr, info_ptr, length, keep);
  819          if (chunk_name == png_PLTE)
  820             png_ptr->mode |= PNG_HAVE_PLTE;
  821       }
  822 #endif
  823 
  824       else if (chunk_name == png_IDAT)
  825       {
  826          /* Zero length IDATs are legal after the last IDAT has been
  827           * read, but not after other chunks have been read.  1.6 does not
  828           * always read all the deflate data; specifically it cannot be relied
  829           * upon to read the Adler32 at the end.  If it doesn't ignore IDAT
  830           * chunks which are longer than zero as well:
  831           */
  832          if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
  833              || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
  834             png_benign_error(png_ptr, "..Too many IDATs found");
  835 
  836          png_crc_finish(png_ptr, length);
  837       }
  838       else if (chunk_name == png_PLTE)
  839          png_handle_PLTE(png_ptr, info_ptr, length);
  840 
  841 #ifdef PNG_READ_bKGD_SUPPORTED
  842       else if (chunk_name == png_bKGD)
  843          png_handle_bKGD(png_ptr, info_ptr, length);
  844 #endif
  845 
  846 #ifdef PNG_READ_cHRM_SUPPORTED
  847       else if (chunk_name == png_cHRM)
  848          png_handle_cHRM(png_ptr, info_ptr, length);
  849 #endif
  850 
  851 #ifdef PNG_READ_eXIf_SUPPORTED
  852       else if (chunk_name == png_eXIf)
  853          png_handle_eXIf(png_ptr, info_ptr, length);
  854 #endif
  855 
  856 #ifdef PNG_READ_gAMA_SUPPORTED
  857       else if (chunk_name == png_gAMA)
  858          png_handle_gAMA(png_ptr, info_ptr, length);
  859 #endif
  860 
  861 #ifdef PNG_READ_hIST_SUPPORTED
  862       else if (chunk_name == png_hIST)
  863          png_handle_hIST(png_ptr, info_ptr, length);
  864 #endif
  865 
  866 #ifdef PNG_READ_oFFs_SUPPORTED
  867       else if (chunk_name == png_oFFs)
  868          png_handle_oFFs(png_ptr, info_ptr, length);
  869 #endif
  870 
  871 #ifdef PNG_READ_pCAL_SUPPORTED
  872       else if (chunk_name == png_pCAL)
  873          png_handle_pCAL(png_ptr, info_ptr, length);
  874 #endif
  875 
  876 #ifdef PNG_READ_sCAL_SUPPORTED
  877       else if (chunk_name == png_sCAL)
  878          png_handle_sCAL(png_ptr, info_ptr, length);
  879 #endif
  880 
  881 #ifdef PNG_READ_pHYs_SUPPORTED
  882       else if (chunk_name == png_pHYs)
  883          png_handle_pHYs(png_ptr, info_ptr, length);
  884 #endif
  885 
  886 #ifdef PNG_READ_sBIT_SUPPORTED
  887       else if (chunk_name == png_sBIT)
  888          png_handle_sBIT(png_ptr, info_ptr, length);
  889 #endif
  890 
  891 #ifdef PNG_READ_sRGB_SUPPORTED
  892       else if (chunk_name == png_sRGB)
  893          png_handle_sRGB(png_ptr, info_ptr, length);
  894 #endif
  895 
  896 #ifdef PNG_READ_iCCP_SUPPORTED
  897       else if (chunk_name == png_iCCP)
  898          png_handle_iCCP(png_ptr, info_ptr, length);
  899 #endif
  900 
  901 #ifdef PNG_READ_sPLT_SUPPORTED
  902       else if (chunk_name == png_sPLT)
  903          png_handle_sPLT(png_ptr, info_ptr, length);
  904 #endif
  905 
  906 #ifdef PNG_READ_tEXt_SUPPORTED
  907       else if (chunk_name == png_tEXt)
  908          png_handle_tEXt(png_ptr, info_ptr, length);
  909 #endif
  910 
  911 #ifdef PNG_READ_tIME_SUPPORTED
  912       else if (chunk_name == png_tIME)
  913          png_handle_tIME(png_ptr, info_ptr, length);
  914 #endif
  915 
  916 #ifdef PNG_READ_tRNS_SUPPORTED
  917       else if (chunk_name == png_tRNS)
  918          png_handle_tRNS(png_ptr, info_ptr, length);
  919 #endif
  920 
  921 #ifdef PNG_READ_zTXt_SUPPORTED
  922       else if (chunk_name == png_zTXt)
  923          png_handle_zTXt(png_ptr, info_ptr, length);
  924 #endif
  925 
  926 #ifdef PNG_READ_iTXt_SUPPORTED
  927       else if (chunk_name == png_iTXt)
  928          png_handle_iTXt(png_ptr, info_ptr, length);
  929 #endif
  930 
  931       else
  932          png_handle_unknown(png_ptr, info_ptr, length,
  933              PNG_HANDLE_CHUNK_AS_DEFAULT);
  934    } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
  935 }
  936 #endif /* SEQUENTIAL_READ */
  937 
  938 /* Free all memory used in the read struct */
  939 static void
  940 png_read_destroy(png_structrp png_ptr)
  941 {
  942    png_debug(1, "in png_read_destroy");
  943 
  944 #ifdef PNG_READ_GAMMA_SUPPORTED
  945    png_destroy_gamma_table(png_ptr);
  946 #endif
  947 
  948    png_free(png_ptr, png_ptr->big_row_buf);
  949    png_ptr->big_row_buf = NULL;
  950    png_free(png_ptr, png_ptr->big_prev_row);
  951    png_ptr->big_prev_row = NULL;
  952    png_free(png_ptr, png_ptr->read_buffer);
  953    png_ptr->read_buffer = NULL;
  954 
  955 #ifdef PNG_READ_QUANTIZE_SUPPORTED
  956    png_free(png_ptr, png_ptr->palette_lookup);
  957    png_ptr->palette_lookup = NULL;
  958    png_free(png_ptr, png_ptr->quantize_index);
  959    png_ptr->quantize_index = NULL;
  960 #endif
  961 
  962    if ((png_ptr->free_me & PNG_FREE_PLTE) != 0)
  963    {
  964       png_zfree(png_ptr, png_ptr->palette);
  965       png_ptr->palette = NULL;
  966    }
  967    png_ptr->free_me &= ~PNG_FREE_PLTE;
  968 
  969 #if defined(PNG_tRNS_SUPPORTED) || \
  970     defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  971    if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
  972    {
  973       png_free(png_ptr, png_ptr->trans_alpha);
  974       png_ptr->trans_alpha = NULL;
  975    }
  976    png_ptr->free_me &= ~PNG_FREE_TRNS;
  977 #endif
  978 
  979    inflateEnd(&png_ptr->zstream);
  980 
  981 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  982    png_free(png_ptr, png_ptr->save_buffer);
  983    png_ptr->save_buffer = NULL;
  984 #endif
  985 
  986 #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) && \
  987    defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
  988    png_free(png_ptr, png_ptr->unknown_chunk.data);
  989    png_ptr->unknown_chunk.data = NULL;
  990 #endif
  991 
  992 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
  993    png_free(png_ptr, png_ptr->chunk_list);
  994    png_ptr->chunk_list = NULL;
  995 #endif
  996 
  997    /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error
  998     * callbacks are still set at this point.  They are required to complete the
  999     * destruction of the png_struct itself.
 1000     */
 1001 }
 1002 
 1003 /* Free all memory used by the read */
 1004 void PNGAPI
 1005 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 1006     png_infopp end_info_ptr_ptr)
 1007 {
 1008    png_structrp png_ptr = NULL;
 1009 
 1010    png_debug(1, "in png_destroy_read_struct");
 1011 
 1012    if (png_ptr_ptr != NULL)
 1013       png_ptr = *png_ptr_ptr;
 1014 
 1015    if (png_ptr == NULL)
 1016       return;
 1017 
 1018    /* libpng 1.6.0: use the API to destroy info structs to ensure consistent
 1019     * behavior.  Prior to 1.6.0 libpng did extra 'info' destruction in this API.
 1020     * The extra was, apparently, unnecessary yet this hides memory leak bugs.
 1021     */
 1022    png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
 1023    png_destroy_info_struct(png_ptr, info_ptr_ptr);
 1024 
 1025    *png_ptr_ptr = NULL;
 1026    png_read_destroy(png_ptr);
 1027    png_destroy_png_struct(png_ptr);
 1028 }
 1029 
 1030 void PNGAPI
 1031 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
 1032 {
 1033    if (png_ptr == NULL)
 1034       return;
 1035 
 1036    png_ptr->read_row_fn = read_row_fn;
 1037 }
 1038 
 1039 
 1040 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1041 #ifdef PNG_INFO_IMAGE_SUPPORTED
 1042 void PNGAPI
 1043 png_read_png(png_structrp png_ptr, png_inforp info_ptr,
 1044     int transforms, voidp params)
 1045 {
 1046    if (png_ptr == NULL || info_ptr == NULL)
 1047       return;
 1048 
 1049    /* png_read_info() gives us all of the information from the
 1050     * PNG file before the first IDAT (image data chunk).
 1051     */
 1052    png_read_info(png_ptr, info_ptr);
 1053    if (info_ptr->height > PNG_UINT_32_MAX/(sizeof (png_bytep)))
 1054       png_error(png_ptr, "Image is too high to process with png_read_png()");
 1055 
 1056    /* -------------- image transformations start here ------------------- */
 1057    /* libpng 1.6.10: add code to cause a png_app_error if a selected TRANSFORM
 1058     * is not implemented.  This will only happen in de-configured (non-default)
 1059     * libpng builds.  The results can be unexpected - png_read_png may return
 1060     * short or mal-formed rows because the transform is skipped.
 1061     */
 1062 
 1063    /* Tell libpng to strip 16-bit/color files down to 8 bits per color.
 1064     */
 1065    if ((transforms & PNG_TRANSFORM_SCALE_16) != 0)
 1066       /* Added at libpng-1.5.4. "strip_16" produces the same result that it
 1067        * did in earlier versions, while "scale_16" is now more accurate.
 1068        */
 1069 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
 1070       png_set_scale_16(png_ptr);
 1071 #else
 1072       png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported");
 1073 #endif
 1074 
 1075    /* If both SCALE and STRIP are required pngrtran will effectively cancel the
 1076     * latter by doing SCALE first.  This is ok and allows apps not to check for
 1077     * which is supported to get the right answer.
 1078     */
 1079    if ((transforms & PNG_TRANSFORM_STRIP_16) != 0)
 1080 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
 1081       png_set_strip_16(png_ptr);
 1082 #else
 1083       png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported");
 1084 #endif
 1085 
 1086    /* Strip alpha bytes from the input data without combining with
 1087     * the background (not recommended).
 1088     */
 1089    if ((transforms & PNG_TRANSFORM_STRIP_ALPHA) != 0)
 1090 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 1091       png_set_strip_alpha(png_ptr);
 1092 #else
 1093       png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported");
 1094 #endif
 1095 
 1096    /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
 1097     * byte into separate bytes (useful for paletted and grayscale images).
 1098     */
 1099    if ((transforms & PNG_TRANSFORM_PACKING) != 0)
 1100 #ifdef PNG_READ_PACK_SUPPORTED
 1101       png_set_packing(png_ptr);
 1102 #else
 1103       png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported");
 1104 #endif
 1105 
 1106    /* Change the order of packed pixels to least significant bit first
 1107     * (not useful if you are using png_set_packing).
 1108     */
 1109    if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
 1110 #ifdef PNG_READ_PACKSWAP_SUPPORTED
 1111       png_set_packswap(png_ptr);
 1112 #else
 1113       png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported");
 1114 #endif
 1115 
 1116    /* Expand paletted colors into true RGB triplets
 1117     * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
 1118     * Expand paletted or RGB images with transparency to full alpha
 1119     * channels so the data will be available as RGBA quartets.
 1120     */
 1121    if ((transforms & PNG_TRANSFORM_EXPAND) != 0)
 1122 #ifdef PNG_READ_EXPAND_SUPPORTED
 1123       png_set_expand(png_ptr);
 1124 #else
 1125       png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported");
 1126 #endif
 1127 
 1128    /* We don't handle background color or gamma transformation or quantizing.
 1129     */
 1130 
 1131    /* Invert monochrome files to have 0 as white and 1 as black
 1132     */
 1133    if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
 1134 #ifdef PNG_READ_INVERT_SUPPORTED
 1135       png_set_invert_mono(png_ptr);
 1136 #else
 1137       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported");
 1138 #endif
 1139 
 1140    /* If you want to shift the pixel values from the range [0,255] or
 1141     * [0,65535] to the original [0,7] or [0,31], or whatever range the
 1142     * colors were originally in:
 1143     */
 1144    if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
 1145 #ifdef PNG_READ_SHIFT_SUPPORTED
 1146       if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
 1147          png_set_shift(png_ptr, &info_ptr->sig_bit);
 1148 #else
 1149       png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
 1150 #endif
 1151 
 1152    /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
 1153    if ((transforms & PNG_TRANSFORM_BGR) != 0)
 1154 #ifdef PNG_READ_BGR_SUPPORTED
 1155       png_set_bgr(png_ptr);
 1156 #else
 1157       png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported");
 1158 #endif
 1159 
 1160    /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
 1161    if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
 1162 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
 1163       png_set_swap_alpha(png_ptr);
 1164 #else
 1165       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported");
 1166 #endif
 1167 
 1168    /* Swap bytes of 16-bit files to least significant byte first */
 1169    if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
 1170 #ifdef PNG_READ_SWAP_SUPPORTED
 1171       png_set_swap(png_ptr);
 1172 #else
 1173       png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported");
 1174 #endif
 1175 
 1176 /* Added at libpng-1.2.41 */
 1177    /* Invert the alpha channel from opacity to transparency */
 1178    if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
 1179 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 1180       png_set_invert_alpha(png_ptr);
 1181 #else
 1182       png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported");
 1183 #endif
 1184 
 1185 /* Added at libpng-1.2.41 */
 1186    /* Expand grayscale image to RGB */
 1187    if ((transforms & PNG_TRANSFORM_GRAY_TO_RGB) != 0)
 1188 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 1189       png_set_gray_to_rgb(png_ptr);
 1190 #else
 1191       png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported");
 1192 #endif
 1193 
 1194 /* Added at libpng-1.5.4 */
 1195    if ((transforms & PNG_TRANSFORM_EXPAND_16) != 0)
 1196 #ifdef PNG_READ_EXPAND_16_SUPPORTED
 1197       png_set_expand_16(png_ptr);
 1198 #else
 1199       png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported");
 1200 #endif
 1201 
 1202    /* We don't handle adding filler bytes */
 1203 
 1204    /* We use png_read_image and rely on that for interlace handling, but we also
 1205     * call png_read_update_info therefore must turn on interlace handling now:
 1206     */
 1207    (void)png_set_interlace_handling(png_ptr);
 1208 
 1209    /* Optional call to gamma correct and add the background to the palette
 1210     * and update info structure.  REQUIRED if you are expecting libpng to
 1211     * update the palette for you (i.e., you selected such a transform above).
 1212     */
 1213    png_read_update_info(png_ptr, info_ptr);
 1214 
 1215    /* -------------- image transformations end here ------------------- */
 1216 
 1217    png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
 1218    if (info_ptr->row_pointers == NULL)
 1219    {
 1220       png_uint_32 iptr;
 1221 
 1222       info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr,
 1223           info_ptr->height * (sizeof (png_bytep))));
 1224 
 1225       for (iptr=0; iptr<info_ptr->height; iptr++)
 1226          info_ptr->row_pointers[iptr] = NULL;
 1227 
 1228       info_ptr->free_me |= PNG_FREE_ROWS;
 1229 
 1230       for (iptr = 0; iptr < info_ptr->height; iptr++)
 1231          info_ptr->row_pointers[iptr] = png_voidcast(png_bytep,
 1232              png_malloc(png_ptr, info_ptr->rowbytes));
 1233    }
 1234 
 1235    png_read_image(png_ptr, info_ptr->row_pointers);
 1236    info_ptr->valid |= PNG_INFO_IDAT;
 1237 
 1238    /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
 1239    png_read_end(png_ptr, info_ptr);
 1240 
 1241    PNG_UNUSED(params)
 1242 }
 1243 #endif /* INFO_IMAGE */
 1244 #endif /* SEQUENTIAL_READ */
 1245 
 1246 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
 1247 /* SIMPLIFIED READ
 1248  *
 1249  * This code currently relies on the sequential reader, though it could easily
 1250  * be made to work with the progressive one.
 1251  */
 1252 /* Arguments to png_image_finish_read: */
 1253 
 1254 /* Encoding of PNG data (used by the color-map code) */
 1255 #  define P_NOTSET  0 /* File encoding not yet known */
 1256 #  define P_sRGB    1 /* 8-bit encoded to sRGB gamma */
 1257 #  define P_LINEAR  2 /* 16-bit linear: not encoded, NOT pre-multiplied! */
 1258 #  define P_FILE    3 /* 8-bit encoded to file gamma, not sRGB or linear */
 1259 #  define P_LINEAR8 4 /* 8-bit linear: only from a file value */
 1260 
 1261 /* Color-map processing: after libpng has run on the PNG image further
 1262  * processing may be needed to convert the data to color-map indices.
 1263  */
 1264 #define PNG_CMAP_NONE      0
 1265 #define PNG_CMAP_GA        1 /* Process GA data to a color-map with alpha */
 1266 #define PNG_CMAP_TRANS     2 /* Process GA data to a background index */
 1267 #define PNG_CMAP_RGB       3 /* Process RGB data */
 1268 #define PNG_CMAP_RGB_ALPHA 4 /* Process RGBA data */
 1269 
 1270 /* The following document where the background is for each processing case. */
 1271 #define PNG_CMAP_NONE_BACKGROUND      256
 1272 #define PNG_CMAP_GA_BACKGROUND        231
 1273 #define PNG_CMAP_TRANS_BACKGROUND     254
 1274 #define PNG_CMAP_RGB_BACKGROUND       256
 1275 #define PNG_CMAP_RGB_ALPHA_BACKGROUND 216
 1276 
 1277 typedef struct
 1278 {
 1279    /* Arguments: */
 1280    png_imagep image;
 1281    png_voidp  buffer;
 1282    png_int_32 row_stride;
 1283    png_voidp  colormap;
 1284    png_const_colorp background;
 1285    /* Local variables: */
 1286    png_voidp       local_row;
 1287    png_voidp       first_row;
 1288    ptrdiff_t       row_bytes;           /* step between rows */
 1289    int             file_encoding;       /* E_ values above */
 1290    png_fixed_point gamma_to_linear;     /* For P_FILE, reciprocal of gamma */
 1291    int             colormap_processing; /* PNG_CMAP_ values above */
 1292 } png_image_read_control;
 1293 
 1294 /* Do all the *safe* initialization - 'safe' means that png_error won't be
 1295  * called, so setting up the jmp_buf is not required.  This means that anything
 1296  * called from here must *not* call png_malloc - it has to call png_malloc_warn
 1297  * instead so that control is returned safely back to this routine.
 1298  */
 1299 static int
 1300 png_image_read_init(png_imagep image)
 1301 {
 1302    if (image->opaque == NULL)
 1303    {
 1304       png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image,
 1305           png_safe_error, png_safe_warning);
 1306 
 1307       /* And set the rest of the structure to NULL to ensure that the various
 1308        * fields are consistent.
 1309        */
 1310       memset(image, 0, (sizeof *image));
 1311       image->version = PNG_IMAGE_VERSION;
 1312 
 1313       if (png_ptr != NULL)
 1314       {
 1315          png_infop info_ptr = png_create_info_struct(png_ptr);
 1316 
 1317          if (info_ptr != NULL)
 1318          {
 1319             png_controlp control = png_voidcast(png_controlp,
 1320                 png_malloc_warn(png_ptr, (sizeof *control)));
 1321 
 1322             if (control != NULL)
 1323             {
 1324                memset(control, 0, (sizeof *control));
 1325 
 1326                control->png_ptr = png_ptr;
 1327                control->info_ptr = info_ptr;
 1328                control->for_write = 0;
 1329 
 1330                image->opaque = control;
 1331                return 1;
 1332             }
 1333 
 1334             /* Error clean up */
 1335             png_destroy_info_struct(png_ptr, &info_ptr);
 1336          }
 1337 
 1338          png_destroy_read_struct(&png_ptr, NULL, NULL);
 1339       }
 1340 
 1341       return png_image_error(image, "png_image_read: out of memory");
 1342    }
 1343 
 1344    return png_image_error(image, "png_image_read: opaque pointer not NULL");
 1345 }
 1346 
 1347 /* Utility to find the base format of a PNG file from a png_struct. */
 1348 static png_uint_32
 1349 png_image_format(png_structrp png_ptr)
 1350 {
 1351    png_uint_32 format = 0;
 1352 
 1353    if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
 1354       format |= PNG_FORMAT_FLAG_COLOR;
 1355 
 1356    if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
 1357       format |= PNG_FORMAT_FLAG_ALPHA;
 1358 
 1359    /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
 1360     * sets the png_struct fields; that's all we are interested in here.  The
 1361     * precise interaction with an app call to png_set_tRNS and PNG file reading
 1362     * is unclear.
 1363     */
 1364    else if (png_ptr->num_trans > 0)
 1365       format |= PNG_FORMAT_FLAG_ALPHA;
 1366 
 1367    if (png_ptr->bit_depth == 16)
 1368       format |= PNG_FORMAT_FLAG_LINEAR;
 1369 
 1370    if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0)
 1371       format |= PNG_FORMAT_FLAG_COLORMAP;
 1372 
 1373    return format;
 1374 }
 1375 
 1376 /* Is the given gamma significantly different from sRGB?  The test is the same
 1377  * one used in pngrtran.c when deciding whether to do gamma correction.  The
 1378  * arithmetic optimizes the division by using the fact that the inverse of the
 1379  * file sRGB gamma is 2.2
 1380  */
 1381 static int
 1382 png_gamma_not_sRGB(png_fixed_point g)
 1383 {
 1384    if (g < PNG_FP_1)
 1385    {
 1386       /* An uninitialized gamma is assumed to be sRGB for the simplified API. */
 1387       if (g == 0)
 1388          return 0;
 1389 
 1390       return png_gamma_significant((g * 11 + 2)/5 /* i.e. *2.2, rounded */);
 1391    }
 1392 
 1393    return 1;
 1394 }
 1395 
 1396 /* Do the main body of a 'png_image_begin_read' function; read the PNG file
 1397  * header and fill in all the information.  This is executed in a safe context,
 1398  * unlike the init routine above.
 1399  */
 1400 static int
 1401 png_image_read_header(png_voidp argument)
 1402 {
 1403    png_imagep image = png_voidcast(png_imagep, argument);
 1404    png_structrp png_ptr = image->opaque->png_ptr;
 1405    png_inforp info_ptr = image->opaque->info_ptr;
 1406 
 1407 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 1408    png_set_benign_errors(png_ptr, 1/*warn*/);
 1409 #endif
 1410    png_read_info(png_ptr, info_ptr);
 1411 
 1412    /* Do this the fast way; just read directly out of png_struct. */
 1413    image->width = png_ptr->width;
 1414    image->height = png_ptr->height;
 1415 
 1416    {
 1417       png_uint_32 format = png_image_format(png_ptr);
 1418 
 1419       image->format = format;
 1420 
 1421 #ifdef PNG_COLORSPACE_SUPPORTED
 1422       /* Does the colorspace match sRGB?  If there is no color endpoint
 1423        * (colorant) information assume yes, otherwise require the
 1424        * 'ENDPOINTS_MATCHP_sRGB' colorspace flag to have been set.  If the
 1425        * colorspace has been determined to be invalid ignore it.
 1426        */
 1427       if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags
 1428          & (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB|
 1429             PNG_COLORSPACE_INVALID)) == PNG_COLORSPACE_HAVE_ENDPOINTS))
 1430          image->flags |= PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB;
 1431 #endif
 1432    }
 1433 
 1434    /* We need the maximum number of entries regardless of the format the
 1435     * application sets here.
 1436     */
 1437    {
 1438       png_uint_32 cmap_entries;
 1439 
 1440       switch (png_ptr->color_type)
 1441       {
 1442          case PNG_COLOR_TYPE_GRAY:
 1443             cmap_entries = 1U << png_ptr->bit_depth;
 1444             break;
 1445 
 1446          case PNG_COLOR_TYPE_PALETTE:
 1447             cmap_entries = (png_uint_32)png_ptr->num_palette;
 1448             break;
 1449 
 1450          default:
 1451             cmap_entries = 256;
 1452             break;
 1453       }
 1454 
 1455       if (cmap_entries > 256)
 1456          cmap_entries = 256;
 1457 
 1458       image->colormap_entries = cmap_entries;
 1459    }
 1460 
 1461    return 1;
 1462 }
 1463 
 1464 #ifdef PNG_STDIO_SUPPORTED
 1465 int PNGAPI
 1466 png_image_begin_read_from_stdio(png_imagep image, FILE* file)
 1467 {
 1468    if (image != NULL && image->version == PNG_IMAGE_VERSION)
 1469    {
 1470       if (file != NULL)
 1471       {
 1472          if (png_image_read_init(image) != 0)
 1473          {
 1474             /* This is slightly evil, but png_init_io doesn't do anything other
 1475              * than this and we haven't changed the standard IO functions so
 1476              * this saves a 'safe' function.
 1477              */
 1478             image->opaque->png_ptr->io_ptr = file;
 1479             return png_safe_execute(image, png_image_read_header, image);
 1480          }
 1481       }
 1482 
 1483       else
 1484          return png_image_error(image,
 1485              "png_image_begin_read_from_stdio: invalid argument");
 1486    }
 1487 
 1488    else if (image != NULL)
 1489       return png_image_error(image,
 1490           "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION");
 1491 
 1492    return 0;
 1493 }
 1494 
 1495 int PNGAPI
 1496 png_image_begin_read_from_file(png_imagep image, const char *file_name)
 1497 {
 1498    if (image != NULL && image->version == PNG_IMAGE_VERSION)
 1499    {
 1500       if (file_name != NULL)
 1501       {
 1502          FILE *fp = fopen(file_name, "rb");
 1503 
 1504          if (fp != NULL)
 1505          {
 1506             if (png_image_read_init(image) != 0)
 1507             {
 1508                image->opaque->png_ptr->io_ptr = fp;
 1509                image->opaque->owned_file = 1;
 1510                return png_safe_execute(image, png_image_read_header, image);
 1511             }
 1512 
 1513             /* Clean up: just the opened file. */
 1514             (void)fclose(fp);
 1515          }
 1516 
 1517          else
 1518             return png_image_error(image, strerror(errno));
 1519       }
 1520 
 1521       else
 1522          return png_image_error(image,
 1523              "png_image_begin_read_from_file: invalid argument");
 1524    }
 1525 
 1526    else if (image != NULL)
 1527       return png_image_error(image,
 1528           "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION");
 1529 
 1530    return 0;
 1531 }
 1532 #endif /* STDIO */
 1533 
 1534 static void PNGCBAPI
 1535 png_image_memory_read(png_structp png_ptr, png_bytep out, size_t need)
 1536 {
 1537    if (png_ptr != NULL)
 1538    {
 1539       png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
 1540       if (image != NULL)
 1541       {
 1542          png_controlp cp = image->opaque;
 1543          if (cp != NULL)
 1544          {
 1545             png_const_bytep memory = cp->memory;
 1546             size_t size = cp->size;
 1547 
 1548             if (memory != NULL && size >= need)
 1549             {
 1550                memcpy(out, memory, need);
 1551                cp->memory = memory + need;
 1552                cp->size = size - need;
 1553                return;
 1554             }
 1555 
 1556             png_error(png_ptr, "read beyond end of data");
 1557          }
 1558       }
 1559 
 1560       png_error(png_ptr, "invalid memory read");
 1561    }
 1562 }
 1563 
 1564 int PNGAPI png_image_begin_read_from_memory(png_imagep image,
 1565     png_const_voidp memory, size_t size)
 1566 {
 1567    if (image != NULL && image->version == PNG_IMAGE_VERSION)
 1568    {
 1569       if (memory != NULL && size > 0)
 1570       {
 1571          if (png_image_read_init(image) != 0)
 1572          {
 1573             /* Now set the IO functions to read from the memory buffer and
 1574              * store it into io_ptr.  Again do this in-place to avoid calling a
 1575              * libpng function that requires error handling.
 1576              */
 1577             image->opaque->memory = png_voidcast(png_const_bytep, memory);
 1578             image->opaque->size = size;
 1579             image->opaque->png_ptr->io_ptr = image;
 1580             image->opaque->png_ptr->read_data_fn = png_image_memory_read;
 1581 
 1582             return png_safe_execute(image, png_image_read_header, image);
 1583          }
 1584       }
 1585 
 1586       else
 1587          return png_image_error(image,
 1588              "png_image_begin_read_from_memory: invalid argument");
 1589    }
 1590 
 1591    else if (image != NULL)
 1592       return png_image_error(image,
 1593           "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION");
 1594 
 1595    return 0;
 1596 }
 1597 
 1598 /* Utility function to skip chunks that are not used by the simplified image
 1599  * read functions and an appropriate macro to call it.
 1600  */
 1601 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 1602 static void
 1603 png_image_skip_unused_chunks(png_structrp png_ptr)
 1604 {
 1605    /* Prepare the reader to ignore all recognized chunks whose data will not
 1606     * be used, i.e., all chunks recognized by libpng except for those
 1607     * involved in basic image reading:
 1608     *
 1609     *    IHDR, PLTE, IDAT, IEND
 1610     *
 1611     * Or image data handling:
 1612     *
 1613     *    tRNS, bKGD, gAMA, cHRM, sRGB, [iCCP] and sBIT.
 1614     *
 1615     * This provides a small performance improvement and eliminates any
 1616     * potential vulnerability to security problems in the unused chunks.
 1617     *
 1618     * At present the iCCP chunk data isn't used, so iCCP chunk can be ignored
 1619     * too.  This allows the simplified API to be compiled without iCCP support,
 1620     * however if the support is there the chunk is still checked to detect
 1621     * errors (which are unfortunately quite common.)
 1622     */
 1623    {
 1624          static const png_byte chunks_to_process[] = {
 1625             98,  75,  71,  68, '\0',  /* bKGD */
 1626             99,  72,  82,  77, '\0',  /* cHRM */
 1627            103,  65,  77,  65, '\0',  /* gAMA */
 1628 #        ifdef PNG_READ_iCCP_SUPPORTED
 1629            105,  67,  67,  80, '\0',  /* iCCP */
 1630 #        endif
 1631            115,  66,  73,  84, '\0',  /* sBIT */
 1632            115,  82,  71,  66, '\0',  /* sRGB */
 1633            };
 1634 
 1635        /* Ignore unknown chunks and all other chunks except for the
 1636         * IHDR, PLTE, tRNS, IDAT, and IEND chunks.
 1637         */
 1638        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
 1639            NULL, -1);
 1640 
 1641        /* But do not ignore image data handling chunks */
 1642        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
 1643            chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5);
 1644    }
 1645 }
 1646 
 1647 #  define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p)
 1648 #else
 1649 #  define PNG_SKIP_CHUNKS(p) ((void)0)
 1650 #endif /* HANDLE_AS_UNKNOWN */
 1651 
 1652 /* The following macro gives the exact rounded answer for all values in the
 1653  * range 0..255 (it actually divides by 51.2, but the rounding still generates
 1654  * the correct numbers 0..5
 1655  */
 1656 #define PNG_DIV51(v8) (((v8) * 5 + 130) >> 8)
 1657 
 1658 /* Utility functions to make particular color-maps */
 1659 static void
 1660 set_file_encoding(png_image_read_control *display)
 1661 {
 1662    png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
 1663    if (png_gamma_significant(g) != 0)
 1664    {
 1665       if (png_gamma_not_sRGB(g) != 0)
 1666       {
 1667          display->file_encoding = P_FILE;
 1668          display->gamma_to_linear = png_reciprocal(g);
 1669       }
 1670 
 1671       else
 1672          display->file_encoding = P_sRGB;
 1673    }
 1674 
 1675    else
 1676       display->file_encoding = P_LINEAR8;
 1677 }
 1678 
 1679 static unsigned int
 1680 decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
 1681 {
 1682    if (encoding == P_FILE) /* double check */
 1683       encoding = display->file_encoding;
 1684 
 1685    if (encoding == P_NOTSET) /* must be the file encoding */
 1686    {
 1687       set_file_encoding(display);
 1688       encoding = display->file_encoding;
 1689    }
 1690 
 1691    switch (encoding)
 1692    {
 1693       case P_FILE:
 1694          value = png_gamma_16bit_correct(value*257, display->gamma_to_linear);
 1695          break;
 1696 
 1697       case P_sRGB:
 1698          value = png_sRGB_table[value];
 1699          break;
 1700 
 1701       case P_LINEAR:
 1702          break;
 1703 
 1704       case P_LINEAR8:
 1705          value *= 257;
 1706          break;
 1707 
 1708 #ifdef __GNUC__
 1709       default:
 1710          png_error(display->image->opaque->png_ptr,
 1711              "unexpected encoding (internal error)");
 1712 #endif
 1713    }
 1714 
 1715    return value;
 1716 }
 1717 
 1718 static png_uint_32
 1719 png_colormap_compose(png_image_read_control *display,
 1720     png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha,
 1721     png_uint_32 background, int encoding)
 1722 {
 1723    /* The file value is composed on the background, the background has the given
 1724     * encoding and so does the result, the file is encoded with P_FILE and the
 1725     * file and alpha are 8-bit values.  The (output) encoding will always be
 1726     * P_LINEAR or P_sRGB.
 1727     */
 1728    png_uint_32 f = decode_gamma(display, foreground, foreground_encoding);
 1729    png_uint_32 b = decode_gamma(display, background, encoding);
 1730 
 1731    /* The alpha is always an 8-bit value (it comes from the palette), the value
 1732     * scaled by 255 is what PNG_sRGB_FROM_LINEAR requires.
 1733     */
 1734    f = f * alpha + b * (255-alpha);
 1735 
 1736    if (encoding == P_LINEAR)
 1737    {
 1738       /* Scale to 65535; divide by 255, approximately (in fact this is extremely
 1739        * accurate, it divides by 255.00000005937181414556, with no overflow.)
 1740        */
 1741       f *= 257; /* Now scaled by 65535 */
 1742       f += f >> 16;
 1743       f = (f+32768) >> 16;
 1744    }
 1745 
 1746    else /* P_sRGB */
 1747       f = PNG_sRGB_FROM_LINEAR(f);
 1748 
 1749    return f;
 1750 }
 1751 
 1752 /* NOTE: P_LINEAR values to this routine must be 16-bit, but P_FILE values must
 1753  * be 8-bit.
 1754  */
 1755 static void
 1756 png_create_colormap_entry(png_image_read_control *display,
 1757     png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue,
 1758     png_uint_32 alpha, int encoding)
 1759 {
 1760    png_imagep image = display->image;
 1761    int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
 1762        P_LINEAR : P_sRGB;
 1763    int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
 1764        (red != green || green != blue);
 1765 
 1766    if (ip > 255)
 1767       png_error(image->opaque->png_ptr, "color-map index out of range");
 1768 
 1769    /* Update the cache with whether the file gamma is significantly different
 1770     * from sRGB.
 1771     */
 1772    if (encoding == P_FILE)
 1773    {
 1774       if (display->file_encoding == P_NOTSET)
 1775          set_file_encoding(display);
 1776 
 1777       /* Note that the cached value may be P_FILE too, but if it is then the
 1778        * gamma_to_linear member has been set.
 1779        */
 1780       encoding = display->file_encoding;
 1781    }
 1782 
 1783    if (encoding == P_FILE)
 1784    {
 1785       png_fixed_point g = display->gamma_to_linear;
 1786 
 1787       red = png_gamma_16bit_correct(red*257, g);
 1788       green = png_gamma_16bit_correct(green*257, g);
 1789       blue = png_gamma_16bit_correct(blue*257, g);
 1790 
 1791       if (convert_to_Y != 0 || output_encoding == P_LINEAR)
 1792       {
 1793          alpha *= 257;
 1794          encoding = P_LINEAR;
 1795       }
 1796 
 1797       else
 1798       {
 1799          red = PNG_sRGB_FROM_LINEAR(red * 255);
 1800          green = PNG_sRGB_FROM_LINEAR(green * 255);
 1801          blue = PNG_sRGB_FROM_LINEAR(blue * 255);
 1802          encoding = P_sRGB;
 1803       }
 1804    }
 1805 
 1806    else if (encoding == P_LINEAR8)
 1807    {
 1808       /* This encoding occurs quite frequently in test cases because PngSuite
 1809        * includes a gAMA 1.0 chunk with most images.
 1810        */
 1811       red *= 257;
 1812       green *= 257;
 1813       blue *= 257;
 1814       alpha *= 257;
 1815       encoding = P_LINEAR;
 1816    }
 1817 
 1818    else if (encoding == P_sRGB &&
 1819        (convert_to_Y  != 0 || output_encoding == P_LINEAR))
 1820    {
 1821       /* The values are 8-bit sRGB values, but must be converted to 16-bit
 1822        * linear.
 1823        */
 1824       red = png_sRGB_table[red];
 1825       green = png_sRGB_table[green];
 1826       blue = png_sRGB_table[blue];
 1827       alpha *= 257;
 1828       encoding = P_LINEAR;
 1829    }
 1830 
 1831    /* This is set if the color isn't gray but the output is. */
 1832    if (encoding == P_LINEAR)
 1833    {
 1834       if (convert_to_Y != 0)
 1835       {
 1836          /* NOTE: these values are copied from png_do_rgb_to_gray */
 1837          png_uint_32 y = (png_uint_32)6968 * red  + (png_uint_32)23434 * green +
 1838             (png_uint_32)2366 * blue;
 1839 
 1840          if (output_encoding == P_LINEAR)
 1841             y = (y + 16384) >> 15;
 1842 
 1843          else
 1844          {
 1845             /* y is scaled by 32768, we need it scaled by 255: */
 1846             y = (y + 128) >> 8;
 1847             y *= 255;
 1848             y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7);
 1849             alpha = PNG_DIV257(alpha);
 1850             encoding = P_sRGB;
 1851          }
 1852 
 1853          blue = red = green = y;
 1854       }
 1855 
 1856       else if (output_encoding == P_sRGB)
 1857       {
 1858          red = PNG_sRGB_FROM_LINEAR(red * 255);
 1859          green = PNG_sRGB_FROM_LINEAR(green * 255);
 1860          blue = PNG_sRGB_FROM_LINEAR(blue * 255);
 1861          alpha = PNG_DIV257(alpha);
 1862          encoding = P_sRGB;
 1863       }
 1864    }
 1865 
 1866    if (encoding != output_encoding)
 1867       png_error(image->opaque->png_ptr, "bad encoding (internal error)");
 1868 
 1869    /* Store the value. */
 1870    {
 1871 #     ifdef PNG_FORMAT_AFIRST_SUPPORTED
 1872          int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
 1873             (image->format & PNG_FORMAT_FLAG_ALPHA) != 0;
 1874 #     else
 1875 #        define afirst 0
 1876 #     endif
 1877 #     ifdef PNG_FORMAT_BGR_SUPPORTED
 1878          int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
 1879 #     else
 1880 #        define bgr 0
 1881 #     endif
 1882 
 1883       if (output_encoding == P_LINEAR)
 1884       {
 1885          png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap);
 1886 
 1887          entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);
 1888 
 1889          /* The linear 16-bit values must be pre-multiplied by the alpha channel
 1890           * value, if less than 65535 (this is, effectively, composite on black
 1891           * if the alpha channel is removed.)
 1892           */
 1893          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
 1894          {
 1895             case 4:
 1896                entry[afirst ? 0 : 3] = (png_uint_16)alpha;
 1897                /* FALLTHROUGH */
 1898 
 1899             case 3:
 1900                if (alpha < 65535)
 1901                {
 1902                   if (alpha > 0)
 1903                   {
 1904                      blue = (blue * alpha + 32767U)/65535U;
 1905                      green = (green * alpha + 32767U)/65535U;
 1906                      red = (red * alpha + 32767U)/65535U;
 1907                   }
 1908 
 1909                   else
 1910                      red = green = blue = 0;
 1911                }
 1912                entry[afirst + (2 ^ bgr)] = (png_uint_16)blue;
 1913                entry[afirst + 1] = (png_uint_16)green;
 1914                entry[afirst + bgr] = (png_uint_16)red;
 1915                break;
 1916 
 1917             case 2:
 1918                entry[1 ^ afirst] = (png_uint_16)alpha;
 1919                /* FALLTHROUGH */
 1920 
 1921             case 1:
 1922                if (alpha < 65535)
 1923                {
 1924                   if (alpha > 0)
 1925                      green = (green * alpha + 32767U)/65535U;
 1926 
 1927                   else
 1928                      green = 0;
 1929                }
 1930                entry[afirst] = (png_uint_16)green;
 1931                break;
 1932 
 1933             default:
 1934                break;
 1935          }
 1936       }
 1937 
 1938       else /* output encoding is P_sRGB */
 1939       {
 1940          png_bytep entry = png_voidcast(png_bytep, display->colormap);
 1941 
 1942          entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);
 1943 
 1944          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
 1945          {
 1946             case 4:
 1947                entry[afirst ? 0 : 3] = (png_byte)alpha;
 1948                /* FALLTHROUGH */
 1949             case 3:
 1950                entry[afirst + (2 ^ bgr)] = (png_byte)blue;
 1951                entry[afirst + 1] = (png_byte)green;
 1952                entry[afirst + bgr] = (png_byte)red;
 1953                break;
 1954 
 1955             case 2:
 1956                entry[1 ^ afirst] = (png_byte)alpha;
 1957                /* FALLTHROUGH */
 1958             case 1:
 1959                entry[afirst] = (png_byte)green;
 1960                break;
 1961 
 1962             default:
 1963                break;
 1964          }
 1965       }
 1966 
 1967 #     ifdef afirst
 1968 #        undef afirst
 1969 #     endif
 1970 #     ifdef bgr
 1971 #        undef bgr
 1972 #     endif
 1973    }
 1974 }
 1975 
 1976 static int
 1977 make_gray_file_colormap(png_image_read_control *display)
 1978 {
 1979    unsigned int i;
 1980 
 1981    for (i=0; i<256; ++i)
 1982       png_create_colormap_entry(display, i, i, i, i, 255, P_FILE);
 1983 
 1984    return (int)i;
 1985 }
 1986 
 1987 static int
 1988 make_gray_colormap(png_image_read_control *display)
 1989 {
 1990    unsigned int i;
 1991 
 1992    for (i=0; i<256; ++i)
 1993       png_create_colormap_entry(display, i, i, i, i, 255, P_sRGB);
 1994 
 1995    return (int)i;
 1996 }
 1997 #define PNG_GRAY_COLORMAP_ENTRIES 256
 1998 
 1999 static int
 2000 make_ga_colormap(png_image_read_control *display)
 2001 {
 2002    unsigned int i, a;
 2003 
 2004    /* Alpha is retained, the output will be a color-map with entries
 2005     * selected by six levels of alpha.  One transparent entry, 6 gray
 2006     * levels for all the intermediate alpha values, leaving 230 entries
 2007     * for the opaque grays.  The color-map entries are the six values
 2008     * [0..5]*51, the GA processing uses PNG_DIV51(value) to find the
 2009     * relevant entry.
 2010     *
 2011     * if (alpha > 229) // opaque
 2012     * {
 2013     *    // The 231 entries are selected to make the math below work:
 2014     *    base = 0;
 2015     *    entry = (231 * gray + 128) >> 8;
 2016     * }
 2017     * else if (alpha < 26) // transparent
 2018     * {
 2019     *    base = 231;
 2020     *    entry = 0;
 2021     * }
 2022     * else // partially opaque
 2023     * {
 2024     *    base = 226 + 6 * PNG_DIV51(alpha);
 2025     *    entry = PNG_DIV51(gray);
 2026     * }
 2027     */
 2028    i = 0;
 2029    while (i < 231)
 2030    {
 2031       unsigned int gray = (i * 256 + 115) / 231;
 2032       png_create_colormap_entry(display, i++, gray, gray, gray, 255, P_sRGB);
 2033    }
 2034 
 2035    /* 255 is used here for the component values for consistency with the code
 2036     * that undoes premultiplication in pngwrite.c.
 2037     */
 2038    png_create_colormap_entry(display, i++, 255, 255, 255, 0, P_sRGB);
 2039 
 2040    for (a=1; a<5; ++a)
 2041    {
 2042       unsigned int g;
 2043 
 2044       for (g=0; g<6; ++g)
 2045          png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51,
 2046              P_sRGB);
 2047    }
 2048 
 2049    return (int)i;
 2050 }
 2051 
 2052 #define PNG_GA_COLORMAP_ENTRIES 256
 2053 
 2054 static int
 2055 make_rgb_colormap(png_image_read_control *display)
 2056 {
 2057    unsigned int i, r;
 2058 
 2059    /* Build a 6x6x6 opaque RGB cube */
 2060    for (i=r=0; r<6; ++r)
 2061    {
 2062       unsigned int g;
 2063 
 2064       for (g=0; g<6; ++g)
 2065       {
 2066          unsigned int b;
 2067 
 2068          for (b=0; b<6; ++b)
 2069             png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255,
 2070                 P_sRGB);
 2071       }
 2072    }
 2073 
 2074    return (int)i;
 2075 }
 2076 
 2077 #define PNG_RGB_COLORMAP_ENTRIES 216
 2078 
 2079 /* Return a palette index to the above palette given three 8-bit sRGB values. */
 2080 #define PNG_RGB_INDEX(r,g,b) \
 2081    ((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b)))
 2082 
 2083 static int
 2084 png_image_read_colormap(png_voidp argument)
 2085 {
 2086    png_image_read_control *display =
 2087       png_voidcast(png_image_read_control*, argument);
 2088    png_imagep image = display->image;
 2089 
 2090    png_structrp png_ptr = image->opaque->png_ptr;
 2091    png_uint_32 output_format = image->format;
 2092    int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
 2093       P_LINEAR : P_sRGB;
 2094 
 2095    unsigned int cmap_entries;
 2096    unsigned int output_processing;        /* Output processing option */
 2097    unsigned int data_encoding = P_NOTSET; /* Encoding libpng must produce */
 2098 
 2099    /* Background information; the background color and the index of this color
 2100     * in the color-map if it exists (else 256).
 2101     */
 2102    unsigned int background_index = 256;
 2103    png_uint_32 back_r, back_g, back_b;
 2104 
 2105    /* Flags to accumulate things that need to be done to the input. */
 2106    int expand_tRNS = 0;
 2107 
 2108    /* Exclude the NYI feature of compositing onto a color-mapped buffer; it is
 2109     * very difficult to do, the results look awful, and it is difficult to see
 2110     * what possible use it is because the application can't control the
 2111     * color-map.
 2112     */
 2113    if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 ||
 2114          png_ptr->num_trans > 0) /* alpha in input */ &&
 2115       ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */)
 2116    {
 2117       if (output_encoding == P_LINEAR) /* compose on black */
 2118          back_b = back_g = back_r = 0;
 2119 
 2120       else if (display->background == NULL /* no way to remove it */)
 2121          png_error(png_ptr,
 2122              "background color must be supplied to remove alpha/transparency");
 2123 
 2124       /* Get a copy of the background color (this avoids repeating the checks
 2125        * below.)  The encoding is 8-bit sRGB or 16-bit linear, depending on the
 2126        * output format.
 2127        */
 2128       else
 2129       {
 2130          back_g = display->background->green;
 2131          if ((output_format & PNG_FORMAT_FLAG_COLOR) != 0)
 2132          {
 2133             back_r = display->background->red;
 2134             back_b = display->background->blue;
 2135          }
 2136          else
 2137             back_b = back_r = back_g;
 2138       }
 2139    }
 2140 
 2141    else if (output_encoding == P_LINEAR)
 2142       back_b = back_r = back_g = 65535;
 2143 
 2144    else
 2145       back_b = back_r = back_g = 255;
 2146 
 2147    /* Default the input file gamma if required - this is necessary because
 2148     * libpng assumes that if no gamma information is present the data is in the
 2149     * output format, but the simplified API deduces the gamma from the input
 2150     * format.
 2151     */
 2152    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0)
 2153    {
 2154       /* Do this directly, not using the png_colorspace functions, to ensure
 2155        * that it happens even if the colorspace is invalid (though probably if
 2156        * it is the setting will be ignored)  Note that the same thing can be
 2157        * achieved at the application interface with png_set_gAMA.
 2158        */
 2159       if (png_ptr->bit_depth == 16 &&
 2160          (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)
 2161          png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR;
 2162 
 2163       else
 2164          png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE;
 2165 
 2166       png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
 2167    }
 2168 
 2169    /* Decide what to do based on the PNG color type of the input data.  The
 2170     * utility function png_create_colormap_entry deals with most aspects of the
 2171     * output transformations; this code works out how to produce bytes of
 2172     * color-map entries from the original format.
 2173     */
 2174    switch (png_ptr->color_type)
 2175    {
 2176       case PNG_COLOR_TYPE_GRAY:
 2177          if (png_ptr->bit_depth <= 8)
 2178          {
 2179             /* There at most 256 colors in the output, regardless of
 2180              * transparency.
 2181              */
 2182             unsigned int step, i, val, trans = 256/*ignore*/, back_alpha = 0;
 2183 
 2184             cmap_entries = 1U << png_ptr->bit_depth;
 2185             if (cmap_entries > image->colormap_entries)
 2186                png_error(png_ptr, "gray[8] color-map: too few entries");
 2187 
 2188             step = 255 / (cmap_entries - 1);
 2189             output_processing = PNG_CMAP_NONE;
 2190 
 2191             /* If there is a tRNS chunk then this either selects a transparent
 2192              * value or, if the output has no alpha, the background color.
 2193              */
 2194             if (png_ptr->num_trans > 0)
 2195             {
 2196                trans = png_ptr->trans_color.gray;
 2197 
 2198                if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0)
 2199                   back_alpha = output_encoding == P_LINEAR ? 65535 : 255;
 2200             }
 2201 
 2202             /* png_create_colormap_entry just takes an RGBA and writes the
 2203              * corresponding color-map entry using the format from 'image',
 2204              * including the required conversion to sRGB or linear as
 2205              * appropriate.  The input values are always either sRGB (if the
 2206              * gamma correction flag is 0) or 0..255 scaled file encoded values
 2207              * (if the function must gamma correct them).
 2208              */
 2209             for (i=val=0; i<cmap_entries; ++i, val += step)
 2210             {
 2211                /* 'i' is a file value.  While this will result in duplicated
 2212                 * entries for 8-bit non-sRGB encoded files it is necessary to
 2213                 * have non-gamma corrected values to do tRNS handling.
 2214                 */
 2215                if (i != trans)
 2216                   png_create_colormap_entry(display, i, val, val, val, 255,
 2217                       P_FILE/*8-bit with file gamma*/);
 2218 
 2219                /* Else this entry is transparent.  The colors don't matter if
 2220                 * there is an alpha channel (back_alpha == 0), but it does no
 2221                 * harm to pass them in; the values are not set above so this
 2222                 * passes in white.
 2223                 *
 2224                 * NOTE: this preserves the full precision of the application
 2225                 * supplied background color when it is used.
 2226                 */
 2227                else
 2228                   png_create_colormap_entry(display, i, back_r, back_g, back_b,
 2229                       back_alpha, output_encoding);
 2230             }
 2231 
 2232             /* We need libpng to preserve the original encoding. */
 2233             data_encoding = P_FILE;
 2234 
 2235             /* The rows from libpng, while technically gray values, are now also
 2236              * color-map indices; however, they may need to be expanded to 1
 2237              * byte per pixel.  This is what png_set_packing does (i.e., it
 2238              * unpacks the bit values into bytes.)
 2239              */
 2240             if (png_ptr->bit_depth < 8)
 2241                png_set_packing(png_ptr);
 2242          }
 2243 
 2244          else /* bit depth is 16 */
 2245          {
 2246             /* The 16-bit input values can be converted directly to 8-bit gamma
 2247              * encoded values; however, if a tRNS chunk is present 257 color-map
 2248              * entries are required.  This means that the extra entry requires
 2249              * special processing; add an alpha channel, sacrifice gray level
 2250              * 254 and convert transparent (alpha==0) entries to that.
 2251              *
 2252              * Use libpng to chop the data to 8 bits.  Convert it to sRGB at the
 2253              * same time to minimize quality loss.  If a tRNS chunk is present
 2254              * this means libpng must handle it too; otherwise it is impossible
 2255              * to do the exact match on the 16-bit value.
 2256              *
 2257              * If the output has no alpha channel *and* the background color is
 2258              * gray then it is possible to let libpng handle the substitution by
 2259              * ensuring that the corresponding gray level matches the background
 2260              * color exactly.
 2261              */
 2262             data_encoding = P_sRGB;
 2263 
 2264             if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
 2265                png_error(png_ptr, "gray[16] color-map: too few entries");
 2266 
 2267             cmap_entries = (unsigned int)make_gray_colormap(display);
 2268 
 2269             if (png_ptr->num_trans > 0)
 2270             {
 2271                unsigned int back_alpha;
 2272 
 2273                if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 2274                   back_alpha = 0;
 2275 
 2276                else
 2277                {
 2278                   if (back_r == back_g && back_g == back_b)
 2279                   {
 2280                      /* Background is gray; no special processing will be
 2281                       * required.
 2282                       */
 2283                      png_color_16 c;
 2284                      png_uint_32 gray = back_g;
 2285 
 2286                      if (output_encoding == P_LINEAR)
 2287                      {
 2288                         gray = PNG_sRGB_FROM_LINEAR(gray * 255);
 2289 
 2290                         /* And make sure the corresponding palette entry
 2291                          * matches.
 2292                          */
 2293                         png_create_colormap_entry(display, gray, back_g, back_g,
 2294                             back_g, 65535, P_LINEAR);
 2295                      }
 2296 
 2297                      /* The background passed to libpng, however, must be the
 2298                       * sRGB value.
 2299                       */
 2300                      c.index = 0; /*unused*/
 2301                      c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
 2302 
 2303                      /* NOTE: does this work without expanding tRNS to alpha?
 2304                       * It should be the color->gray case below apparently
 2305                       * doesn't.
 2306                       */
 2307                      png_set_background_fixed(png_ptr, &c,
 2308                          PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
 2309                          0/*gamma: not used*/);
 2310 
 2311                      output_processing = PNG_CMAP_NONE;
 2312                      break;
 2313                   }
 2314 #ifdef __COVERITY__
 2315                  /* Coverity claims that output_encoding cannot be 2 (P_LINEAR)
 2316                   * here.
 2317                   */
 2318                   back_alpha = 255;
 2319 #else
 2320                   back_alpha = output_encoding == P_LINEAR ? 65535 : 255;
 2321 #endif
 2322                }
 2323 
 2324                /* output_processing means that the libpng-processed row will be
 2325                 * 8-bit GA and it has to be processing to single byte color-map
 2326                 * values.  Entry 254 is replaced by either a completely
 2327                 * transparent entry or by the background color at full
 2328                 * precision (and the background color is not a simple gray
 2329                 * level in this case.)
 2330                 */
 2331                expand_tRNS = 1;
 2332                output_processing = PNG_CMAP_TRANS;
 2333                background_index = 254;
 2334 
 2335                /* And set (overwrite) color-map entry 254 to the actual
 2336                 * background color at full precision.
 2337                 */
 2338                png_create_colormap_entry(display, 254, back_r, back_g, back_b,
 2339                    back_alpha, output_encoding);
 2340             }
 2341 
 2342             else
 2343                output_processing = PNG_CMAP_NONE;
 2344          }
 2345          break;
 2346 
 2347       case PNG_COLOR_TYPE_GRAY_ALPHA:
 2348          /* 8-bit or 16-bit PNG with two channels - gray and alpha.  A minimum
 2349           * of 65536 combinations.  If, however, the alpha channel is to be
 2350           * removed there are only 256 possibilities if the background is gray.
 2351           * (Otherwise there is a subset of the 65536 possibilities defined by
 2352           * the triangle between black, white and the background color.)
 2353           *
 2354           * Reduce 16-bit files to 8-bit and sRGB encode the result.  No need to
 2355           * worry about tRNS matching - tRNS is ignored if there is an alpha
 2356           * channel.
 2357           */
 2358          data_encoding = P_sRGB;
 2359 
 2360          if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 2361          {
 2362             if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
 2363                png_error(png_ptr, "gray+alpha color-map: too few entries");
 2364 
 2365             cmap_entries = (unsigned int)make_ga_colormap(display);
 2366 
 2367             background_index = PNG_CMAP_GA_BACKGROUND;
 2368             output_processing = PNG_CMAP_GA;
 2369          }
 2370 
 2371          else /* alpha is removed */
 2372          {
 2373             /* Alpha must be removed as the PNG data is processed when the
 2374              * background is a color because the G and A channels are
 2375              * independent and the vector addition (non-parallel vectors) is a
 2376              * 2-D problem.
 2377              *
 2378              * This can be reduced to the same algorithm as above by making a
 2379              * colormap containing gray levels (for the opaque grays), a
 2380              * background entry (for a transparent pixel) and a set of four six
 2381              * level color values, one set for each intermediate alpha value.
 2382              * See the comments in make_ga_colormap for how this works in the
 2383              * per-pixel processing.
 2384              *
 2385              * If the background is gray, however, we only need a 256 entry gray
 2386              * level color map.  It is sufficient to make the entry generated
 2387              * for the background color be exactly the color specified.
 2388              */
 2389             if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0 ||
 2390                (back_r == back_g && back_g == back_b))
 2391             {
 2392                /* Background is gray; no special processing will be required. */
 2393                png_color_16 c;
 2394                png_uint_32 gray = back_g;
 2395 
 2396                if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
 2397                   png_error(png_ptr, "gray-alpha color-map: too few entries");
 2398 
 2399                cmap_entries = (unsigned int)make_gray_colormap(display);
 2400 
 2401                if (output_encoding == P_LINEAR)
 2402                {
 2403                   gray = PNG_sRGB_FROM_LINEAR(gray * 255);
 2404 
 2405                   /* And make sure the corresponding palette entry matches. */
 2406                   png_create_colormap_entry(display, gray, back_g, back_g,
 2407                       back_g, 65535, P_LINEAR);
 2408                }
 2409 
 2410                /* The background passed to libpng, however, must be the sRGB
 2411                 * value.
 2412                 */
 2413                c.index = 0; /*unused*/
 2414                c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
 2415 
 2416                png_set_background_fixed(png_ptr, &c,
 2417                    PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
 2418                    0/*gamma: not used*/);
 2419 
 2420                output_processing = PNG_CMAP_NONE;
 2421             }
 2422 
 2423             else
 2424             {
 2425                png_uint_32 i, a;
 2426 
 2427                /* This is the same as png_make_ga_colormap, above, except that
 2428                 * the entries are all opaque.
 2429                 */
 2430                if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
 2431                   png_error(png_ptr, "ga-alpha color-map: too few entries");
 2432 
 2433                i = 0;
 2434                while (i < 231)
 2435                {
 2436                   png_uint_32 gray = (i * 256 + 115) / 231;
 2437                   png_create_colormap_entry(display, i++, gray, gray, gray,
 2438                       255, P_sRGB);
 2439                }
 2440 
 2441                /* NOTE: this preserves the full precision of the application
 2442                 * background color.
 2443                 */
 2444                background_index = i;
 2445                png_create_colormap_entry(display, i++, back_r, back_g, back_b,
 2446 #ifdef __COVERITY__
 2447                    /* Coverity claims that output_encoding
 2448                     * cannot be 2 (P_LINEAR) here.
 2449                     */ 255U,
 2450 #else
 2451                     output_encoding == P_LINEAR ? 65535U : 255U,
 2452 #endif
 2453                     output_encoding);
 2454 
 2455                /* For non-opaque input composite on the sRGB background - this
 2456                 * requires inverting the encoding for each component.  The input
 2457                 * is still converted to the sRGB encoding because this is a
 2458                 * reasonable approximate to the logarithmic curve of human
 2459                 * visual sensitivity, at least over the narrow range which PNG
 2460                 * represents.  Consequently 'G' is always sRGB encoded, while
 2461                 * 'A' is linear.  We need the linear background colors.
 2462                 */
 2463                if (output_encoding == P_sRGB) /* else already linear */
 2464                {
 2465                   /* This may produce a value not exactly matching the
 2466                    * background, but that's ok because these numbers are only
 2467                    * used when alpha != 0
 2468                    */
 2469                   back_r = png_sRGB_table[back_r];
 2470                   back_g = png_sRGB_table[back_g];
 2471                   back_b = png_sRGB_table[back_b];
 2472                }
 2473 
 2474                for (a=1; a<5; ++a)
 2475                {
 2476                   unsigned int g;
 2477 
 2478                   /* PNG_sRGB_FROM_LINEAR expects a 16-bit linear value scaled
 2479                    * by an 8-bit alpha value (0..255).
 2480                    */
 2481                   png_uint_32 alpha = 51 * a;
 2482                   png_uint_32 back_rx = (255-alpha) * back_r;
 2483                   png_uint_32 back_gx = (255-alpha) * back_g;
 2484                   png_uint_32 back_bx = (255-alpha) * back_b;
 2485 
 2486                   for (g=0; g<6; ++g)
 2487                   {
 2488                      png_uint_32 gray = png_sRGB_table[g*51] * alpha;
 2489 
 2490                      png_create_colormap_entry(display, i++,
 2491                          PNG_sRGB_FROM_LINEAR(gray + back_rx),
 2492                          PNG_sRGB_FROM_LINEAR(gray + back_gx),
 2493                          PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB);
 2494                   }
 2495                }
 2496 
 2497                cmap_entries = i;
 2498                output_processing = PNG_CMAP_GA;
 2499             }
 2500          }
 2501          break;
 2502 
 2503       case PNG_COLOR_TYPE_RGB:
 2504       case PNG_COLOR_TYPE_RGB_ALPHA:
 2505          /* Exclude the case where the output is gray; we can always handle this
 2506           * with the cases above.
 2507           */
 2508          if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0)
 2509          {
 2510             /* The color-map will be grayscale, so we may as well convert the
 2511              * input RGB values to a simple grayscale and use the grayscale
 2512              * code above.
 2513              *
 2514              * NOTE: calling this apparently damages the recognition of the
 2515              * transparent color in background color handling; call
 2516              * png_set_tRNS_to_alpha before png_set_background_fixed.
 2517              */
 2518             png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
 2519                 -1);
 2520             data_encoding = P_sRGB;
 2521 
 2522             /* The output will now be one or two 8-bit gray or gray+alpha
 2523              * channels.  The more complex case arises when the input has alpha.
 2524              */
 2525             if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
 2526                png_ptr->num_trans > 0) &&
 2527                (output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 2528             {
 2529                /* Both input and output have an alpha channel, so no background
 2530                 * processing is required; just map the GA bytes to the right
 2531                 * color-map entry.
 2532                 */
 2533                expand_tRNS = 1;
 2534 
 2535                if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
 2536                   png_error(png_ptr, "rgb[ga] color-map: too few entries");
 2537 
 2538                cmap_entries = (unsigned int)make_ga_colormap(display);
 2539                background_index = PNG_CMAP_GA_BACKGROUND;
 2540                output_processing = PNG_CMAP_GA;
 2541             }
 2542 
 2543             else
 2544             {
 2545                /* Either the input or the output has no alpha channel, so there
 2546                 * will be no non-opaque pixels in the color-map; it will just be
 2547                 * grayscale.
 2548                 */
 2549                if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries)
 2550                   png_error(png_ptr, "rgb[gray] color-map: too few entries");
 2551 
 2552                /* Ideally this code would use libpng to do the gamma correction,
 2553                 * but if an input alpha channel is to be removed we will hit the
 2554                 * libpng bug in gamma+compose+rgb-to-gray (the double gamma
 2555                 * correction bug).  Fix this by dropping the gamma correction in
 2556                 * this case and doing it in the palette; this will result in
 2557                 * duplicate palette entries, but that's better than the
 2558                 * alternative of double gamma correction.
 2559                 */
 2560                if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
 2561                   png_ptr->num_trans > 0) &&
 2562                   png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0)
 2563                {
 2564                   cmap_entries = (unsigned int)make_gray_file_colormap(display);
 2565                   data_encoding = P_FILE;
 2566                }
 2567 
 2568                else
 2569                   cmap_entries = (unsigned int)make_gray_colormap(display);
 2570 
 2571                /* But if the input has alpha or transparency it must be removed
 2572                 */
 2573                if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
 2574                   png_ptr->num_trans > 0)
 2575                {
 2576                   png_color_16 c;
 2577                   png_uint_32 gray = back_g;
 2578 
 2579                   /* We need to ensure that the application background exists in
 2580                    * the colormap and that completely transparent pixels map to
 2581                    * it.  Achieve this simply by ensuring that the entry
 2582                    * selected for the background really is the background color.
 2583                    */
 2584                   if (data_encoding == P_FILE) /* from the fixup above */
 2585                   {
 2586                      /* The app supplied a gray which is in output_encoding, we
 2587                       * need to convert it to a value of the input (P_FILE)
 2588                       * encoding then set this palette entry to the required
 2589                       * output encoding.
 2590                       */
 2591                      if (output_encoding == P_sRGB)
 2592                         gray = png_sRGB_table[gray]; /* now P_LINEAR */
 2593 
 2594                      gray = PNG_DIV257(png_gamma_16bit_correct(gray,
 2595                          png_ptr->colorspace.gamma)); /* now P_FILE */
 2596 
 2597                      /* And make sure the corresponding palette entry contains
 2598                       * exactly the required sRGB value.
 2599                       */
 2600                      png_create_colormap_entry(display, gray, back_g, back_g,
 2601                          back_g, 0/*unused*/, output_encoding);
 2602                   }
 2603 
 2604                   else if (output_encoding == P_LINEAR)
 2605                   {
 2606                      gray = PNG_sRGB_FROM_LINEAR(gray * 255);
 2607 
 2608                      /* And make sure the corresponding palette entry matches.
 2609                       */
 2610                      png_create_colormap_entry(display, gray, back_g, back_g,
 2611                         back_g, 0/*unused*/, P_LINEAR);
 2612                   }
 2613 
 2614                   /* The background passed to libpng, however, must be the
 2615                    * output (normally sRGB) value.
 2616                    */
 2617                   c.index = 0; /*unused*/
 2618                   c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
 2619 
 2620                   /* NOTE: the following is apparently a bug in libpng. Without
 2621                    * it the transparent color recognition in
 2622                    * png_set_background_fixed seems to go wrong.
 2623                    */
 2624                   expand_tRNS = 1;
 2625                   png_set_background_fixed(png_ptr, &c,
 2626                       PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
 2627                       0/*gamma: not used*/);
 2628                }
 2629 
 2630                output_processing = PNG_CMAP_NONE;
 2631             }
 2632          }
 2633 
 2634          else /* output is color */
 2635          {
 2636             /* We could use png_quantize here so long as there is no transparent
 2637              * color or alpha; png_quantize ignores alpha.  Easier overall just
 2638              * to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube.
 2639              * Consequently we always want libpng to produce sRGB data.
 2640              */
 2641             data_encoding = P_sRGB;
 2642 
 2643             /* Is there any transparency or alpha? */
 2644             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
 2645                png_ptr->num_trans > 0)
 2646             {
 2647                /* Is there alpha in the output too?  If so all four channels are
 2648                 * processed into a special RGB cube with alpha support.
 2649                 */
 2650                if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 2651                {
 2652                   png_uint_32 r;
 2653 
 2654                   if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)
 2655                      png_error(png_ptr, "rgb+alpha color-map: too few entries");
 2656 
 2657                   cmap_entries = (unsigned int)make_rgb_colormap(display);
 2658 
 2659                   /* Add a transparent entry. */
 2660                   png_create_colormap_entry(display, cmap_entries, 255, 255,
 2661                       255, 0, P_sRGB);
 2662 
 2663                   /* This is stored as the background index for the processing
 2664                    * algorithm.
 2665                    */
 2666                   background_index = cmap_entries++;
 2667 
 2668                   /* Add 27 r,g,b entries each with alpha 0.5. */
 2669                   for (r=0; r<256; r = (r << 1) | 0x7f)
 2670                   {
 2671                      png_uint_32 g;
 2672 
 2673                      for (g=0; g<256; g = (g << 1) | 0x7f)
 2674                      {
 2675                         png_uint_32 b;
 2676 
 2677                         /* This generates components with the values 0, 127 and
 2678                          * 255
 2679                          */
 2680                         for (b=0; b<256; b = (b << 1) | 0x7f)
 2681                            png_create_colormap_entry(display, cmap_entries++,
 2682                                r, g, b, 128, P_sRGB);
 2683                      }
 2684                   }
 2685 
 2686                   expand_tRNS = 1;
 2687                   output_processing = PNG_CMAP_RGB_ALPHA;
 2688                }
 2689 
 2690                else
 2691                {
 2692                   /* Alpha/transparency must be removed.  The background must
 2693                    * exist in the color map (achieved by setting adding it after
 2694                    * the 666 color-map).  If the standard processing code will
 2695                    * pick up this entry automatically that's all that is
 2696                    * required; libpng can be called to do the background
 2697                    * processing.
 2698                    */
 2699                   unsigned int sample_size =
 2700                      PNG_IMAGE_SAMPLE_SIZE(output_format);
 2701                   png_uint_32 r, g, b; /* sRGB background */
 2702 
 2703                   if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries)
 2704                      png_error(png_ptr, "rgb-alpha color-map: too few entries");
 2705 
 2706                   cmap_entries = (unsigned int)make_rgb_colormap(display);
 2707 
 2708                   png_create_colormap_entry(display, cmap_entries, back_r,
 2709                       back_g, back_b, 0/*unused*/, output_encoding);
 2710 
 2711                   if (output_encoding == P_LINEAR)
 2712                   {
 2713                      r = PNG_sRGB_FROM_LINEAR(back_r * 255);
 2714                      g = PNG_sRGB_FROM_LINEAR(back_g * 255);
 2715                      b = PNG_sRGB_FROM_LINEAR(back_b * 255);
 2716                   }
 2717 
 2718                   else
 2719                   {
 2720                      r = back_r;
 2721                      g = back_g;
 2722                      b = back_g;
 2723                   }
 2724 
 2725                   /* Compare the newly-created color-map entry with the one the
 2726                    * PNG_CMAP_RGB algorithm will use.  If the two entries don't
 2727                    * match, add the new one and set this as the background
 2728                    * index.
 2729                    */
 2730                   if (memcmp((png_const_bytep)display->colormap +
 2731                       sample_size * cmap_entries,
 2732                       (png_const_bytep)display->colormap +
 2733                           sample_size * PNG_RGB_INDEX(r,g,b),
 2734                      sample_size) != 0)
 2735                   {
 2736                      /* The background color must be added. */
 2737                      background_index = cmap_entries++;
 2738 
 2739                      /* Add 27 r,g,b entries each with created by composing with
 2740                       * the background at alpha 0.5.
 2741                       */
 2742                      for (r=0; r<256; r = (r << 1) | 0x7f)
 2743                      {
 2744                         for (g=0; g<256; g = (g << 1) | 0x7f)
 2745                         {
 2746                            /* This generates components with the values 0, 127
 2747                             * and 255
 2748                             */
 2749                            for (b=0; b<256; b = (b << 1) | 0x7f)
 2750                               png_create_colormap_entry(display, cmap_entries++,
 2751                                   png_colormap_compose(display, r, P_sRGB, 128,
 2752                                       back_r, output_encoding),
 2753                                   png_colormap_compose(display, g, P_sRGB, 128,
 2754                                       back_g, output_encoding),
 2755                                   png_colormap_compose(display, b, P_sRGB, 128,
 2756                                       back_b, output_encoding),
 2757                                   0/*unused*/, output_encoding);
 2758                         }
 2759                      }
 2760 
 2761                      expand_tRNS = 1;
 2762                      output_processing = PNG_CMAP_RGB_ALPHA;
 2763                   }
 2764 
 2765                   else /* background color is in the standard color-map */
 2766                   {
 2767                      png_color_16 c;
 2768 
 2769                      c.index = 0; /*unused*/
 2770                      c.red = (png_uint_16)back_r;
 2771                      c.gray = c.green = (png_uint_16)back_g;
 2772                      c.blue = (png_uint_16)back_b;
 2773 
 2774                      png_set_background_fixed(png_ptr, &c,
 2775                          PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
 2776                          0/*gamma: not used*/);
 2777 
 2778                      output_processing = PNG_CMAP_RGB;
 2779                   }
 2780                }
 2781             }
 2782 
 2783             else /* no alpha or transparency in the input */
 2784             {
 2785                /* Alpha in the output is irrelevant, simply map the opaque input
 2786                 * pixels to the 6x6x6 color-map.
 2787                 */
 2788                if (PNG_RGB_COLORMAP_ENTRIES > image->colormap_entries)
 2789                   png_error(png_ptr, "rgb color-map: too few entries");
 2790 
 2791                cmap_entries = (unsigned int)make_rgb_colormap(display);
 2792                output_processing = PNG_CMAP_RGB;
 2793             }
 2794          }
 2795          break;
 2796 
 2797       case PNG_COLOR_TYPE_PALETTE:
 2798          /* It's already got a color-map.  It may be necessary to eliminate the
 2799           * tRNS entries though.
 2800           */
 2801          {
 2802             unsigned int num_trans = png_ptr->num_trans;
 2803             png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL;
 2804             png_const_colorp colormap = png_ptr->palette;
 2805             int do_background = trans != NULL &&
 2806                (output_format & PNG_FORMAT_FLAG_ALPHA) == 0;
 2807             unsigned int i;
 2808 
 2809             /* Just in case: */
 2810             if (trans == NULL)
 2811                num_trans = 0;
 2812 
 2813             output_processing = PNG_CMAP_NONE;
 2814             data_encoding = P_FILE; /* Don't change from color-map indices */
 2815             cmap_entries = (unsigned int)png_ptr->num_palette;
 2816             if (cmap_entries > 256)
 2817                cmap_entries = 256;
 2818 
 2819             if (cmap_entries > (unsigned int)image->colormap_entries)
 2820                png_error(png_ptr, "palette color-map: too few entries");
 2821 
 2822             for (i=0; i < cmap_entries; ++i)
 2823             {
 2824                if (do_background != 0 && i < num_trans && trans[i] < 255)
 2825                {
 2826                   if (trans[i] == 0)
 2827                      png_create_colormap_entry(display, i, back_r, back_g,
 2828                          back_b, 0, output_encoding);
 2829 
 2830                   else
 2831                   {
 2832                      /* Must compose the PNG file color in the color-map entry
 2833                       * on the sRGB color in 'back'.
 2834                       */
 2835                      png_create_colormap_entry(display, i,
 2836                          png_colormap_compose(display, colormap[i].red,
 2837                              P_FILE, trans[i], back_r, output_encoding),
 2838                          png_colormap_compose(display, colormap[i].green,
 2839                              P_FILE, trans[i], back_g, output_encoding),
 2840                          png_colormap_compose(display, colormap[i].blue,
 2841                              P_FILE, trans[i], back_b, output_encoding),
 2842                          output_encoding == P_LINEAR ? trans[i] * 257U :
 2843                              trans[i],
 2844                          output_encoding);
 2845                   }
 2846                }
 2847 
 2848                else
 2849                   png_create_colormap_entry(display, i, colormap[i].red,
 2850                       colormap[i].green, colormap[i].blue,
 2851                       i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/);
 2852             }
 2853 
 2854             /* The PNG data may have indices packed in fewer than 8 bits, it
 2855              * must be expanded if so.
 2856              */
 2857             if (png_ptr->bit_depth < 8)
 2858                png_set_packing(png_ptr);
 2859          }
 2860          break;
 2861 
 2862       default:
 2863          png_error(png_ptr, "invalid PNG color type");
 2864          /*NOT REACHED*/
 2865    }
 2866 
 2867    /* Now deal with the output processing */
 2868    if (expand_tRNS != 0 && png_ptr->num_trans > 0 &&
 2869        (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
 2870       png_set_tRNS_to_alpha(png_ptr);
 2871 
 2872    switch (data_encoding)
 2873    {
 2874       case P_sRGB:
 2875          /* Change to 8-bit sRGB */
 2876          png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB);
 2877          /* FALLTHROUGH */
 2878 
 2879       case P_FILE:
 2880          if (png_ptr->bit_depth > 8)
 2881             png_set_scale_16(png_ptr);
 2882          break;
 2883 
 2884 #ifdef __GNUC__
 2885       default:
 2886          png_error(png_ptr, "bad data option (internal error)");
 2887 #endif
 2888    }
 2889 
 2890    if (cmap_entries > 256 || cmap_entries > image->colormap_entries)
 2891       png_error(png_ptr, "color map overflow (BAD internal error)");
 2892 
 2893    image->colormap_entries = cmap_entries;
 2894 
 2895    /* Double check using the recorded background index */
 2896    switch (output_processing)
 2897    {
 2898       case PNG_CMAP_NONE:
 2899          if (background_index != PNG_CMAP_NONE_BACKGROUND)
 2900             goto bad_background;
 2901          break;
 2902 
 2903       case PNG_CMAP_GA:
 2904          if (background_index != PNG_CMAP_GA_BACKGROUND)
 2905             goto bad_background;
 2906          break;
 2907 
 2908       case PNG_CMAP_TRANS:
 2909          if (background_index >= cmap_entries ||
 2910             background_index != PNG_CMAP_TRANS_BACKGROUND)
 2911             goto bad_background;
 2912          break;
 2913 
 2914       case PNG_CMAP_RGB:
 2915          if (background_index != PNG_CMAP_RGB_BACKGROUND)
 2916             goto bad_background;
 2917          break;
 2918 
 2919       case PNG_CMAP_RGB_ALPHA:
 2920          if (background_index != PNG_CMAP_RGB_ALPHA_BACKGROUND)
 2921             goto bad_background;
 2922          break;
 2923 
 2924       default:
 2925          png_error(png_ptr, "bad processing option (internal error)");
 2926 
 2927       bad_background:
 2928          png_error(png_ptr, "bad background index (internal error)");
 2929    }
 2930 
 2931    display->colormap_processing = (int)output_processing;
 2932 
 2933    return 1/*ok*/;
 2934 }
 2935 
 2936 /* The final part of the color-map read called from png_image_finish_read. */
 2937 static int
 2938 png_image_read_and_map(png_voidp argument)
 2939 {
 2940    png_image_read_control *display = png_voidcast(png_image_read_control*,
 2941        argument);
 2942    png_imagep image = display->image;
 2943    png_structrp png_ptr = image->opaque->png_ptr;
 2944    int passes;
 2945 
 2946    /* Called when the libpng data must be transformed into the color-mapped
 2947     * form.  There is a local row buffer in display->local and this routine must
 2948     * do the interlace handling.
 2949     */
 2950    switch (png_ptr->interlaced)
 2951    {
 2952       case PNG_INTERLACE_NONE:
 2953          passes = 1;
 2954          break;
 2955 
 2956       case PNG_INTERLACE_ADAM7:
 2957          passes = PNG_INTERLACE_ADAM7_PASSES;
 2958          break;
 2959 
 2960       default:
 2961          png_error(png_ptr, "unknown interlace type");
 2962    }
 2963 
 2964    {
 2965       png_uint_32  height = image->height;
 2966       png_uint_32  width = image->width;
 2967       int          proc = display->colormap_processing;
 2968       png_bytep    first_row = png_voidcast(png_bytep, display->first_row);
 2969       ptrdiff_t    step_row = display->row_bytes;
 2970       int pass;
 2971 
 2972       for (pass = 0; pass < passes; ++pass)
 2973       {
 2974          unsigned int     startx, stepx, stepy;
 2975          png_uint_32      y;
 2976 
 2977          if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
 2978          {
 2979             /* The row may be empty for a short image: */
 2980             if (PNG_PASS_COLS(width, pass) == 0)
 2981                continue;
 2982 
 2983             startx = PNG_PASS_START_COL(pass);
 2984             stepx = PNG_PASS_COL_OFFSET(pass);
 2985             y = PNG_PASS_START_ROW(pass);
 2986             stepy = PNG_PASS_ROW_OFFSET(pass);
 2987          }
 2988 
 2989          else
 2990          {
 2991             y = 0;
 2992             startx = 0;
 2993             stepx = stepy = 1;
 2994          }
 2995 
 2996          for (; y<height; y += stepy)
 2997          {
 2998             png_bytep inrow = png_voidcast(png_bytep, display->local_row);
 2999             png_bytep outrow = first_row + y * step_row;
 3000             png_const_bytep end_row = outrow + width;
 3001 
 3002             /* Read read the libpng data into the temporary buffer. */
 3003             png_read_row(png_ptr, inrow, NULL);
 3004 
 3005             /* Now process the row according to the processing option, note
 3006              * that the caller verifies that the format of the libpng output
 3007              * data is as required.
 3008              */
 3009             outrow += startx;
 3010             switch (proc)
 3011             {
 3012                case PNG_CMAP_GA:
 3013                   for (; outrow < end_row; outrow += stepx)
 3014                   {
 3015                      /* The data is always in the PNG order */
 3016                      unsigned int gray = *inrow++;
 3017                      unsigned int alpha = *inrow++;
 3018                      unsigned int entry;
 3019 
 3020                      /* NOTE: this code is copied as a comment in
 3021                       * make_ga_colormap above.  Please update the
 3022                       * comment if you change this code!
 3023                       */
 3024                      if (alpha > 229) /* opaque */
 3025                      {
 3026                         entry = (231 * gray + 128) >> 8;
 3027                      }
 3028                      else if (alpha < 26) /* transparent */
 3029                      {
 3030                         entry = 231;
 3031                      }
 3032                      else /* partially opaque */
 3033                      {
 3034                         entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray);
 3035                      }
 3036 
 3037                      *outrow = (png_byte)entry;
 3038                   }
 3039                   break;
 3040 
 3041                case PNG_CMAP_TRANS:
 3042                   for (; outrow < end_row; outrow += stepx)
 3043                   {
 3044                      png_byte gray = *inrow++;
 3045                      png_byte alpha = *inrow++;
 3046 
 3047                      if (alpha == 0)
 3048                         *outrow = PNG_CMAP_TRANS_BACKGROUND;
 3049 
 3050                      else if (gray != PNG_CMAP_TRANS_BACKGROUND)
 3051                         *outrow = gray;
 3052 
 3053                      else
 3054                         *outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1);
 3055                   }
 3056                   break;
 3057 
 3058                case PNG_CMAP_RGB:
 3059                   for (; outrow < end_row; outrow += stepx)
 3060                   {
 3061                      *outrow = PNG_RGB_INDEX(inrow[0], inrow[1], inrow[2]);
 3062                      inrow += 3;
 3063                   }
 3064                   break;
 3065 
 3066                case PNG_CMAP_RGB_ALPHA:
 3067                   for (; outrow < end_row; outrow += stepx)
 3068                   {
 3069                      unsigned int alpha = inrow[3];
 3070 
 3071                      /* Because the alpha entries only hold alpha==0.5 values
 3072                       * split the processing at alpha==0.25 (64) and 0.75
 3073                       * (196).
 3074                       */
 3075 
 3076                      if (alpha >= 196)
 3077                         *outrow = PNG_RGB_INDEX(inrow[0], inrow[1],
 3078                             inrow[2]);
 3079 
 3080                      else if (alpha < 64)
 3081                         *outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND;
 3082 
 3083                      else
 3084                      {
 3085                         /* Likewise there are three entries for each of r, g
 3086                          * and b.  We could select the entry by popcount on
 3087                          * the top two bits on those architectures that
 3088                          * support it, this is what the code below does,
 3089                          * crudely.
 3090                          */
 3091                         unsigned int back_i = PNG_CMAP_RGB_ALPHA_BACKGROUND+1;
 3092 
 3093                         /* Here are how the values map:
 3094                          *
 3095                          * 0x00 .. 0x3f -> 0
 3096                          * 0x40 .. 0xbf -> 1
 3097                          * 0xc0 .. 0xff -> 2
 3098                          *
 3099                          * So, as above with the explicit alpha checks, the
 3100                          * breakpoints are at 64 and 196.
 3101                          */
 3102                         if (inrow[0] & 0x80) back_i += 9; /* red */
 3103                         if (inrow[0] & 0x40) back_i += 9;
 3104                         if (inrow[0] & 0x80) back_i += 3; /* green */
 3105                         if (inrow[0] & 0x40) back_i += 3;
 3106                         if (inrow[0] & 0x80) back_i += 1; /* blue */
 3107                         if (inrow[0] & 0x40) back_i += 1;
 3108 
 3109                         *outrow = (png_byte)back_i;
 3110                      }
 3111 
 3112                      inrow += 4;
 3113                   }
 3114                   break;
 3115 
 3116                default:
 3117                   break;
 3118             }
 3119          }
 3120       }
 3121    }
 3122 
 3123    return 1;
 3124 }
 3125 
 3126 static int
 3127 png_image_read_colormapped(png_voidp argument)
 3128 {
 3129    png_image_read_control *display = png_voidcast(png_image_read_control*,
 3130        argument);
 3131    png_imagep image = display->image;
 3132    png_controlp control = image->opaque;
 3133    png_structrp png_ptr = control->png_ptr;
 3134    png_inforp info_ptr = control->info_ptr;
 3135 
 3136    int passes = 0; /* As a flag */
 3137 
 3138    PNG_SKIP_CHUNKS(png_ptr);
 3139 
 3140    /* Update the 'info' structure and make sure the result is as required; first
 3141     * make sure to turn on the interlace handling if it will be required
 3142     * (because it can't be turned on *after* the call to png_read_update_info!)
 3143     */
 3144    if (display->colormap_processing == PNG_CMAP_NONE)
 3145       passes = png_set_interlace_handling(png_ptr);
 3146 
 3147    png_read_update_info(png_ptr, info_ptr);
 3148 
 3149    /* The expected output can be deduced from the colormap_processing option. */
 3150    switch (display->colormap_processing)
 3151    {
 3152       case PNG_CMAP_NONE:
 3153          /* Output must be one channel and one byte per pixel, the output
 3154           * encoding can be anything.
 3155           */
 3156          if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
 3157             info_ptr->color_type == PNG_COLOR_TYPE_GRAY) &&
 3158             info_ptr->bit_depth == 8)
 3159             break;
 3160 
 3161          goto bad_output;
 3162 
 3163       case PNG_CMAP_TRANS:
 3164       case PNG_CMAP_GA:
 3165          /* Output must be two channels and the 'G' one must be sRGB, the latter
 3166           * can be checked with an exact number because it should have been set
 3167           * to this number above!
 3168           */
 3169          if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
 3170             info_ptr->bit_depth == 8 &&
 3171             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
 3172             image->colormap_entries == 256)
 3173             break;
 3174 
 3175          goto bad_output;
 3176 
 3177       case PNG_CMAP_RGB:
 3178          /* Output must be 8-bit sRGB encoded RGB */
 3179          if (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
 3180             info_ptr->bit_depth == 8 &&
 3181             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
 3182             image->colormap_entries == 216)
 3183             break;
 3184 
 3185          goto bad_output;
 3186 
 3187       case PNG_CMAP_RGB_ALPHA:
 3188          /* Output must be 8-bit sRGB encoded RGBA */
 3189          if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
 3190             info_ptr->bit_depth == 8 &&
 3191             png_ptr->screen_gamma == PNG_GAMMA_sRGB &&
 3192             image->colormap_entries == 244 /* 216 + 1 + 27 */)
 3193             break;
 3194 
 3195          goto bad_output;
 3196 
 3197       default:
 3198       bad_output:
 3199          png_error(png_ptr, "bad color-map processing (internal error)");
 3200    }
 3201 
 3202    /* Now read the rows.  Do this here if it is possible to read directly into
 3203     * the output buffer, otherwise allocate a local row buffer of the maximum
 3204     * size libpng requires and call the relevant processing routine safely.
 3205     */
 3206    {
 3207       png_voidp first_row = display->buffer;
 3208       ptrdiff_t row_bytes = display->row_stride;
 3209 
 3210       /* The following expression is designed to work correctly whether it gives
 3211        * a signed or an unsigned result.
 3212        */
 3213       if (row_bytes < 0)
 3214       {
 3215          char *ptr = png_voidcast(char*, first_row);
 3216          ptr += (image->height-1) * (-row_bytes);
 3217          first_row = png_voidcast(png_voidp, ptr);
 3218       }
 3219 
 3220       display->first_row = first_row;
 3221       display->row_bytes = row_bytes;
 3222    }
 3223 
 3224    if (passes == 0)
 3225    {
 3226       int result;
 3227       png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
 3228 
 3229       display->local_row = row;
 3230       result = png_safe_execute(image, png_image_read_and_map, display);
 3231       display->local_row = NULL;
 3232       png_free(png_ptr, row);
 3233 
 3234       return result;
 3235    }
 3236 
 3237    else
 3238    {
 3239       png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes;
 3240 
 3241       while (--passes >= 0)
 3242       {
 3243          png_uint_32      y = image->height;
 3244          png_bytep        row = png_voidcast(png_bytep, display->first_row);
 3245 
 3246          for (; y > 0; --y)
 3247          {
 3248             png_read_row(png_ptr, row, NULL);
 3249             row += row_bytes;
 3250          }
 3251       }
 3252 
 3253       return 1;
 3254    }
 3255 }
 3256 
 3257 /* Just the row reading part of png_image_read. */
 3258 static int
 3259 png_image_read_composite(png_voidp argument)
 3260 {
 3261    png_image_read_control *display = png_voidcast(png_image_read_control*,
 3262        argument);
 3263    png_imagep image = display->image;
 3264    png_structrp png_ptr = image->opaque->png_ptr;
 3265    int passes;
 3266 
 3267    switch (png_ptr->interlaced)
 3268    {
 3269       case PNG_INTERLACE_NONE:
 3270          passes = 1;
 3271          break;
 3272 
 3273       case PNG_INTERLACE_ADAM7:
 3274          passes = PNG_INTERLACE_ADAM7_PASSES;
 3275          break;
 3276 
 3277       default:
 3278          png_error(png_ptr, "unknown interlace type");
 3279    }
 3280 
 3281    {
 3282       png_uint_32  height = image->height;
 3283       png_uint_32  width = image->width;
 3284       ptrdiff_t    step_row = display->row_bytes;
 3285       unsigned int channels =
 3286           (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
 3287       int pass;
 3288 
 3289       for (pass = 0; pass < passes; ++pass)
 3290       {
 3291          unsigned int     startx, stepx, stepy;
 3292          png_uint_32      y;
 3293 
 3294          if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
 3295          {
 3296             /* The row may be empty for a short image: */
 3297             if (PNG_PASS_COLS(width, pass) == 0)
 3298                continue;
 3299 
 3300             startx = PNG_PASS_START_COL(pass) * channels;
 3301             stepx = PNG_PASS_COL_OFFSET(pass) * channels;
 3302             y = PNG_PASS_START_ROW(pass);
 3303             stepy = PNG_PASS_ROW_OFFSET(pass);
 3304          }
 3305 
 3306          else
 3307          {
 3308             y = 0;
 3309             startx = 0;
 3310             stepx = channels;
 3311             stepy = 1;
 3312          }
 3313 
 3314          for (; y<height; y += stepy)
 3315          {
 3316             png_bytep inrow = png_voidcast(png_bytep, display->local_row);
 3317             png_bytep outrow;
 3318             png_const_bytep end_row;
 3319 
 3320             /* Read the row, which is packed: */
 3321             png_read_row(png_ptr, inrow, NULL);
 3322 
 3323             outrow = png_voidcast(png_bytep, display->first_row);
 3324             outrow += y * step_row;
 3325             end_row = outrow + width * channels;
 3326 
 3327             /* Now do the composition on each pixel in this row. */
 3328             outrow += startx;
 3329             for (; outrow < end_row; outrow += stepx)
 3330             {
 3331                png_byte alpha = inrow[channels];
 3332 
 3333                if (alpha > 0) /* else no change to the output */
 3334                {
 3335                   unsigned int c;
 3336 
 3337                   for (c=0; c<channels; ++c)
 3338                   {
 3339                      png_uint_32 component = inrow[c];
 3340 
 3341                      if (alpha < 255) /* else just use component */
 3342                      {
 3343                         /* This is PNG_OPTIMIZED_ALPHA, the component value
 3344                          * is a linear 8-bit value.  Combine this with the
 3345                          * current outrow[c] value which is sRGB encoded.
 3346                          * Arithmetic here is 16-bits to preserve the output
 3347                          * values correctly.
 3348                          */
 3349                         component *= 257*255; /* =65535 */
 3350                         component += (255-alpha)*png_sRGB_table[outrow[c]];
 3351 
 3352                         /* So 'component' is scaled by 255*65535 and is
 3353                          * therefore appropriate for the sRGB to linear
 3354                          * conversion table.
 3355                          */
 3356                         component = PNG_sRGB_FROM_LINEAR(component);
 3357                      }
 3358 
 3359                      outrow[c] = (png_byte)component;
 3360                   }
 3361                }
 3362 
 3363                inrow += channels+1; /* components and alpha channel */
 3364             }
 3365          }
 3366       }
 3367    }
 3368 
 3369    return 1;
 3370 }
 3371 
 3372 /* The do_local_background case; called when all the following transforms are to
 3373  * be done:
 3374  *
 3375  * PNG_RGB_TO_GRAY
 3376  * PNG_COMPOSITE
 3377  * PNG_GAMMA
 3378  *
 3379  * This is a work-around for the fact that both the PNG_RGB_TO_GRAY and
 3380  * PNG_COMPOSITE code performs gamma correction, so we get double gamma
 3381  * correction.  The fix-up is to prevent the PNG_COMPOSITE operation from
 3382  * happening inside libpng, so this routine sees an 8 or 16-bit gray+alpha
 3383  * row and handles the removal or pre-multiplication of the alpha channel.
 3384  */
 3385 static int
 3386 png_image_read_background(png_voidp argument)
 3387 {
 3388    png_image_read_control *display = png_voidcast(png_image_read_control*,
 3389        argument);
 3390    png_imagep image = display->image;
 3391    png_structrp png_ptr = image->opaque->png_ptr;
 3392    png_inforp info_ptr = image->opaque->info_ptr;
 3393    png_uint_32 height = image->height;
 3394    png_uint_32 width = image->width;
 3395    int pass, passes;
 3396 
 3397    /* Double check the convoluted logic below.  We expect to get here with
 3398     * libpng doing rgb to gray and gamma correction but background processing
 3399     * left to the png_image_read_background function.  The rows libpng produce
 3400     * might be 8 or 16-bit but should always have two channels; gray plus alpha.
 3401     */
 3402    if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
 3403       png_error(png_ptr, "lost rgb to gray");
 3404 
 3405    if ((png_ptr->transformations & PNG_COMPOSE) != 0)
 3406       png_error(png_ptr, "unexpected compose");
 3407 
 3408    if (png_get_channels(png_ptr, info_ptr) != 2)
 3409       png_error(png_ptr, "lost/gained channels");
 3410 
 3411    /* Expect the 8-bit case to always remove the alpha channel */
 3412    if ((image->format & PNG_FORMAT_FLAG_LINEAR) == 0 &&
 3413       (image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3414       png_error(png_ptr, "unexpected 8-bit transformation");
 3415 
 3416    switch (png_ptr->interlaced)
 3417    {
 3418       case PNG_INTERLACE_NONE:
 3419          passes = 1;
 3420          break;
 3421 
 3422       case PNG_INTERLACE_ADAM7:
 3423          passes = PNG_INTERLACE_ADAM7_PASSES;
 3424          break;
 3425 
 3426       default:
 3427          png_error(png_ptr, "unknown interlace type");
 3428    }
 3429 
 3430    /* Use direct access to info_ptr here because otherwise the simplified API
 3431     * would require PNG_EASY_ACCESS_SUPPORTED (just for this.)  Note this is
 3432     * checking the value after libpng expansions, not the original value in the
 3433     * PNG.
 3434     */
 3435    switch (info_ptr->bit_depth)
 3436    {
 3437       case 8:
 3438          /* 8-bit sRGB gray values with an alpha channel; the alpha channel is
 3439           * to be removed by composing on a background: either the row if
 3440           * display->background is NULL or display->background->green if not.
 3441           * Unlike the code above ALPHA_OPTIMIZED has *not* been done.
 3442           */
 3443          {
 3444             png_bytep first_row = png_voidcast(png_bytep, display->first_row);
 3445             ptrdiff_t step_row = display->row_bytes;
 3446 
 3447             for (pass = 0; pass < passes; ++pass)
 3448             {
 3449                png_bytep row = png_voidcast(png_bytep, display->first_row);
 3450                unsigned int     startx, stepx, stepy;
 3451                png_uint_32      y;
 3452 
 3453                if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
 3454                {
 3455                   /* The row may be empty for a short image: */
 3456                   if (PNG_PASS_COLS(width, pass) == 0)
 3457                      continue;
 3458 
 3459                   startx = PNG_PASS_START_COL(pass);
 3460                   stepx = PNG_PASS_COL_OFFSET(pass);
 3461                   y = PNG_PASS_START_ROW(pass);
 3462                   stepy = PNG_PASS_ROW_OFFSET(pass);
 3463                }
 3464 
 3465                else
 3466                {
 3467                   y = 0;
 3468                   startx = 0;
 3469                   stepx = stepy = 1;
 3470                }
 3471 
 3472                if (display->background == NULL)
 3473                {
 3474                   for (; y<height; y += stepy)
 3475                   {
 3476                      png_bytep inrow = png_voidcast(png_bytep,
 3477                          display->local_row);
 3478                      png_bytep outrow = first_row + y * step_row;
 3479                      png_const_bytep end_row = outrow + width;
 3480 
 3481                      /* Read the row, which is packed: */
 3482                      png_read_row(png_ptr, inrow, NULL);
 3483 
 3484                      /* Now do the composition on each pixel in this row. */
 3485                      outrow += startx;
 3486                      for (; outrow < end_row; outrow += stepx)
 3487                      {
 3488                         png_byte alpha = inrow[1];
 3489 
 3490                         if (alpha > 0) /* else no change to the output */
 3491                         {
 3492                            png_uint_32 component = inrow[0];
 3493 
 3494                            if (alpha < 255) /* else just use component */
 3495                            {
 3496                               /* Since PNG_OPTIMIZED_ALPHA was not set it is
 3497                                * necessary to invert the sRGB transfer
 3498                                * function and multiply the alpha out.
 3499                                */
 3500                               component = png_sRGB_table[component] * alpha;
 3501                               component += png_sRGB_table[outrow[0]] *
 3502                                  (255-alpha);
 3503                               component = PNG_sRGB_FROM_LINEAR(component);
 3504                            }
 3505 
 3506                            outrow[0] = (png_byte)component;
 3507                         }
 3508 
 3509                         inrow += 2; /* gray and alpha channel */
 3510                      }
 3511                   }
 3512                }
 3513 
 3514                else /* constant background value */
 3515                {
 3516                   png_byte background8 = display->background->green;
 3517                   png_uint_16 background = png_sRGB_table[background8];
 3518 
 3519                   for (; y<height; y += stepy)
 3520                   {
 3521                      png_bytep inrow = png_voidcast(png_bytep,
 3522                          display->local_row);
 3523                      png_bytep outrow = first_row + y * step_row;
 3524                      png_const_bytep end_row = outrow + width;
 3525 
 3526                      /* Read the row, which is packed: */
 3527                      png_read_row(png_ptr, inrow, NULL);
 3528 
 3529                      /* Now do the composition on each pixel in this row. */
 3530                      outrow += startx;
 3531                      for (; outrow < end_row; outrow += stepx)
 3532                      {
 3533                         png_byte alpha = inrow[1];
 3534 
 3535                         if (alpha > 0) /* else use background */
 3536                         {
 3537                            png_uint_32 component = inrow[0];
 3538 
 3539                            if (alpha < 255) /* else just use component */
 3540                            {
 3541                               component = png_sRGB_table[component] * alpha;
 3542                               component += background * (255-alpha);
 3543                               component = PNG_sRGB_FROM_LINEAR(component);
 3544                            }
 3545 
 3546                            outrow[0] = (png_byte)component;
 3547                         }
 3548 
 3549                         else
 3550                            outrow[0] = background8;
 3551 
 3552                         inrow += 2; /* gray and alpha channel */
 3553                      }
 3554 
 3555                      row += display->row_bytes;
 3556                   }
 3557                }
 3558             }
 3559          }
 3560          break;
 3561 
 3562       case 16:
 3563          /* 16-bit linear with pre-multiplied alpha; the pre-multiplication must
 3564           * still be done and, maybe, the alpha channel removed.  This code also
 3565           * handles the alpha-first option.
 3566           */
 3567          {
 3568             png_uint_16p first_row = png_voidcast(png_uint_16p,
 3569                 display->first_row);
 3570             /* The division by two is safe because the caller passed in a
 3571              * stride which was multiplied by 2 (below) to get row_bytes.
 3572              */
 3573             ptrdiff_t    step_row = display->row_bytes / 2;
 3574             unsigned int preserve_alpha = (image->format &
 3575                 PNG_FORMAT_FLAG_ALPHA) != 0;
 3576             unsigned int outchannels = 1U+preserve_alpha;
 3577             int swap_alpha = 0;
 3578 
 3579 #           ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
 3580                if (preserve_alpha != 0 &&
 3581                    (image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
 3582                   swap_alpha = 1;
 3583 #           endif
 3584 
 3585             for (pass = 0; pass < passes; ++pass)
 3586             {
 3587                unsigned int     startx, stepx, stepy;
 3588                png_uint_32      y;
 3589 
 3590                /* The 'x' start and step are adjusted to output components here.
 3591                 */
 3592                if (png_ptr->interlaced == PNG_INTERLACE_ADAM7)
 3593                {
 3594                   /* The row may be empty for a short image: */
 3595                   if (PNG_PASS_COLS(width, pass) == 0)
 3596                      continue;
 3597 
 3598                   startx = PNG_PASS_START_COL(pass) * outchannels;
 3599                   stepx = PNG_PASS_COL_OFFSET(pass) * outchannels;
 3600                   y = PNG_PASS_START_ROW(pass);
 3601                   stepy = PNG_PASS_ROW_OFFSET(pass);
 3602                }
 3603 
 3604                else
 3605                {
 3606                   y = 0;
 3607                   startx = 0;
 3608                   stepx = outchannels;
 3609                   stepy = 1;
 3610                }
 3611 
 3612                for (; y<height; y += stepy)
 3613                {
 3614                   png_const_uint_16p inrow;
 3615                   png_uint_16p outrow = first_row + y*step_row;
 3616                   png_uint_16p end_row = outrow + width * outchannels;
 3617 
 3618                   /* Read the row, which is packed: */
 3619                   png_read_row(png_ptr, png_voidcast(png_bytep,
 3620                       display->local_row), NULL);
 3621                   inrow = png_voidcast(png_const_uint_16p, display->local_row);
 3622 
 3623                   /* Now do the pre-multiplication on each pixel in this row.
 3624                    */
 3625                   outrow += startx;
 3626                   for (; outrow < end_row; outrow += stepx)
 3627                   {
 3628                      png_uint_32 component = inrow[0];
 3629                      png_uint_16 alpha = inrow[1];
 3630 
 3631                      if (alpha > 0) /* else 0 */
 3632                      {
 3633                         if (alpha < 65535) /* else just use component */
 3634                         {
 3635                            component *= alpha;
 3636                            component += 32767;
 3637                            component /= 65535;
 3638                         }
 3639                      }
 3640 
 3641                      else
 3642                         component = 0;
 3643 
 3644                      outrow[swap_alpha] = (png_uint_16)component;
 3645                      if (preserve_alpha != 0)
 3646                         outrow[1 ^ swap_alpha] = alpha;
 3647 
 3648                      inrow += 2; /* components and alpha channel */
 3649                   }
 3650                }
 3651             }
 3652          }
 3653          break;
 3654 
 3655 #ifdef __GNUC__
 3656       default:
 3657          png_error(png_ptr, "unexpected bit depth");
 3658 #endif
 3659    }
 3660 
 3661    return 1;
 3662 }
 3663 
 3664 /* The guts of png_image_finish_read as a png_safe_execute callback. */
 3665 static int
 3666 png_image_read_direct(png_voidp argument)
 3667 {
 3668    png_image_read_control *display = png_voidcast(png_image_read_control*,
 3669        argument);
 3670    png_imagep image = display->image;
 3671    png_structrp png_ptr = image->opaque->png_ptr;
 3672    png_inforp info_ptr = image->opaque->info_ptr;
 3673 
 3674    png_uint_32 format = image->format;
 3675    int linear = (format & PNG_FORMAT_FLAG_LINEAR) != 0;
 3676    int do_local_compose = 0;
 3677    int do_local_background = 0; /* to avoid double gamma correction bug */
 3678    int passes = 0;
 3679 
 3680    /* Add transforms to ensure the correct output format is produced then check
 3681     * that the required implementation support is there.  Always expand; always
 3682     * need 8 bits minimum, no palette and expanded tRNS.
 3683     */
 3684    png_set_expand(png_ptr);
 3685 
 3686    /* Now check the format to see if it was modified. */
 3687    {
 3688       png_uint_32 base_format = png_image_format(png_ptr) &
 3689          ~PNG_FORMAT_FLAG_COLORMAP /* removed by png_set_expand */;
 3690       png_uint_32 change = format ^ base_format;
 3691       png_fixed_point output_gamma;
 3692       int mode; /* alpha mode */
 3693 
 3694       /* Do this first so that we have a record if rgb to gray is happening. */
 3695       if ((change & PNG_FORMAT_FLAG_COLOR) != 0)
 3696       {
 3697          /* gray<->color transformation required. */
 3698          if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
 3699             png_set_gray_to_rgb(png_ptr);
 3700 
 3701          else
 3702          {
 3703             /* libpng can't do both rgb to gray and
 3704              * background/pre-multiplication if there is also significant gamma
 3705              * correction, because both operations require linear colors and
 3706              * the code only supports one transform doing the gamma correction.
 3707              * Handle this by doing the pre-multiplication or background
 3708              * operation in this code, if necessary.
 3709              *
 3710              * TODO: fix this by rewriting pngrtran.c (!)
 3711              *
 3712              * For the moment (given that fixing this in pngrtran.c is an
 3713              * enormous change) 'do_local_background' is used to indicate that
 3714              * the problem exists.
 3715              */
 3716             if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3717                do_local_background = 1/*maybe*/;
 3718 
 3719             png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
 3720                 PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT);
 3721          }
 3722 
 3723          change &= ~PNG_FORMAT_FLAG_COLOR;
 3724       }
 3725 
 3726       /* Set the gamma appropriately, linear for 16-bit input, sRGB otherwise.
 3727        */
 3728       {
 3729          png_fixed_point input_gamma_default;
 3730 
 3731          if ((base_format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
 3732              (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)
 3733             input_gamma_default = PNG_GAMMA_LINEAR;
 3734          else
 3735             input_gamma_default = PNG_DEFAULT_sRGB;
 3736 
 3737          /* Call png_set_alpha_mode to set the default for the input gamma; the
 3738           * output gamma is set by a second call below.
 3739           */
 3740          png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default);
 3741       }
 3742 
 3743       if (linear != 0)
 3744       {
 3745          /* If there *is* an alpha channel in the input it must be multiplied
 3746           * out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG.
 3747           */
 3748          if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3749             mode = PNG_ALPHA_STANDARD; /* associated alpha */
 3750 
 3751          else
 3752             mode = PNG_ALPHA_PNG;
 3753 
 3754          output_gamma = PNG_GAMMA_LINEAR;
 3755       }
 3756 
 3757       else
 3758       {
 3759          mode = PNG_ALPHA_PNG;
 3760          output_gamma = PNG_DEFAULT_sRGB;
 3761       }
 3762       
 3763       if ((change & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0)
 3764       {
 3765          mode = PNG_ALPHA_OPTIMIZED;
 3766          change &= ~PNG_FORMAT_FLAG_ASSOCIATED_ALPHA;
 3767       }
 3768       
 3769       /* If 'do_local_background' is set check for the presence of gamma
 3770        * correction; this is part of the work-round for the libpng bug
 3771        * described above.
 3772        *
 3773        * TODO: fix libpng and remove this.
 3774        */
 3775       if (do_local_background != 0)
 3776       {
 3777          png_fixed_point gtest;
 3778 
 3779          /* This is 'png_gamma_threshold' from pngrtran.c; the test used for
 3780           * gamma correction, the screen gamma hasn't been set on png_struct
 3781           * yet; it's set below.  png_struct::gamma, however, is set to the
 3782           * final value.
 3783           */
 3784          if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma,
 3785              PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0)
 3786             do_local_background = 0;
 3787 
 3788          else if (mode == PNG_ALPHA_STANDARD)
 3789          {
 3790             do_local_background = 2/*required*/;
 3791             mode = PNG_ALPHA_PNG; /* prevent libpng doing it */
 3792          }
 3793 
 3794          /* else leave as 1 for the checks below */
 3795       }
 3796 
 3797       /* If the bit-depth changes then handle that here. */
 3798       if ((change & PNG_FORMAT_FLAG_LINEAR) != 0)
 3799       {
 3800          if (linear != 0 /*16-bit output*/)
 3801             png_set_expand_16(png_ptr);
 3802 
 3803          else /* 8-bit output */
 3804             png_set_scale_16(png_ptr);
 3805 
 3806          change &= ~PNG_FORMAT_FLAG_LINEAR;
 3807       }
 3808 
 3809       /* Now the background/alpha channel changes. */
 3810       if ((change & PNG_FORMAT_FLAG_ALPHA) != 0)
 3811       {
 3812          /* Removing an alpha channel requires composition for the 8-bit
 3813           * formats; for the 16-bit it is already done, above, by the
 3814           * pre-multiplication and the channel just needs to be stripped.
 3815           */
 3816          if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3817          {
 3818             /* If RGB->gray is happening the alpha channel must be left and the
 3819              * operation completed locally.
 3820              *
 3821              * TODO: fix libpng and remove this.
 3822              */
 3823             if (do_local_background != 0)
 3824                do_local_background = 2/*required*/;
 3825 
 3826             /* 16-bit output: just remove the channel */
 3827             else if (linear != 0) /* compose on black (well, pre-multiply) */
 3828                png_set_strip_alpha(png_ptr);
 3829 
 3830             /* 8-bit output: do an appropriate compose */
 3831             else if (display->background != NULL)
 3832             {
 3833                png_color_16 c;
 3834 
 3835                c.index = 0; /*unused*/
 3836                c.red = display->background->red;
 3837                c.green = display->background->green;
 3838                c.blue = display->background->blue;
 3839                c.gray = display->background->green;
 3840 
 3841                /* This is always an 8-bit sRGB value, using the 'green' channel
 3842                 * for gray is much better than calculating the luminance here;
 3843                 * we can get off-by-one errors in that calculation relative to
 3844                 * the app expectations and that will show up in transparent
 3845                 * pixels.
 3846                 */
 3847                png_set_background_fixed(png_ptr, &c,
 3848                    PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
 3849                    0/*gamma: not used*/);
 3850             }
 3851 
 3852             else /* compose on row: implemented below. */
 3853             {
 3854                do_local_compose = 1;
 3855                /* This leaves the alpha channel in the output, so it has to be
 3856                 * removed by the code below.  Set the encoding to the 'OPTIMIZE'
 3857                 * one so the code only has to hack on the pixels that require
 3858                 * composition.
 3859                 */
 3860                mode = PNG_ALPHA_OPTIMIZED;
 3861             }
 3862          }
 3863 
 3864          else /* output needs an alpha channel */
 3865          {
 3866             /* This is tricky because it happens before the swap operation has
 3867              * been accomplished; however, the swap does *not* swap the added
 3868              * alpha channel (weird API), so it must be added in the correct
 3869              * place.
 3870              */
 3871             png_uint_32 filler; /* opaque filler */
 3872             int where;
 3873 
 3874             if (linear != 0)
 3875                filler = 65535;
 3876 
 3877             else
 3878                filler = 255;
 3879 
 3880 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 3881             if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
 3882             {
 3883                where = PNG_FILLER_BEFORE;
 3884                change &= ~PNG_FORMAT_FLAG_AFIRST;
 3885             }
 3886 
 3887             else
 3888 #endif
 3889             where = PNG_FILLER_AFTER;
 3890 
 3891             png_set_add_alpha(png_ptr, filler, where);
 3892          }
 3893 
 3894          /* This stops the (irrelevant) call to swap_alpha below. */
 3895          change &= ~PNG_FORMAT_FLAG_ALPHA;
 3896       }
 3897 
 3898       /* Now set the alpha mode correctly; this is always done, even if there is
 3899        * no alpha channel in either the input or the output because it correctly
 3900        * sets the output gamma.
 3901        */
 3902       png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
 3903 
 3904 #     ifdef PNG_FORMAT_BGR_SUPPORTED
 3905          if ((change & PNG_FORMAT_FLAG_BGR) != 0)
 3906          {
 3907             /* Check only the output format; PNG is never BGR; don't do this if
 3908              * the output is gray, but fix up the 'format' value in that case.
 3909              */
 3910             if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
 3911                png_set_bgr(png_ptr);
 3912 
 3913             else
 3914                format &= ~PNG_FORMAT_FLAG_BGR;
 3915 
 3916             change &= ~PNG_FORMAT_FLAG_BGR;
 3917          }
 3918 #     endif
 3919 
 3920 #     ifdef PNG_FORMAT_AFIRST_SUPPORTED
 3921          if ((change & PNG_FORMAT_FLAG_AFIRST) != 0)
 3922          {
 3923             /* Only relevant if there is an alpha channel - it's particularly
 3924              * important to handle this correctly because do_local_compose may
 3925              * be set above and then libpng will keep the alpha channel for this
 3926              * code to remove.
 3927              */
 3928             if ((format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3929             {
 3930                /* Disable this if doing a local background,
 3931                 * TODO: remove this when local background is no longer required.
 3932                 */
 3933                if (do_local_background != 2)
 3934                   png_set_swap_alpha(png_ptr);
 3935             }
 3936 
 3937             else
 3938                format &= ~PNG_FORMAT_FLAG_AFIRST;
 3939 
 3940             change &= ~PNG_FORMAT_FLAG_AFIRST;
 3941          }
 3942 #     endif
 3943 
 3944       /* If the *output* is 16-bit then we need to check for a byte-swap on this
 3945        * architecture.
 3946        */
 3947       if (linear != 0)
 3948       {
 3949          png_uint_16 le = 0x0001;
 3950 
 3951          if ((*(png_const_bytep) & le) != 0)
 3952             png_set_swap(png_ptr);
 3953       }
 3954 
 3955       /* If change is not now 0 some transformation is missing - error out. */
 3956       if (change != 0)
 3957          png_error(png_ptr, "png_read_image: unsupported transformation");
 3958    }
 3959 
 3960    PNG_SKIP_CHUNKS(png_ptr);
 3961 
 3962    /* Update the 'info' structure and make sure the result is as required; first
 3963     * make sure to turn on the interlace handling if it will be required
 3964     * (because it can't be turned on *after* the call to png_read_update_info!)
 3965     *
 3966     * TODO: remove the do_local_background fixup below.
 3967     */
 3968    if (do_local_compose == 0 && do_local_background != 2)
 3969       passes = png_set_interlace_handling(png_ptr);
 3970 
 3971    png_read_update_info(png_ptr, info_ptr);
 3972 
 3973    {
 3974       png_uint_32 info_format = 0;
 3975 
 3976       if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
 3977          info_format |= PNG_FORMAT_FLAG_COLOR;
 3978 
 3979       if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
 3980       {
 3981          /* do_local_compose removes this channel below. */
 3982          if (do_local_compose == 0)
 3983          {
 3984             /* do_local_background does the same if required. */
 3985             if (do_local_background != 2 ||
 3986                (format & PNG_FORMAT_FLAG_ALPHA) != 0)
 3987                info_format |= PNG_FORMAT_FLAG_ALPHA;
 3988          }
 3989       }
 3990 
 3991       else if (do_local_compose != 0) /* internal error */
 3992          png_error(png_ptr, "png_image_read: alpha channel lost");
 3993 
 3994       if ((format & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0) {
 3995          info_format |= PNG_FORMAT_FLAG_ASSOCIATED_ALPHA;
 3996       }
 3997 
 3998       if (info_ptr->bit_depth == 16)
 3999          info_format |= PNG_FORMAT_FLAG_LINEAR;
 4000 
 4001 #ifdef PNG_FORMAT_BGR_SUPPORTED
 4002       if ((png_ptr->transformations & PNG_BGR) != 0)
 4003          info_format |= PNG_FORMAT_FLAG_BGR;
 4004 #endif
 4005 
 4006 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 4007          if (do_local_background == 2)
 4008          {
 4009             if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
 4010                info_format |= PNG_FORMAT_FLAG_AFIRST;
 4011          }
 4012 
 4013          if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 ||
 4014             ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 &&
 4015             (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0))
 4016          {
 4017             if (do_local_background == 2)
 4018                png_error(png_ptr, "unexpected alpha swap transformation");
 4019 
 4020             info_format |= PNG_FORMAT_FLAG_AFIRST;
 4021          }
 4022 #     endif
 4023 
 4024       /* This is actually an internal error. */
 4025       if (info_format != format)
 4026          png_error(png_ptr, "png_read_image: invalid transformations");
 4027    }
 4028 
 4029    /* Now read the rows.  If do_local_compose is set then it is necessary to use
 4030     * a local row buffer.  The output will be GA, RGBA or BGRA and must be
 4031     * converted to G, RGB or BGR as appropriate.  The 'local_row' member of the
 4032     * display acts as a flag.
 4033     */
 4034    {
 4035       png_voidp first_row = display->buffer;
 4036       ptrdiff_t row_bytes = display->row_stride;
 4037 
 4038       if (linear != 0)
 4039          row_bytes *= 2;
 4040 
 4041       /* The following expression is designed to work correctly whether it gives
 4042        * a signed or an unsigned result.
 4043        */
 4044       if (row_bytes < 0)
 4045       {
 4046          char *ptr = png_voidcast(char*, first_row);
 4047          ptr += (image->height-1) * (-row_bytes);
 4048          first_row = png_voidcast(png_voidp, ptr);
 4049       }
 4050 
 4051       display->first_row = first_row;
 4052       display->row_bytes = row_bytes;
 4053    }
 4054 
 4055    if (do_local_compose != 0)
 4056    {
 4057       int result;
 4058       png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
 4059 
 4060       display->local_row = row;
 4061       result = png_safe_execute(image, png_image_read_composite, display);
 4062       display->local_row = NULL;
 4063       png_free(png_ptr, row);
 4064 
 4065       return result;
 4066    }
 4067 
 4068    else if (do_local_background == 2)
 4069    {
 4070       int result;
 4071       png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
 4072 
 4073       display->local_row = row;
 4074       result = png_safe_execute(image, png_image_read_background, display);
 4075       display->local_row = NULL;
 4076       png_free(png_ptr, row);
 4077 
 4078       return result;
 4079    }
 4080 
 4081    else
 4082    {
 4083       png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes;
 4084 
 4085       while (--passes >= 0)
 4086       {
 4087          png_uint_32      y = image->height;
 4088          png_bytep        row = png_voidcast(png_bytep, display->first_row);
 4089 
 4090          for (; y > 0; --y)
 4091          {
 4092             png_read_row(png_ptr, row, NULL);
 4093             row += row_bytes;
 4094          }
 4095       }
 4096 
 4097       return 1;
 4098    }
 4099 }
 4100 
 4101 int PNGAPI
 4102 png_image_finish_read(png_imagep image, png_const_colorp background,
 4103     void *buffer, png_int_32 row_stride, void *colormap)
 4104 {
 4105    if (image != NULL && image->version == PNG_IMAGE_VERSION)
 4106    {
 4107       /* Check for row_stride overflow.  This check is not performed on the
 4108        * original PNG format because it may not occur in the output PNG format
 4109        * and libpng deals with the issues of reading the original.
 4110        */
 4111       unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
 4112 
 4113       /* The following checks just the 'row_stride' calculation to ensure it
 4114        * fits in a signed 32-bit value.  Because channels/components can be
 4115        * either 1 or 2 bytes in size the length of a row can still overflow 32
 4116        * bits; this is just to verify that the 'row_stride' argument can be
 4117        * represented.
 4118        */
 4119       if (image->width <= 0x7fffffffU/channels) /* no overflow */
 4120       {
 4121          png_uint_32 check;
 4122          png_uint_32 png_row_stride = image->width * channels;
 4123 
 4124          if (row_stride == 0)
 4125             row_stride = (png_int_32)/*SAFE*/png_row_stride;
 4126 
 4127          if (row_stride < 0)
 4128             check = (png_uint_32)(-row_stride);
 4129 
 4130          else
 4131             check = (png_uint_32)row_stride;
 4132 
 4133          /* This verifies 'check', the absolute value of the actual stride
 4134           * passed in and detects overflow in the application calculation (i.e.
 4135           * if the app did actually pass in a non-zero 'row_stride'.
 4136           */
 4137          if (image->opaque != NULL && buffer != NULL && check >= png_row_stride)
 4138          {
 4139             /* Now check for overflow of the image buffer calculation; this
 4140              * limits the whole image size to 32 bits for API compatibility with
 4141              * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
 4142              *
 4143              * The PNG_IMAGE_BUFFER_SIZE macro is:
 4144              *
 4145              *    (PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)*height*(row_stride))
 4146              *
 4147              * And the component size is always 1 or 2, so make sure that the
 4148              * number of *bytes* that the application is saying are available
 4149              * does actually fit into a 32-bit number.
 4150              *
 4151              * NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE
 4152              * will be changed to use png_alloc_size_t; bigger images can be
 4153              * accommodated on 64-bit systems.
 4154              */
 4155             if (image->height <=
 4156                 0xffffffffU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check)
 4157             {
 4158                if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 ||
 4159                   (image->colormap_entries > 0 && colormap != NULL))
 4160                {
 4161                   int result;
 4162                   png_image_read_control display;
 4163 
 4164                   memset(&display, 0, (sizeof display));
 4165                   display.image = image;
 4166                   display.buffer = buffer;
 4167                   display.row_stride = row_stride;
 4168                   display.colormap = colormap;
 4169                   display.background = background;
 4170                   display.local_row = NULL;
 4171 
 4172                   /* Choose the correct 'end' routine; for the color-map case
 4173                    * all the setup has already been done.
 4174                    */
 4175                   if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
 4176                      result =
 4177                          png_safe_execute(image,
 4178                              png_image_read_colormap, &display) &&
 4179                              png_safe_execute(image,
 4180                              png_image_read_colormapped, &display);
 4181 
 4182                   else
 4183                      result =
 4184                         png_safe_execute(image,
 4185                             png_image_read_direct, &display);
 4186 
 4187                   png_image_free(image);
 4188                   return result;
 4189                }
 4190 
 4191                else
 4192                   return png_image_error(image,
 4193                       "png_image_finish_read[color-map]: no color-map");
 4194             }
 4195 
 4196             else
 4197                return png_image_error(image,
 4198                    "png_image_finish_read: image too large");
 4199          }
 4200 
 4201          else
 4202             return png_image_error(image,
 4203                 "png_image_finish_read: invalid argument");
 4204       }
 4205 
 4206       else
 4207          return png_image_error(image,
 4208              "png_image_finish_read: row_stride too large");
 4209    }
 4210 
 4211    else if (image != NULL)
 4212       return png_image_error(image,
 4213           "png_image_finish_read: damaged PNG_IMAGE_VERSION");
 4214 
 4215    return 0;
 4216 }
 4217 
 4218 #endif /* SIMPLIFIED_READ */
 4219 #endif /* READ */