Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. /* png.c - location for general purpose libpng functions
  3.  *
  4.  * Last changed in libpng 1.5.1 [February 3, 2011]
  5.  * Copyright (c) 1998-2011 Glenn Randers-Pehrson
  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  7.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  8.  *
  9.  * This code is released under the libpng license.
  10.  * For conditions of distribution and use, see the disclaimer
  11.  * and license in png.h
  12.  */
  13.  
  14. #include "pngpriv.h"
  15.  
  16. /* Generate a compiler error if there is an old png.h in the search path. */
  17. typedef png_libpng_version_1_5_1 Your_png_h_is_not_version_1_5_1;
  18.  
  19. /* Tells libpng that we have already handled the first "num_bytes" bytes
  20.  * of the PNG file signature.  If the PNG data is embedded into another
  21.  * stream we can set num_bytes = 8 so that libpng will not attempt to read
  22.  * or write any of the magic bytes before it starts on the IHDR.
  23.  */
  24.  
  25. #ifdef PNG_READ_SUPPORTED
  26. void PNGAPI
  27. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
  28. {
  29.    png_debug(1, "in png_set_sig_bytes");
  30.  
  31.    if (png_ptr == NULL)
  32.       return;
  33.  
  34.    if (num_bytes > 8)
  35.       png_error(png_ptr, "Too many bytes for PNG signature");
  36.  
  37.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
  38. }
  39.  
  40. /* Checks whether the supplied bytes match the PNG signature.  We allow
  41.  * checking less than the full 8-byte signature so that those apps that
  42.  * already read the first few bytes of a file to determine the file type
  43.  * can simply check the remaining bytes for extra assurance.  Returns
  44.  * an integer less than, equal to, or greater than zero if sig is found,
  45.  * respectively, to be less than, to match, or be greater than the correct
  46.  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
  47.  */
  48. int PNGAPI
  49. png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
  50. {
  51.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  52.  
  53.    if (num_to_check > 8)
  54.       num_to_check = 8;
  55.  
  56.    else if (num_to_check < 1)
  57.       return (-1);
  58.  
  59.    if (start > 7)
  60.       return (-1);
  61.  
  62.    if (start + num_to_check > 8)
  63.       num_to_check = 8 - start;
  64.  
  65.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
  66. }
  67.  
  68. #endif /* PNG_READ_SUPPORTED */
  69.  
  70. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  71. /* Function to allocate memory for zlib */
  72. PNG_FUNCTION(voidpf /* PRIVATE */,
  73. png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
  74. {
  75.    png_voidp ptr;
  76.    png_structp p=(png_structp)png_ptr;
  77.    png_uint_32 save_flags=p->flags;
  78.    png_alloc_size_t num_bytes;
  79.  
  80.    if (png_ptr == NULL)
  81.       return (NULL);
  82.  
  83.    if (items > PNG_UINT_32_MAX/size)
  84.    {
  85.      png_warning (p, "Potential overflow in png_zalloc()");
  86.      return (NULL);
  87.    }
  88.    num_bytes = (png_alloc_size_t)items * size;
  89.  
  90.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  91.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
  92.    p->flags=save_flags;
  93.  
  94.    return ((voidpf)ptr);
  95. }
  96.  
  97. /* Function to free memory for zlib */
  98. void /* PRIVATE */
  99. png_zfree(voidpf png_ptr, voidpf ptr)
  100. {
  101.    png_free((png_structp)png_ptr, (png_voidp)ptr);
  102. }
  103.  
  104. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
  105.  * in case CRC is > 32 bits to leave the top bits 0.
  106.  */
  107. void /* PRIVATE */
  108. png_reset_crc(png_structp png_ptr)
  109. {
  110.    png_ptr->crc = crc32(0, Z_NULL, 0);
  111. }
  112.  
  113. /* Calculate the CRC over a section of data.  We can only pass as
  114.  * much data to this routine as the largest single buffer size.  We
  115.  * also check that this data will actually be used before going to the
  116.  * trouble of calculating it.
  117.  */
  118. void /* PRIVATE */
  119. png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
  120. {
  121.    int need_crc = 1;
  122.  
  123.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
  124.    {
  125.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  126.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  127.          need_crc = 0;
  128.    }
  129.  
  130.    else                                                    /* critical */
  131.    {
  132.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
  133.          need_crc = 0;
  134.    }
  135.  
  136.    if (need_crc)
  137.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
  138. }
  139.  
  140. /* Allocate the memory for an info_struct for the application.  We don't
  141.  * really need the png_ptr, but it could potentially be useful in the
  142.  * future.  This should be used in favour of malloc(png_sizeof(png_info))
  143.  * and png_info_init() so that applications that want to use a shared
  144.  * libpng don't have to be recompiled if png_info changes size.
  145.  */
  146. PNG_FUNCTION(png_infop,PNGAPI
  147. png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED)
  148. {
  149.    png_infop info_ptr;
  150.  
  151.    png_debug(1, "in png_create_info_struct");
  152.  
  153.    if (png_ptr == NULL)
  154.       return (NULL);
  155.  
  156. #ifdef PNG_USER_MEM_SUPPORTED
  157.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
  158.       png_ptr->malloc_fn, png_ptr->mem_ptr);
  159. #else
  160.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  161. #endif
  162.    if (info_ptr != NULL)
  163.       png_info_init_3(&info_ptr, png_sizeof(png_info));
  164.  
  165.    return (info_ptr);
  166. }
  167.  
  168. /* This function frees the memory associated with a single info struct.
  169.  * Normally, one would use either png_destroy_read_struct() or
  170.  * png_destroy_write_struct() to free an info struct, but this may be
  171.  * useful for some applications.
  172.  */
  173. void PNGAPI
  174. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
  175. {
  176.    png_infop info_ptr = NULL;
  177.  
  178.    png_debug(1, "in png_destroy_info_struct");
  179.  
  180.    if (png_ptr == NULL)
  181.       return;
  182.  
  183.    if (info_ptr_ptr != NULL)
  184.       info_ptr = *info_ptr_ptr;
  185.  
  186.    if (info_ptr != NULL)
  187.    {
  188.       png_info_destroy(png_ptr, info_ptr);
  189.  
  190. #ifdef PNG_USER_MEM_SUPPORTED
  191.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
  192.           png_ptr->mem_ptr);
  193. #else
  194.       png_destroy_struct((png_voidp)info_ptr);
  195. #endif
  196.       *info_ptr_ptr = NULL;
  197.    }
  198. }
  199.  
  200. /* Initialize the info structure.  This is now an internal function (0.89)
  201.  * and applications using it are urged to use png_create_info_struct()
  202.  * instead.
  203.  */
  204.  
  205. void PNGAPI
  206. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
  207. {
  208.    png_infop info_ptr = *ptr_ptr;
  209.  
  210.    png_debug(1, "in png_info_init_3");
  211.  
  212.    if (info_ptr == NULL)
  213.       return;
  214.  
  215.    if (png_sizeof(png_info) > png_info_struct_size)
  216.    {
  217.       png_destroy_struct(info_ptr);
  218.       info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  219.       *ptr_ptr = info_ptr;
  220.    }
  221.  
  222.    /* Set everything to 0 */
  223.    png_memset(info_ptr, 0, png_sizeof(png_info));
  224. }
  225.  
  226. void PNGAPI
  227. png_data_freer(png_structp png_ptr, png_infop info_ptr,
  228.    int freer, png_uint_32 mask)
  229. {
  230.    png_debug(1, "in png_data_freer");
  231.  
  232.    if (png_ptr == NULL || info_ptr == NULL)
  233.       return;
  234.  
  235.    if (freer == PNG_DESTROY_WILL_FREE_DATA)
  236.       info_ptr->free_me |= mask;
  237.  
  238.    else if (freer == PNG_USER_WILL_FREE_DATA)
  239.       info_ptr->free_me &= ~mask;
  240.  
  241.    else
  242.       png_warning(png_ptr,
  243.          "Unknown freer parameter in png_data_freer");
  244. }
  245.  
  246. void PNGAPI
  247. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
  248.    int num)
  249. {
  250.    png_debug(1, "in png_free_data");
  251.  
  252.    if (png_ptr == NULL || info_ptr == NULL)
  253.       return;
  254.  
  255. #ifdef PNG_TEXT_SUPPORTED
  256.    /* Free text item num or (if num == -1) all text items */
  257.    if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
  258.    {
  259.       if (num != -1)
  260.       {
  261.          if (info_ptr->text && info_ptr->text[num].key)
  262.          {
  263.             png_free(png_ptr, info_ptr->text[num].key);
  264.             info_ptr->text[num].key = NULL;
  265.          }
  266.       }
  267.  
  268.       else
  269.       {
  270.          int i;
  271.          for (i = 0; i < info_ptr->num_text; i++)
  272.              png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
  273.          png_free(png_ptr, info_ptr->text);
  274.          info_ptr->text = NULL;
  275.          info_ptr->num_text=0;
  276.       }
  277.    }
  278. #endif
  279.  
  280. #ifdef PNG_tRNS_SUPPORTED
  281.    /* Free any tRNS entry */
  282.    if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
  283.    {
  284.       png_free(png_ptr, info_ptr->trans_alpha);
  285.       info_ptr->trans_alpha = NULL;
  286.       info_ptr->valid &= ~PNG_INFO_tRNS;
  287.    }
  288. #endif
  289.  
  290. #ifdef PNG_sCAL_SUPPORTED
  291.    /* Free any sCAL entry */
  292.    if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
  293.    {
  294. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
  295.       png_free(png_ptr, info_ptr->scal_s_width);
  296.       png_free(png_ptr, info_ptr->scal_s_height);
  297.       info_ptr->scal_s_width = NULL;
  298.       info_ptr->scal_s_height = NULL;
  299. #endif
  300.       info_ptr->valid &= ~PNG_INFO_sCAL;
  301.    }
  302. #endif
  303.  
  304. #ifdef PNG_pCAL_SUPPORTED
  305.    /* Free any pCAL entry */
  306.    if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
  307.    {
  308.       png_free(png_ptr, info_ptr->pcal_purpose);
  309.       png_free(png_ptr, info_ptr->pcal_units);
  310.       info_ptr->pcal_purpose = NULL;
  311.       info_ptr->pcal_units = NULL;
  312.       if (info_ptr->pcal_params != NULL)
  313.          {
  314.             int i;
  315.             for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
  316.             {
  317.                png_free(png_ptr, info_ptr->pcal_params[i]);
  318.                info_ptr->pcal_params[i] = NULL;
  319.             }
  320.             png_free(png_ptr, info_ptr->pcal_params);
  321.             info_ptr->pcal_params = NULL;
  322.          }
  323.       info_ptr->valid &= ~PNG_INFO_pCAL;
  324.    }
  325. #endif
  326.  
  327. #ifdef PNG_iCCP_SUPPORTED
  328.    /* Free any iCCP entry */
  329.    if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
  330.    {
  331.       png_free(png_ptr, info_ptr->iccp_name);
  332.       png_free(png_ptr, info_ptr->iccp_profile);
  333.       info_ptr->iccp_name = NULL;
  334.       info_ptr->iccp_profile = NULL;
  335.       info_ptr->valid &= ~PNG_INFO_iCCP;
  336.    }
  337. #endif
  338.  
  339. #ifdef PNG_sPLT_SUPPORTED
  340.    /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
  341.    if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
  342.    {
  343.       if (num != -1)
  344.       {
  345.          if (info_ptr->splt_palettes)
  346.          {
  347.             png_free(png_ptr, info_ptr->splt_palettes[num].name);
  348.             png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  349.             info_ptr->splt_palettes[num].name = NULL;
  350.             info_ptr->splt_palettes[num].entries = NULL;
  351.          }
  352.       }
  353.  
  354.       else
  355.       {
  356.          if (info_ptr->splt_palettes_num)
  357.          {
  358.             int i;
  359.             for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  360.                png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
  361.  
  362.             png_free(png_ptr, info_ptr->splt_palettes);
  363.             info_ptr->splt_palettes = NULL;
  364.             info_ptr->splt_palettes_num = 0;
  365.          }
  366.          info_ptr->valid &= ~PNG_INFO_sPLT;
  367.       }
  368.    }
  369. #endif
  370.  
  371. #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
  372.    if (png_ptr->unknown_chunk.data)
  373.    {
  374.       png_free(png_ptr, png_ptr->unknown_chunk.data);
  375.       png_ptr->unknown_chunk.data = NULL;
  376.    }
  377.  
  378.    if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
  379.    {
  380.       if (num != -1)
  381.       {
  382.           if (info_ptr->unknown_chunks)
  383.           {
  384.              png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  385.              info_ptr->unknown_chunks[num].data = NULL;
  386.           }
  387.       }
  388.  
  389.       else
  390.       {
  391.          int i;
  392.  
  393.          if (info_ptr->unknown_chunks_num)
  394.          {
  395.             for (i = 0; i < info_ptr->unknown_chunks_num; i++)
  396.                png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
  397.  
  398.             png_free(png_ptr, info_ptr->unknown_chunks);
  399.             info_ptr->unknown_chunks = NULL;
  400.             info_ptr->unknown_chunks_num = 0;
  401.          }
  402.       }
  403.    }
  404. #endif
  405.  
  406. #ifdef PNG_hIST_SUPPORTED
  407.    /* Free any hIST entry */
  408.    if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
  409.    {
  410.       png_free(png_ptr, info_ptr->hist);
  411.       info_ptr->hist = NULL;
  412.       info_ptr->valid &= ~PNG_INFO_hIST;
  413.    }
  414. #endif
  415.  
  416.    /* Free any PLTE entry that was internally allocated */
  417.    if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
  418.    {
  419.       png_zfree(png_ptr, info_ptr->palette);
  420.       info_ptr->palette = NULL;
  421.       info_ptr->valid &= ~PNG_INFO_PLTE;
  422.       info_ptr->num_palette = 0;
  423.    }
  424.  
  425. #ifdef PNG_INFO_IMAGE_SUPPORTED
  426.    /* Free any image bits attached to the info structure */
  427.    if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
  428.    {
  429.       if (info_ptr->row_pointers)
  430.       {
  431.          int row;
  432.          for (row = 0; row < (int)info_ptr->height; row++)
  433.          {
  434.             png_free(png_ptr, info_ptr->row_pointers[row]);
  435.             info_ptr->row_pointers[row] = NULL;
  436.          }
  437.          png_free(png_ptr, info_ptr->row_pointers);
  438.          info_ptr->row_pointers = NULL;
  439.       }
  440.       info_ptr->valid &= ~PNG_INFO_IDAT;
  441.    }
  442. #endif
  443.  
  444.    if (num != -1)
  445.       mask &= ~PNG_FREE_MUL;
  446.  
  447.    info_ptr->free_me &= ~mask;
  448. }
  449.  
  450. /* This is an internal routine to free any memory that the info struct is
  451.  * pointing to before re-using it or freeing the struct itself.  Recall
  452.  * that png_free() checks for NULL pointers for us.
  453.  */
  454. void /* PRIVATE */
  455. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
  456. {
  457.    png_debug(1, "in png_info_destroy");
  458.  
  459.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  460.  
  461. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  462.    if (png_ptr->num_chunk_list)
  463.    {
  464.       png_free(png_ptr, png_ptr->chunk_list);
  465.       png_ptr->chunk_list = NULL;
  466.       png_ptr->num_chunk_list = 0;
  467.    }
  468. #endif
  469.  
  470.    png_info_init_3(&info_ptr, png_sizeof(png_info));
  471. }
  472. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  473.  
  474. /* This function returns a pointer to the io_ptr associated with the user
  475.  * functions.  The application should free any memory associated with this
  476.  * pointer before png_write_destroy() or png_read_destroy() are called.
  477.  */
  478. png_voidp PNGAPI
  479. png_get_io_ptr(png_structp png_ptr)
  480. {
  481.    if (png_ptr == NULL)
  482.       return (NULL);
  483.  
  484.    return (png_ptr->io_ptr);
  485. }
  486.  
  487. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  488. #  ifdef PNG_STDIO_SUPPORTED
  489. /* Initialize the default input/output functions for the PNG file.  If you
  490.  * use your own read or write routines, you can call either png_set_read_fn()
  491.  * or png_set_write_fn() instead of png_init_io().  If you have defined
  492.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
  493.  * necessarily available.
  494.  */
  495. void PNGAPI
  496. png_init_io(png_structp png_ptr, png_FILE_p fp)
  497. {
  498.    png_debug(1, "in png_init_io");
  499.  
  500.    if (png_ptr == NULL)
  501.       return;
  502.  
  503.    png_ptr->io_ptr = (png_voidp)fp;
  504. }
  505. #  endif
  506.  
  507. #  ifdef PNG_TIME_RFC1123_SUPPORTED
  508. /* Convert the supplied time into an RFC 1123 string suitable for use in
  509.  * a "Creation Time" or other text-based time string.
  510.  */
  511. png_const_charp PNGAPI
  512. png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime)
  513. {
  514.    static PNG_CONST char short_months[12][4] =
  515.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  516.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  517.  
  518.    if (png_ptr == NULL)
  519.       return (NULL);
  520.  
  521.    if (png_ptr->time_buffer == NULL)
  522.    {
  523.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
  524.          png_sizeof(char)));
  525.    }
  526.  
  527. #    ifdef USE_FAR_KEYWORD
  528.    {
  529.       char near_time_buf[29];
  530.       png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
  531.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  532.           ptime->year, ptime->hour % 24, ptime->minute % 60,
  533.           ptime->second % 61);
  534.       png_memcpy(png_ptr->time_buffer, near_time_buf,
  535.           29*png_sizeof(char));
  536.    }
  537. #    else
  538.    png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
  539.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
  540.        ptime->year, ptime->hour % 24, ptime->minute % 60,
  541.        ptime->second % 61);
  542. #    endif
  543.    return png_ptr->time_buffer;
  544. }
  545. #  endif /* PNG_TIME_RFC1123_SUPPORTED */
  546.  
  547. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  548.  
  549. png_const_charp PNGAPI
  550. png_get_copyright(png_const_structp png_ptr)
  551. {
  552.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
  553. #ifdef PNG_STRING_COPYRIGHT
  554.    return PNG_STRING_COPYRIGHT
  555. #else
  556. #  ifdef __STDC__
  557.    return PNG_STRING_NEWLINE \
  558.      "libpng version 1.5.1 - February 3, 2011" PNG_STRING_NEWLINE \
  559.      "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
  560.      "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
  561.      "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
  562.      PNG_STRING_NEWLINE;
  563. #  else
  564.       return "libpng version 1.5.1 - February 3, 2011\
  565.      Copyright (c) 1998-2011 Glenn Randers-Pehrson\
  566.      Copyright (c) 1996-1997 Andreas Dilger\
  567.      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
  568. #  endif
  569. #endif
  570. }
  571.  
  572. /* The following return the library version as a short string in the
  573.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
  574.  * used with your application, print out PNG_LIBPNG_VER_STRING, which
  575.  * is defined in png.h.
  576.  * Note: now there is no difference between png_get_libpng_ver() and
  577.  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
  578.  * it is guaranteed that png.c uses the correct version of png.h.
  579.  */
  580. png_const_charp PNGAPI
  581. png_get_libpng_ver(png_const_structp png_ptr)
  582. {
  583.    /* Version of *.c files used when building libpng */
  584.    return png_get_header_ver(png_ptr);
  585. }
  586.  
  587. png_const_charp PNGAPI
  588. png_get_header_ver(png_const_structp png_ptr)
  589. {
  590.    /* Version of *.h files used when building libpng */
  591.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
  592.    return PNG_LIBPNG_VER_STRING;
  593. }
  594.  
  595. png_const_charp PNGAPI
  596. png_get_header_version(png_const_structp png_ptr)
  597. {
  598.    /* Returns longer string containing both version and date */
  599.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
  600. #ifdef __STDC__
  601.    return PNG_HEADER_VERSION_STRING
  602. #  ifndef PNG_READ_SUPPORTED
  603.    "     (NO READ SUPPORT)"
  604. #  endif
  605.    PNG_STRING_NEWLINE;
  606. #else
  607.    return PNG_HEADER_VERSION_STRING;
  608. #endif
  609. }
  610.  
  611. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  612. #  ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  613. int PNGAPI
  614. png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
  615. {
  616.    /* Check chunk_name and return "keep" value if it's on the list, else 0 */
  617.    int i;
  618.    png_bytep p;
  619.    if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
  620.       return 0;
  621.  
  622.    p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
  623.    for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
  624.       if (!png_memcmp(chunk_name, p, 4))
  625.         return ((int)*(p + 4));
  626.    return 0;
  627. }
  628. #  endif
  629. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  630.  
  631. #ifdef PNG_READ_SUPPORTED
  632. /* This function, added to libpng-1.0.6g, is untested. */
  633. int PNGAPI
  634. png_reset_zstream(png_structp png_ptr)
  635. {
  636.    if (png_ptr == NULL)
  637.       return Z_STREAM_ERROR;
  638.  
  639.    return (inflateReset(&png_ptr->zstream));
  640. }
  641. #endif /* PNG_READ_SUPPORTED */
  642.  
  643. /* This function was added to libpng-1.0.7 */
  644. png_uint_32 PNGAPI
  645. png_access_version_number(void)
  646. {
  647.    /* Version of *.c files used when building libpng */
  648.    return((png_uint_32)PNG_LIBPNG_VER);
  649. }
  650.  
  651.  
  652.  
  653. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  654. #  ifdef PNG_SIZE_T
  655. /* Added at libpng version 1.2.6 */
  656.    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
  657. png_size_t PNGAPI
  658. png_convert_size(size_t size)
  659. {
  660.    if (size > (png_size_t)-1)
  661.       PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
  662.  
  663.    return ((png_size_t)size);
  664. }
  665. #  endif /* PNG_SIZE_T */
  666.  
  667. /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
  668. #  ifdef PNG_CHECK_cHRM_SUPPORTED
  669.  
  670. int /* PRIVATE */
  671. png_check_cHRM_fixed(png_structp png_ptr,
  672.    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
  673.    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
  674.    png_fixed_point blue_x, png_fixed_point blue_y)
  675. {
  676.    int ret = 1;
  677.    unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
  678.  
  679.    png_debug(1, "in function png_check_cHRM_fixed");
  680.  
  681.    if (png_ptr == NULL)
  682.       return 0;
  683.  
  684.    if (white_x < 0 || white_y <= 0 ||
  685.          red_x < 0 ||   red_y <  0 ||
  686.        green_x < 0 || green_y <  0 ||
  687.         blue_x < 0 ||  blue_y <  0)
  688.    {
  689.       png_warning(png_ptr,
  690.         "Ignoring attempt to set negative chromaticity value");
  691.       ret = 0;
  692.    }
  693.    if (white_x > (png_fixed_point)PNG_UINT_31_MAX ||
  694.        white_y > (png_fixed_point)PNG_UINT_31_MAX ||
  695.          red_x > (png_fixed_point)PNG_UINT_31_MAX ||
  696.          red_y > (png_fixed_point)PNG_UINT_31_MAX ||
  697.        green_x > (png_fixed_point)PNG_UINT_31_MAX ||
  698.        green_y > (png_fixed_point)PNG_UINT_31_MAX ||
  699.         blue_x > (png_fixed_point)PNG_UINT_31_MAX ||
  700.         blue_y > (png_fixed_point)PNG_UINT_31_MAX )
  701.    {
  702.       png_warning(png_ptr,
  703.         "Ignoring attempt to set chromaticity value exceeding 21474.83");
  704.       ret = 0;
  705.    }
  706.    if (white_x > 100000L - white_y)
  707.    {
  708.       png_warning(png_ptr, "Invalid cHRM white point");
  709.       ret = 0;
  710.    }
  711.  
  712.    if (red_x > 100000L - red_y)
  713.    {
  714.       png_warning(png_ptr, "Invalid cHRM red point");
  715.       ret = 0;
  716.    }
  717.  
  718.    if (green_x > 100000L - green_y)
  719.    {
  720.       png_warning(png_ptr, "Invalid cHRM green point");
  721.       ret = 0;
  722.    }
  723.  
  724.    if (blue_x > 100000L - blue_y)
  725.    {
  726.       png_warning(png_ptr, "Invalid cHRM blue point");
  727.       ret = 0;
  728.    }
  729.  
  730.    png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
  731.    png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
  732.  
  733.    if (xy_hi == yx_hi && xy_lo == yx_lo)
  734.    {
  735.       png_warning(png_ptr,
  736.          "Ignoring attempt to set cHRM RGB triangle with zero area");
  737.       ret = 0;
  738.    }
  739.  
  740.    return ret;
  741. }
  742. #  endif /* PNG_CHECK_cHRM_SUPPORTED */
  743.  
  744. void /* PRIVATE */
  745. png_check_IHDR(png_structp png_ptr,
  746.    png_uint_32 width, png_uint_32 height, int bit_depth,
  747.    int color_type, int interlace_type, int compression_type,
  748.    int filter_type)
  749. {
  750.    int error = 0;
  751.  
  752.    /* Check for width and height valid values */
  753.    if (width == 0)
  754.    {
  755.       png_warning(png_ptr, "Image width is zero in IHDR");
  756.       error = 1;
  757.    }
  758.  
  759.    if (height == 0)
  760.    {
  761.       png_warning(png_ptr, "Image height is zero in IHDR");
  762.       error = 1;
  763.    }
  764.  
  765. #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
  766.    if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX)
  767.  
  768. #  else
  769.    if (width > PNG_USER_WIDTH_MAX)
  770. #  endif
  771.    {
  772.       png_warning(png_ptr, "Image width exceeds user limit in IHDR");
  773.       error = 1;
  774.    }
  775.  
  776. #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
  777.    if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX)
  778. #  else
  779.    if (height > PNG_USER_HEIGHT_MAX)
  780. #  endif
  781.    {
  782.       png_warning(png_ptr, "Image height exceeds user limit in IHDR");
  783.       error = 1;
  784.    }
  785.  
  786.    if (width > PNG_UINT_31_MAX)
  787.    {
  788.       png_warning(png_ptr, "Invalid image width in IHDR");
  789.       error = 1;
  790.    }
  791.  
  792.    if (height > PNG_UINT_31_MAX)
  793.    {
  794.       png_warning(png_ptr, "Invalid image height in IHDR");
  795.       error = 1;
  796.    }
  797.  
  798.    if (width > (PNG_UINT_32_MAX
  799.                  >> 3)      /* 8-byte RGBA pixels */
  800.                  - 48       /* bigrowbuf hack */
  801.                  - 1        /* filter byte */
  802.                  - 7*8      /* rounding of width to multiple of 8 pixels */
  803.                  - 8)       /* extra max_pixel_depth pad */
  804.       png_warning(png_ptr, "Width is too large for libpng to process pixels");
  805.  
  806.    /* Check other values */
  807.    if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
  808.        bit_depth != 8 && bit_depth != 16)
  809.    {
  810.       png_warning(png_ptr, "Invalid bit depth in IHDR");
  811.       error = 1;
  812.    }
  813.  
  814.    if (color_type < 0 || color_type == 1 ||
  815.        color_type == 5 || color_type > 6)
  816.    {
  817.       png_warning(png_ptr, "Invalid color type in IHDR");
  818.       error = 1;
  819.    }
  820.  
  821.    if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
  822.        ((color_type == PNG_COLOR_TYPE_RGB ||
  823.          color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
  824.          color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
  825.    {
  826.       png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
  827.       error = 1;
  828.    }
  829.  
  830.    if (interlace_type >= PNG_INTERLACE_LAST)
  831.    {
  832.       png_warning(png_ptr, "Unknown interlace method in IHDR");
  833.       error = 1;
  834.    }
  835.  
  836.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  837.    {
  838.       png_warning(png_ptr, "Unknown compression method in IHDR");
  839.       error = 1;
  840.    }
  841.  
  842. #  ifdef PNG_MNG_FEATURES_SUPPORTED
  843.    /* Accept filter_method 64 (intrapixel differencing) only if
  844.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  845.     * 2. Libpng did not read a PNG signature (this filter_method is only
  846.     *    used in PNG datastreams that are embedded in MNG datastreams) and
  847.     * 3. The application called png_permit_mng_features with a mask that
  848.     *    included PNG_FLAG_MNG_FILTER_64 and
  849.     * 4. The filter_method is 64 and
  850.     * 5. The color_type is RGB or RGBA
  851.     */
  852.    if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
  853.        png_ptr->mng_features_permitted)
  854.       png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
  855.  
  856.    if (filter_type != PNG_FILTER_TYPE_BASE)
  857.    {
  858.       if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  859.           (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
  860.           ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
  861.           (color_type == PNG_COLOR_TYPE_RGB ||
  862.           color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
  863.       {
  864.          png_warning(png_ptr, "Unknown filter method in IHDR");
  865.          error = 1;
  866.       }
  867.  
  868.       if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
  869.       {
  870.          png_warning(png_ptr, "Invalid filter method in IHDR");
  871.          error = 1;
  872.       }
  873.    }
  874.  
  875. #  else
  876.    if (filter_type != PNG_FILTER_TYPE_BASE)
  877.    {
  878.       png_warning(png_ptr, "Unknown filter method in IHDR");
  879.       error = 1;
  880.    }
  881. #  endif
  882.  
  883.    if (error == 1)
  884.       png_error(png_ptr, "Invalid IHDR data");
  885. }
  886.  
  887. #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
  888. /* ASCII to fp functions */
  889. /* Check an ASCII formated floating point value, see the more detailed
  890.  * comments in pngpriv.h
  891.  */
  892. /* The following is used internally to preserve the 'valid' flag */
  893. #define png_fp_add(state, flags) ((state) |= (flags))
  894. #define png_fp_set(state, value)\
  895.    ((state) = (value) | ((state) & PNG_FP_WAS_VALID))
  896.  
  897. /* Internal type codes: bits above the base state! */
  898. #define PNG_FP_SIGN   0  /* [+-] */
  899. #define PNG_FP_DOT    4  /* . */
  900. #define PNG_FP_DIGIT  8  /* [0123456789] */
  901. #define PNG_FP_E     12  /* [Ee] */
  902.  
  903. int /* PRIVATE */
  904. png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
  905.    png_size_tp whereami)
  906. {
  907.    int state = *statep;
  908.    png_size_t i = *whereami;
  909.  
  910.    while (i < size)
  911.    {
  912.       int type;
  913.       /* First find the type of the next character */
  914.       {
  915.          char ch = string[i];
  916.  
  917.          if (ch >= 48 && ch <= 57)
  918.             type = PNG_FP_DIGIT;
  919.  
  920.          else switch (ch)
  921.          {
  922.          case 43: case 45:  type = PNG_FP_SIGN;  break;
  923.          case 46:           type = PNG_FP_DOT;   break;
  924.          case 69: case 101: type = PNG_FP_E;     break;
  925.          default:           goto PNG_FP_End;
  926.          }
  927.       }
  928.  
  929.       /* Now deal with this type according to the current
  930.        * state, the type is arranged to not overlap the
  931.        * bits of the PNG_FP_STATE.
  932.        */
  933.       switch ((state & PNG_FP_STATE) + type)
  934.       {
  935.       case PNG_FP_INTEGER + PNG_FP_SIGN:
  936.          if (state & PNG_FP_SAW_ANY)
  937.             goto PNG_FP_End; /* not a part of the number */
  938.  
  939.          png_fp_add(state, PNG_FP_SAW_SIGN);
  940.          break;
  941.  
  942.       case PNG_FP_INTEGER + PNG_FP_DOT:
  943.          /* Ok as trailer, ok as lead of fraction. */
  944.          if (state & PNG_FP_SAW_DOT) /* two dots */
  945.             goto PNG_FP_End;
  946.  
  947.          else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */
  948.             png_fp_add(state, PNG_FP_SAW_DOT);
  949.  
  950.          else
  951.             png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
  952.  
  953.          break;
  954.  
  955.       case PNG_FP_INTEGER + PNG_FP_DIGIT:
  956.          if (state & PNG_FP_SAW_DOT) /* delayed fraction */
  957.             png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
  958.  
  959.          png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
  960.  
  961.          break;
  962.       case PNG_FP_INTEGER + PNG_FP_E:
  963.          if ((state & PNG_FP_SAW_DIGIT) == 0)
  964.             goto PNG_FP_End;
  965.  
  966.          png_fp_set(state, PNG_FP_EXPONENT);
  967.  
  968.          break;
  969.  
  970.    /* case PNG_FP_FRACTION + PNG_FP_SIGN:
  971.          goto PNG_FP_End; ** no sign in exponent */
  972.  
  973.    /* case PNG_FP_FRACTION + PNG_FP_DOT:
  974.          goto PNG_FP_End; ** Because SAW_DOT is always set */
  975.  
  976.       case PNG_FP_FRACTION + PNG_FP_DIGIT:
  977.          png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
  978.          break;
  979.  
  980.       case PNG_FP_FRACTION + PNG_FP_E:
  981.          /* This is correct because the trailing '.' on an
  982.           * integer is handled above - so we can only get here
  983.           * with the sequence ".E" (with no preceding digits).
  984.           */
  985.          if ((state & PNG_FP_SAW_DIGIT) == 0)
  986.             goto PNG_FP_End;
  987.  
  988.          png_fp_set(state, PNG_FP_EXPONENT);
  989.  
  990.          break;
  991.  
  992.       case PNG_FP_EXPONENT + PNG_FP_SIGN:
  993.          if (state & PNG_FP_SAW_ANY)
  994.             goto PNG_FP_End; /* not a part of the number */
  995.  
  996.          png_fp_add(state, PNG_FP_SAW_SIGN);
  997.  
  998.          break;
  999.  
  1000.    /* case PNG_FP_EXPONENT + PNG_FP_DOT:
  1001.          goto PNG_FP_End; */
  1002.  
  1003.       case PNG_FP_EXPONENT + PNG_FP_DIGIT:
  1004.          png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID);
  1005.  
  1006.          break;
  1007.  
  1008.    /* case PNG_FP_EXPONEXT + PNG_FP_E:
  1009.          goto PNG_FP_End; */
  1010.  
  1011.       default: goto PNG_FP_End; /* I.e. break 2 */
  1012.       }
  1013.  
  1014.       /* The character seems ok, continue. */
  1015.       ++i;
  1016.    }
  1017.  
  1018. PNG_FP_End:
  1019.    /* Here at the end, update the state and return the correct
  1020.     * return code.
  1021.     */
  1022.    *statep = state;
  1023.    *whereami = i;
  1024.  
  1025.    return (state & PNG_FP_SAW_DIGIT) != 0;
  1026. }
  1027.  
  1028.  
  1029. /* The same but for a complete string. */
  1030. int
  1031. png_check_fp_string(png_const_charp string, png_size_t size)
  1032. {
  1033.    int        state=0;
  1034.    png_size_t char_index=0;
  1035.  
  1036.    return png_check_fp_number(string, size, &state, &char_index) &&
  1037.       (char_index == size || string[char_index] == 0);
  1038. }
  1039. #endif /* pCAL or sCAL */
  1040.  
  1041. #ifdef PNG_READ_sCAL_SUPPORTED
  1042. #  ifdef PNG_FLOATING_POINT_SUPPORTED
  1043. /* Utility used below - a simple accurate power of ten from an integral
  1044.  * exponent.
  1045.  */
  1046. static double
  1047. png_pow10(int power)
  1048. {
  1049.    int recip = 0;
  1050.    double d = 1;
  1051.  
  1052.    /* Handle negative exponent with a reciprocal at the end because
  1053.     * 10 is exact whereas .1 is inexact in base 2
  1054.     */
  1055.    if (power < 0)
  1056.    {
  1057.       if (power < DBL_MIN_10_EXP) return 0;
  1058.       recip = 1, power = -power;
  1059.    }
  1060.  
  1061.    if (power > 0)
  1062.    {
  1063.       /* Decompose power bitwise. */
  1064.       double mult = 10;
  1065.       do
  1066.       {
  1067.          if (power & 1) d *= mult;
  1068.          mult *= mult;
  1069.          power >>= 1;
  1070.       }
  1071.       while (power > 0);
  1072.  
  1073.       if (recip) d = 1/d;
  1074.    }
  1075.    /* else power is 0 and d is 1 */
  1076.  
  1077.    return d;
  1078. }
  1079.  
  1080. /* Function to format a floating point value in ASCII with a given
  1081.  * precision.
  1082.  */
  1083. void /* PRIVATE */
  1084. png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
  1085.     double fp, unsigned int precision)
  1086. {
  1087.    /* We use standard functions from math.h, but not printf because
  1088.     * that would require stdio.  The caller must supply a buffer of
  1089.     * sufficient size or we will png_error.  The tests on size and
  1090.     * the space in ascii[] consumed are indicated below.
  1091.     */
  1092.    if (precision < 1)
  1093.       precision = DBL_DIG;
  1094.  
  1095.    /* Enforce the limit of the implementation precision too. */
  1096.    if (precision > DBL_DIG+1)
  1097.       precision = DBL_DIG+1;
  1098.  
  1099.    /* Basic sanity checks */
  1100.    if (size >= precision+5) /* See the requirements below. */
  1101.    {
  1102.       if (fp < 0)
  1103.       {
  1104.          fp = -fp;
  1105.          *ascii++ = 45; /* '-'  PLUS 1 TOTAL 1*/
  1106.          --size;
  1107.       }
  1108.  
  1109.       if (fp >= DBL_MIN && fp <= DBL_MAX)
  1110.       {
  1111.          int exp_b10;       /* A base 10 exponent */
  1112.          double base;   /* 10^exp_b10 */
  1113.  
  1114.          /* First extract a base 10 exponent of the number,
  1115.           * the calculation below rounds down when converting
  1116.           * from base 2 to base 10 (multiply by log10(2) -
  1117.           * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
  1118.           * be increased.  Note that the arithmetic shift
  1119.           * performs a floor() unlike C arithmetic - using a
  1120.           * C multiply would break the following for negative
  1121.           * exponents.
  1122.           */
  1123.          (void)frexp(fp, &exp_b10); /* exponent to base 2 */
  1124.  
  1125.          exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
  1126.  
  1127.          /* Avoid underflow here. */
  1128.          base = png_pow10(exp_b10); /* May underflow */
  1129.  
  1130.          while (base < DBL_MIN || base < fp)
  1131.          {
  1132.             /* And this may overflow. */
  1133.             double test = png_pow10(exp_b10+1);
  1134.  
  1135.             if (test <= DBL_MAX)
  1136.                ++exp_b10, base = test;
  1137.  
  1138.             else
  1139.                break;
  1140.          }
  1141.  
  1142.          /* Normalize fp and correct exp_b10, after this fp is in the
  1143.           * range [.1,1) and exp_b10 is both the exponent and the digit
  1144.           * *before* which the decimal point should be inserted
  1145.           * (starting with 0 for the first digit).  Note that this
  1146.           * works even if 10^exp_b10 is out of range because of the
  1147.           * test on DBL_MAX above.
  1148.           */
  1149.          fp /= base;
  1150.          while (fp >= 1) fp /= 10, ++exp_b10;
  1151.  
  1152.          /* Because of the code above fp may, at this point, be
  1153.           * less than .1, this is ok because the code below can
  1154.           * handle the leading zeros this generates, so no attempt
  1155.           * is made to correct that here.
  1156.           */
  1157.  
  1158.          {
  1159.             int czero, clead, cdigits;
  1160.             char exponent[10];
  1161.  
  1162.             /* Allow up to two leading zeros - this will not lengthen
  1163.              * the number compared to using E-n.
  1164.              */
  1165.             if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
  1166.             {
  1167.                czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
  1168.                exp_b10 = 0;      /* Dot added below before first output. */
  1169.             }
  1170.             else
  1171.                czero = 0;    /* No zeros to add */
  1172.  
  1173.             /* Generate the digit list, stripping trailing zeros and
  1174.              * inserting a '.' before a digit if the exponent is 0.
  1175.              */
  1176.             clead = czero; /* Count of leading zeros */
  1177.             cdigits = 0;   /* Count of digits in list. */
  1178.  
  1179.             do
  1180.             {
  1181.                double d;
  1182.  
  1183.                fp *= 10;
  1184.                /* Use modf here, not floor and subtract, so that
  1185.                 * the separation is done in one step.  At the end
  1186.                 * of the loop don't break the number into parts so
  1187.                 * that the final digit is rounded.
  1188.                 */
  1189.                if (cdigits+czero-clead+1 < (int)precision)
  1190.                   fp = modf(fp, &d);
  1191.  
  1192.                else
  1193.                {
  1194.                   d = floor(fp + .5);
  1195.  
  1196.                   if (d > 9)
  1197.                   {
  1198.                      /* Rounding up to 10, handle that here. */
  1199.                      if (czero > 0)
  1200.                      {
  1201.                         --czero, d = 1;
  1202.                         if (cdigits == 0) --clead;
  1203.                      }
  1204.                      else
  1205.                      {
  1206.                         while (cdigits > 0 && d > 9)
  1207.                         {
  1208.                            int ch = *--ascii;
  1209.  
  1210.                            if (exp_b10 != (-1))
  1211.                               ++exp_b10;
  1212.  
  1213.                            else if (ch == 46)
  1214.                            {
  1215.                               ch = *--ascii, ++size;
  1216.                               /* Advance exp_b10 to '1', so that the
  1217.                                * decimal point happens after the
  1218.                                * previous digit.
  1219.                                */
  1220.                               exp_b10 = 1;
  1221.                            }
  1222.  
  1223.                            --cdigits;
  1224.                            d = ch - 47;  /* I.e. 1+(ch-48) */
  1225.                         }
  1226.  
  1227.                         /* Did we reach the beginning? If so adjust the
  1228.                          * exponent but take into account the leading
  1229.                          * decimal point.
  1230.                          */
  1231.                         if (d > 9)  /* cdigits == 0 */
  1232.                         {
  1233.                            if (exp_b10 == (-1))
  1234.                            {
  1235.                               /* Leading decimal point (plus zeros?), if
  1236.                                * we lose the decimal point here it must
  1237.                                * be reentered below.
  1238.                                */
  1239.                               int ch = *--ascii;
  1240.  
  1241.                               if (ch == 46)
  1242.                                  ++size, exp_b10 = 1;
  1243.  
  1244.                               /* Else lost a leading zero, so 'exp_b10' is
  1245.                                * still ok at (-1)
  1246.                                */
  1247.                            }
  1248.                            else
  1249.                               ++exp_b10;
  1250.  
  1251.                            /* In all cases we output a '1' */
  1252.                            d = 1;
  1253.                         }
  1254.                      }
  1255.                   }
  1256.                   fp = 0; /* Guarantees termination below. */
  1257.                }
  1258.  
  1259.                if (d == 0)
  1260.                {
  1261.                   ++czero;
  1262.                   if (cdigits == 0) ++clead;
  1263.                }
  1264.                else
  1265.                {
  1266.                   /* Included embedded zeros in the digit count. */
  1267.                   cdigits += czero - clead;
  1268.                   clead = 0;
  1269.  
  1270.                   while (czero > 0)
  1271.                   {
  1272.                      /* exp_b10 == (-1) means we just output the decimal
  1273.                       * place - after the DP don't adjust 'exp_b10' any
  1274.                       * more!
  1275.                       */
  1276.                      if (exp_b10 != (-1))
  1277.                      {
  1278.                         if (exp_b10 == 0) *ascii++ = 46, --size;
  1279.                         /* PLUS 1: TOTAL 4 */
  1280.                         --exp_b10;
  1281.                      }
  1282.                      *ascii++ = 48, --czero;
  1283.                   }
  1284.  
  1285.                   if (exp_b10 != (-1))
  1286.                   {
  1287.                      if (exp_b10 == 0) *ascii++ = 46, --size; /* counted
  1288.                                                                  above */
  1289.                      --exp_b10;
  1290.                   }
  1291.                   *ascii++ = (char)(48 + (int)d), ++cdigits;
  1292.                }
  1293.             }
  1294.             while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);
  1295.  
  1296.             /* The total output count (max) is now 4+precision */
  1297.  
  1298.             /* Check for an exponent, if we don't need one we are
  1299.              * done and just need to terminate the string.  At
  1300.              * this point exp_b10==(-1) is effectively if flag - it got
  1301.              * to '-1' because of the decrement after outputing
  1302.              * the decimal point above (the exponent required is
  1303.              * *not* -1!)
  1304.              */
  1305.             if (exp_b10 >= (-1) && exp_b10 <= 2)
  1306.             {
  1307.                /* The following only happens if we didn't output the
  1308.                 * leading zeros above for negative exponent, so this
  1309.                 * doest add to the digit requirement.  Note that the
  1310.                 * two zeros here can only be output if the two leading
  1311.                 * zeros were *not* output, so this doesn't increase
  1312.                 * the output count.
  1313.                 */
  1314.                while (--exp_b10 >= 0) *ascii++ = 48;
  1315.  
  1316.                *ascii = 0;
  1317.  
  1318.                /* Total buffer requirement (including the '\0') is
  1319.                 * 5+precision - see check at the start.
  1320.                 */
  1321.                return;
  1322.             }
  1323.  
  1324.             /* Here if an exponent is required, adjust size for
  1325.              * the digits we output but did not count.  The total
  1326.              * digit output here so far is at most 1+precision - no
  1327.              * decimal point and no leading or trailing zeros have
  1328.              * been output.
  1329.              */
  1330.             size -= cdigits;
  1331.  
  1332.             *ascii++ = 69, --size;    /* 'E': PLUS 1 TOTAL 2+precision*/
  1333.             if (exp_b10 < 0)
  1334.             {
  1335.                *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
  1336.                exp_b10 = -exp_b10;
  1337.             }
  1338.  
  1339.             cdigits = 0;
  1340.  
  1341.             while (exp_b10 > 0)
  1342.             {
  1343.                exponent[cdigits++] = (char)(48 + exp_b10 % 10);
  1344.                exp_b10 /= 10;
  1345.             }
  1346.  
  1347.             /* Need another size check here for the exponent digits, so
  1348.              * this need not be considered above.
  1349.              */
  1350.             if ((int)size > cdigits)
  1351.             {
  1352.                while (cdigits > 0) *ascii++ = exponent[--cdigits];
  1353.  
  1354.                *ascii = 0;
  1355.  
  1356.                return;
  1357.             }
  1358.          }
  1359.       }
  1360.       else if (!(fp >= DBL_MIN))
  1361.       {
  1362.          *ascii++ = 48; /* '0' */
  1363.          *ascii = 0;
  1364.          return;
  1365.       }
  1366.       else
  1367.       {
  1368.          *ascii++ = 105; /* 'i' */
  1369.          *ascii++ = 110; /* 'n' */
  1370.          *ascii++ = 102; /* 'f' */
  1371.          *ascii = 0;
  1372.          return;
  1373.       }
  1374.    }
  1375.  
  1376.    /* Here on buffer too small. */
  1377.    png_error(png_ptr, "ASCII conversion buffer too small");
  1378. }
  1379.  
  1380. #  endif /* FLOATING_POINT */
  1381.  
  1382. #  ifdef PNG_FIXED_POINT_SUPPORTED
  1383. /* Function to format a fixed point value in ASCII.
  1384.  */
  1385. void /* PRIVATE */
  1386. png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size,
  1387.     png_fixed_point fp)
  1388. {
  1389.    /* Require space for 10 decimal digits, a decimal point, a minus sign and a
  1390.     * trailing \0, 13 characters:
  1391.     */
  1392.    if (size > 12)
  1393.    {
  1394.       png_uint_32 num;
  1395.  
  1396.       /* Avoid overflow here on the minimum integer. */
  1397.       if (fp < 0)
  1398.          *ascii++ = 45, --size, num = -fp;
  1399.       else
  1400.          num = fp;
  1401.  
  1402.       if (num <= 0x80000000U) /* else overflowed */
  1403.       {
  1404.          unsigned int ndigits = 0, first = 16/*flag value*/;
  1405.          char digits[10];
  1406.  
  1407.          while (num)
  1408.          {
  1409.             /* Split the low digit off num: */
  1410.             unsigned int tmp = num/10;
  1411.             num -= tmp*10;
  1412.             digits[ndigits++] = (char)(48 + num);
  1413.             /* Record the first non-zero digit, note that this is a number
  1414.              * starting at 1, it's not actually the array index.
  1415.              */
  1416.             if (first == 16 && num > 0)
  1417.                first = ndigits;
  1418.             num = tmp;
  1419.          }
  1420.  
  1421.          if (ndigits > 0)
  1422.          {
  1423.             while (ndigits > 5) *ascii++ = digits[--ndigits];
  1424.             /* The remaining digits are fractional digits, ndigits is '5' or
  1425.              * smaller at this point.  It is certainly not zero.  Check for a
  1426.              * non-zero fractional digit:
  1427.              */
  1428.             if (first <= 5)
  1429.             {
  1430.                unsigned int i;
  1431.                *ascii++ = 46; /* decimal point */
  1432.                /* ndigits may be <5 for small numbers, output leading zeros
  1433.                 * then ndigits digits to first:
  1434.                 */
  1435.                i = 5;
  1436.                while (ndigits < i) *ascii++ = 48, --i;
  1437.                while (ndigits >= first) *ascii++ = digits[--ndigits];
  1438.                /* Don't output the trailing zeros! */
  1439.             }
  1440.          }
  1441.          else
  1442.             *ascii++ = 48;
  1443.  
  1444.          /* And null terminate the string: */
  1445.          *ascii = 0;
  1446.          return;
  1447.       }
  1448.    }
  1449.  
  1450.    /* Here on buffer too small. */
  1451.    png_error(png_ptr, "ASCII conversion buffer too small");
  1452. }
  1453. #   endif /* FIXED_POINT */
  1454. #endif /* READ_SCAL */
  1455.  
  1456. #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
  1457.    !defined(PNG_FIXED_POINT_MACRO_SUPPORTED)
  1458. png_fixed_point
  1459. png_fixed(png_structp png_ptr, double fp, png_const_charp text)
  1460. {
  1461.    double r = floor(100000 * fp + .5);
  1462.  
  1463.    if (r > 2147483647. || r < -2147483648.)
  1464.       png_fixed_error(png_ptr, text);
  1465.  
  1466.    return (png_fixed_point)r;
  1467. }
  1468. #endif
  1469.  
  1470. #if defined(PNG_READ_GAMMA_SUPPORTED) || \
  1471.     defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED)
  1472. /* muldiv functions */
  1473. /* This API takes signed arguments and rounds the result to the nearest
  1474.  * integer (or, for a fixed point number - the standard argument - to
  1475.  * the nearest .00001).  Overflow and divide by zero are signalled in
  1476.  * the result, a boolean - true on success, false on overflow.
  1477.  */
  1478. int
  1479. png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
  1480.     png_int_32 divisor)
  1481. {
  1482.    /* Return a * times / divisor, rounded. */
  1483.    if (divisor != 0)
  1484.    {
  1485.       if (a == 0 || times == 0)
  1486.       {
  1487.          *res = 0;
  1488.          return 1;
  1489.       }
  1490.       else
  1491.       {
  1492. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  1493.          double r = a;
  1494.          r *= times;
  1495.          r /= divisor;
  1496.          r = floor(r+.5);
  1497.  
  1498.          /* A png_fixed_point is a 32 bit integer. */
  1499.          if (r <= 2147483647. && r >= -2147483648.)
  1500.          {
  1501.             *res = (png_fixed_point)r;
  1502.             return 1;
  1503.          }
  1504. #else
  1505.          int negative = 0;
  1506.          png_uint_32 A, T, D;
  1507.          png_uint_32 s16, s32, s00;
  1508.  
  1509.          if (a < 0)
  1510.             negative = 1, A = -a;
  1511.          else
  1512.             A = a;
  1513.  
  1514.          if (times < 0)
  1515.             negative = !negative, T = -times;
  1516.          else
  1517.             T = times;
  1518.  
  1519.          if (divisor < 0)
  1520.             negative = !negative, D = -divisor;
  1521.          else
  1522.             D = divisor;
  1523.  
  1524.          /* Following can't overflow because the arguments only
  1525.           * have 31 bits each, however the result may be 32 bits.
  1526.           */
  1527.          s16 = (A >> 16) * (T & 0xffff) +
  1528.                            (A & 0xffff) * (T >> 16);
  1529.          /* Can't overflow because the a*times bit is only 30
  1530.           * bits at most.
  1531.           */
  1532.          s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
  1533.          s00 = (A & 0xffff) * (T & 0xffff);
  1534.  
  1535.          s16 = (s16 & 0xffff) << 16;
  1536.          s00 += s16;
  1537.  
  1538.          if (s00 < s16)
  1539.             ++s32; /* carry */
  1540.  
  1541.          if (s32 < D) /* else overflow */
  1542.          {
  1543.             /* s32.s00 is now the 64 bit product, do a standard
  1544.              * division, we know that s32 < D, so the maximum
  1545.              * required shift is 31.
  1546.              */
  1547.             int bitshift = 32;
  1548.             png_fixed_point result = 0; /* NOTE: signed */
  1549.  
  1550.             while (--bitshift >= 0)
  1551.             {
  1552.                png_uint_32 d32, d00;
  1553.  
  1554.                if (bitshift > 0)
  1555.                   d32 = D >> (32-bitshift), d00 = D << bitshift;
  1556.  
  1557.                else
  1558.                   d32 = 0, d00 = D;
  1559.  
  1560.                if (s32 > d32)
  1561.                {
  1562.                   if (s00 < d00) --s32; /* carry */
  1563.                   s32 -= d32, s00 -= d00, result += 1<<bitshift;
  1564.                }
  1565.  
  1566.                else
  1567.                   if (s32 == d32 && s00 >= d00)
  1568.                      s32 = 0, s00 -= d00, result += 1<<bitshift;
  1569.             }
  1570.  
  1571.             /* Handle the rounding. */
  1572.             if (s00 >= (D >> 1))
  1573.                ++result;
  1574.  
  1575.             if (negative)
  1576.                result = -result;
  1577.  
  1578.             /* Check for overflow. */
  1579.             if ((negative && result <= 0) || (!negative && result >= 0))
  1580.             {
  1581.                *res = result;
  1582.                return 1;
  1583.             }
  1584.          }
  1585. #endif
  1586.       }
  1587.    }
  1588.  
  1589.    return 0;
  1590. }
  1591. #endif /* READ_GAMMA || INCH_CONVERSIONS */
  1592.  
  1593. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
  1594. /* The following is for when the caller doesn't much care about the
  1595.  * result.
  1596.  */
  1597. png_fixed_point
  1598. png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times,
  1599.     png_int_32 divisor)
  1600. {
  1601.    png_fixed_point result;
  1602.  
  1603.    if (png_muldiv(&result, a, times, divisor))
  1604.       return result;
  1605.  
  1606.    png_warning(png_ptr, "fixed point overflow ignored");
  1607.    return 0;
  1608. }
  1609. #endif
  1610.  
  1611. #ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */
  1612. /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
  1613. png_fixed_point
  1614. png_reciprocal(png_fixed_point a)
  1615. {
  1616. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  1617.    double r = floor(1E10/a+.5);
  1618.  
  1619.    if (r <= 2147483647. && r >= -2147483648.)
  1620.       return (png_fixed_point)r;
  1621. #else
  1622.    png_fixed_point res;
  1623.  
  1624.    if (png_muldiv(&res, 100000, 100000, a))
  1625.       return res;
  1626. #endif
  1627.  
  1628.    return 0; /* error/overflow */
  1629. }
  1630.  
  1631. /* A local convenience routine. */
  1632. static png_fixed_point
  1633. png_product2(png_fixed_point a, png_fixed_point b)
  1634. {
  1635.    /* The required result is 1/a * 1/b; the following preserves accuracy. */
  1636. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  1637.    double r = a * 1E-5;
  1638.    r *= b;
  1639.    r = floor(r+.5);
  1640.  
  1641.    if (r <= 2147483647. && r >= -2147483648.)
  1642.       return (png_fixed_point)r;
  1643. #else
  1644.    png_fixed_point res;
  1645.  
  1646.    if (png_muldiv(&res, a, b, 100000))
  1647.       return res;
  1648. #endif
  1649.  
  1650.    return 0; /* overflow */
  1651. }
  1652.  
  1653. /* The inverse of the above. */
  1654. png_fixed_point
  1655. png_reciprocal2(png_fixed_point a, png_fixed_point b)
  1656. {
  1657.    /* The required result is 1/a * 1/b; the following preserves accuracy. */
  1658. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  1659.    double r = 1E15/a;
  1660.    r /= b;
  1661.    r = floor(r+.5);
  1662.  
  1663.    if (r <= 2147483647. && r >= -2147483648.)
  1664.       return (png_fixed_point)r;
  1665. #else
  1666.    /* This may overflow because the range of png_fixed_point isn't symmetric,
  1667.     * but this API is only used for the product of file and screen gamma so it
  1668.     * doesn't matter that the smallest number it can produce is 1/21474, not
  1669.     * 1/100000
  1670.     */
  1671.    png_fixed_point res = png_product2(a, b);
  1672.  
  1673.    if (res != 0)
  1674.       return png_reciprocal(res);
  1675. #endif
  1676.  
  1677.    return 0; /* overflow */
  1678. }
  1679. #endif /* READ_GAMMA */
  1680.  
  1681. #ifdef PNG_CHECK_cHRM_SUPPORTED
  1682. /* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2,
  1683.  * 2010: moved from pngset.c) */
  1684. /*
  1685.  *    Multiply two 32-bit numbers, V1 and V2, using 32-bit
  1686.  *    arithmetic, to produce a 64 bit result in the HI/LO words.
  1687.  *
  1688.  *                  A B
  1689.  *                x C D
  1690.  *               ------
  1691.  *              AD || BD
  1692.  *        AC || CB || 0
  1693.  *
  1694.  *    where A and B are the high and low 16-bit words of V1,
  1695.  *    C and D are the 16-bit words of V2, AD is the product of
  1696.  *    A and D, and X || Y is (X << 16) + Y.
  1697. */
  1698.  
  1699. void /* PRIVATE */
  1700. png_64bit_product (long v1, long v2, unsigned long *hi_product,
  1701.     unsigned long *lo_product)
  1702. {
  1703.    int a, b, c, d;
  1704.    long lo, hi, x, y;
  1705.  
  1706.    a = (v1 >> 16) & 0xffff;
  1707.    b = v1 & 0xffff;
  1708.    c = (v2 >> 16) & 0xffff;
  1709.    d = v2 & 0xffff;
  1710.  
  1711.    lo = b * d;                   /* BD */
  1712.    x = a * d + c * b;            /* AD + CB */
  1713.    y = ((lo >> 16) & 0xffff) + x;
  1714.  
  1715.    lo = (lo & 0xffff) | ((y & 0xffff) << 16);
  1716.    hi = (y >> 16) & 0xffff;
  1717.  
  1718.    hi += a * c;                  /* AC */
  1719.  
  1720.    *hi_product = (unsigned long)hi;
  1721.    *lo_product = (unsigned long)lo;
  1722. }
  1723. #endif /* CHECK_cHRM */
  1724.  
  1725. #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
  1726. #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
  1727. /* Fixed point gamma.
  1728.  *
  1729.  * To calculate gamma this code implements fast log() and exp() calls using only
  1730.  * fixed point arithmetic.  This code has sufficient precision for either 8 or
  1731.  * 16 bit sample values.
  1732.  *
  1733.  * The tables used here were calculated using simple 'bc' programs, but C double
  1734.  * precision floating point arithmetic would work fine.  The programs are given
  1735.  * at the head of each table.
  1736.  *
  1737.  * 8 bit log table
  1738.  *   This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
  1739.  *   255, so it's the base 2 logarithm of a normalized 8 bit floating point
  1740.  *   mantissa.  The numbers are 32 bit fractions.
  1741.  */
  1742. static png_uint_32
  1743. png_8bit_l2[128] =
  1744. {
  1745. #  if PNG_DO_BC
  1746.       for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; }
  1747. #  endif
  1748.    4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
  1749.    3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
  1750.    3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
  1751.    3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
  1752.    3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
  1753.    2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
  1754.    2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
  1755.    2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
  1756.    2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
  1757.    2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
  1758.    1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
  1759.    1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
  1760.    1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
  1761.    1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
  1762.    1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
  1763.    971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
  1764.    803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
  1765.    639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
  1766.    479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
  1767.    324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
  1768.    172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
  1769.    24347096U, 0U
  1770. #if 0
  1771.    /* The following are the values for 16 bit tables - these work fine for the 8
  1772.     * bit conversions but produce very slightly larger errors in the 16 bit log
  1773.     * (about 1.2 as opposed to 0.7 absolute error in the final value).  To use
  1774.     * these all the shifts below must be adjusted appropriately.
  1775.     */
  1776.    65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
  1777.    57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
  1778.    50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
  1779.    43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
  1780.    37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
  1781.    31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
  1782.    25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
  1783.    20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
  1784.    15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
  1785.    10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
  1786.    6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
  1787.    1119, 744, 372
  1788. #endif
  1789. };
  1790.  
  1791. static png_int_32
  1792. png_log8bit(unsigned int x)
  1793. {
  1794.    unsigned int lg2 = 0;
  1795.    /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
  1796.     * because the log is actually negate that means adding 1.  The final
  1797.     * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
  1798.     * input), return 7.99998 for the overflow (log 0) case - so the result is
  1799.     * always at most 19 bits.
  1800.     */
  1801.    if ((x &= 0xff) == 0)
  1802.       return 0xffffffff;
  1803.  
  1804.    if ((x & 0xf0) == 0)
  1805.       lg2  = 4, x <<= 4;
  1806.  
  1807.    if ((x & 0xc0) == 0)
  1808.       lg2 += 2, x <<= 2;
  1809.  
  1810.    if ((x & 0x80) == 0)
  1811.       lg2 += 1, x <<= 1;
  1812.  
  1813.    /* result is at most 19 bits, so this cast is safe: */
  1814.    return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
  1815. }
  1816.  
  1817. /* The above gives exact (to 16 binary places) log2 values for 8 bit images,
  1818.  * for 16 bit images we use the most significant 8 bits of the 16 bit value to
  1819.  * get an approximation then multiply the approximation by a correction factor
  1820.  * determined by the remaining up to 8 bits.  This requires an additional step
  1821.  * in the 16 bit case.
  1822.  *
  1823.  * We want log2(value/65535), we have log2(v'/255), where:
  1824.  *
  1825.  *    value = v' * 256 + v''
  1826.  *          = v' * f
  1827.  *
  1828.  * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
  1829.  * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
  1830.  * than 258.  The final factor also needs to correct for the fact that our 8 bit
  1831.  * value is scaled by 255, whereas the 16 bit values must be scaled by 65535.
  1832.  *
  1833.  * This gives a final formula using a calculated value 'x' which is value/v' and
  1834.  * scaling by 65536 to match the above table:
  1835.  *
  1836.  *   log2(x/257) * 65536
  1837.  *
  1838.  * Since these numbers are so close to '1' we can use simple linear
  1839.  * interpolation between the two end values 256/257 (result -368.61) and 258/257
  1840.  * (result 367.179).  The values used below are scaled by a further 64 to give
  1841.  * 16 bit precision in the interpolation:
  1842.  *
  1843.  * Start (256): -23591
  1844.  * Zero  (257):      0
  1845.  * End   (258):  23499
  1846.  */
  1847. static png_int_32
  1848. png_log16bit(png_uint_32 x)
  1849. {
  1850.    unsigned int lg2 = 0;
  1851.  
  1852.    /* As above, but now the input has 16 bits. */
  1853.    if ((x &= 0xffff) == 0)
  1854.       return 0xffffffff;
  1855.  
  1856.    if ((x & 0xff00) == 0)
  1857.       lg2  = 8, x <<= 8;
  1858.  
  1859.    if ((x & 0xf000) == 0)
  1860.       lg2 += 4, x <<= 4;
  1861.  
  1862.    if ((x & 0xc000) == 0)
  1863.       lg2 += 2, x <<= 2;
  1864.  
  1865.    if ((x & 0x8000) == 0)
  1866.       lg2 += 1, x <<= 1;
  1867.  
  1868.    /* Calculate the base logarithm from the top 8 bits as a 28 bit fractional
  1869.     * value.
  1870.     */
  1871.    lg2 <<= 28;
  1872.    lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
  1873.  
  1874.    /* Now we need to interpolate the factor, this requires a division by the top
  1875.     * 8 bits.  Do this with maximum precision.
  1876.     */
  1877.    x = ((x << 16) + (x >> 9)) / (x >> 8);
  1878.  
  1879.    /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
  1880.     * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
  1881.     * 16 bits to interpolate to get the low bits of the result.  Round the
  1882.     * answer.  Note that the end point values are scaled by 64 to retain overall
  1883.     * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
  1884.     * the overall scaling by 6-12.  Round at every step.
  1885.     */
  1886.    x -= 1U << 24;
  1887.  
  1888.    if (x <= 65536U) /* <= '257' */
  1889.       lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
  1890.  
  1891.    else
  1892.       lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
  1893.  
  1894.    /* Safe, because the result can't have more than 20 bits: */
  1895.    return (png_int_32)((lg2 + 2048) >> 12);
  1896. }
  1897.  
  1898. /* The 'exp()' case must invert the above, taking a 20 bit fixed point
  1899.  * logarithmic value and returning a 16 or 8 bit number as appropriate.  In
  1900.  * each case only the low 16 bits are relevant - the fraction - since the
  1901.  * integer bits (the top 4) simply determine a shift.
  1902.  *
  1903.  * The worst case is the 16 bit distinction between 65535 and 65534, this
  1904.  * requires perhaps spurious accuracty in the decoding of the logarithm to
  1905.  * distinguish log2(65535/65534.5) - 10^-5 or 17 bits.  There is little chance
  1906.  * of getting this accuracy in practice.
  1907.  *
  1908.  * To deal with this the following exp() function works out the exponent of the
  1909.  * frational part of the logarithm by using an accurate 32 bit value from the
  1910.  * top four fractional bits then multiplying in the remaining bits.
  1911.  */
  1912. static png_uint_32
  1913. png_32bit_exp[16] =
  1914. {
  1915. #  if PNG_DO_BC
  1916.       for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; }
  1917. #  endif
  1918.    /* NOTE: the first entry is deliberately set to the maximum 32 bit value. */
  1919.    4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
  1920.    3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
  1921.    2553802834U, 2445529972U, 2341847524U, 2242560872U
  1922. };
  1923.  
  1924. /* Adjustment table; provided to explain the numbers in the code below. */
  1925. #if PNG_DO_BC
  1926. for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
  1927.    11 44937.64284865548751208448
  1928.    10 45180.98734845585101160448
  1929.     9 45303.31936980687359311872
  1930.     8 45364.65110595323018870784
  1931.     7 45395.35850361789624614912
  1932.     6 45410.72259715102037508096
  1933.     5 45418.40724413220722311168
  1934.     4 45422.25021786898173001728
  1935.     3 45424.17186732298419044352
  1936.     2 45425.13273269940811464704
  1937.     1 45425.61317555035558641664
  1938.     0 45425.85339951654943850496
  1939. #endif
  1940.  
  1941. static png_uint_32
  1942. png_exp(png_fixed_point x)
  1943. {
  1944.    if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
  1945.    {
  1946.       /* Obtain a 4 bit approximation */
  1947.       png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf];
  1948.  
  1949.       /* Incorporate the low 12 bits - these decrease the returned value by
  1950.        * multiplying by a number less than 1 if the bit is set.  The multiplier
  1951.        * is determined by the above table and the shift. Notice that the values
  1952.        * converge on 45426 and this is used to allow linear interpolation of the
  1953.        * low bits.
  1954.        */
  1955.       if (x & 0x800)
  1956.          e -= (((e >> 16) * 44938U) +  16U) >> 5;
  1957.  
  1958.       if (x & 0x400)
  1959.          e -= (((e >> 16) * 45181U) +  32U) >> 6;
  1960.  
  1961.       if (x & 0x200)
  1962.          e -= (((e >> 16) * 45303U) +  64U) >> 7;
  1963.  
  1964.       if (x & 0x100)
  1965.          e -= (((e >> 16) * 45365U) + 128U) >> 8;
  1966.  
  1967.       if (x & 0x080)
  1968.          e -= (((e >> 16) * 45395U) + 256U) >> 9;
  1969.  
  1970.       if (x & 0x040)
  1971.          e -= (((e >> 16) * 45410U) + 512U) >> 10;
  1972.  
  1973.       /* And handle the low 6 bits in a single block. */
  1974.       e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
  1975.  
  1976.       /* Handle the upper bits of x. */
  1977.       e >>= x >> 16;
  1978.       return e;
  1979.    }
  1980.  
  1981.    /* Check for overflow */
  1982.    if (x <= 0)
  1983.       return png_32bit_exp[0];
  1984.  
  1985.    /* Else underflow */
  1986.    return 0;
  1987. }
  1988.  
  1989. static png_byte
  1990. png_exp8bit(png_fixed_point lg2)
  1991. {
  1992.    /* Get a 32 bit value: */
  1993.    png_uint_32 x = png_exp(lg2);
  1994.  
  1995.    /* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the
  1996.     * second, rounding, step can't overflow because of the first, subtraction,
  1997.     * step.
  1998.     */
  1999.    x -= x >> 8;
  2000.    return (png_byte)((x + 0x7fffffU) >> 24);
  2001. }
  2002.  
  2003. static png_uint_16
  2004. png_exp16bit(png_fixed_point lg2)
  2005. {
  2006.    /* Get a 32 bit value: */
  2007.    png_uint_32 x = png_exp(lg2);
  2008.  
  2009.    /* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */
  2010.    x -= x >> 16;
  2011.    return (png_uint_16)((x + 32767U) >> 16);
  2012. }
  2013. #endif /* FLOATING_ARITHMETIC */
  2014.  
  2015. png_byte
  2016. png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
  2017. {
  2018.    if (value > 0 && value < 255)
  2019.    {
  2020. #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  2021.          double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
  2022.          return (png_byte)r;
  2023. #     else
  2024.          png_int_32 lg2 = png_log8bit(value);
  2025.          png_fixed_point res;
  2026.  
  2027.          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
  2028.             return png_exp8bit(res);
  2029.  
  2030.          /* Overflow. */
  2031.          value = 0;
  2032. #     endif
  2033.    }
  2034.  
  2035.    return (png_byte)value;
  2036. }
  2037.  
  2038. png_uint_16
  2039. png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
  2040. {
  2041.    if (value > 0 && value < 65535)
  2042.    {
  2043. #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  2044.          double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
  2045.          return (png_uint_16)r;
  2046. #     else
  2047.          png_int_32 lg2 = png_log16bit(value);
  2048.          png_fixed_point res;
  2049.  
  2050.          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
  2051.             return png_exp16bit(res);
  2052.  
  2053.          /* Overflow. */
  2054.          value = 0;
  2055. #     endif
  2056.    }
  2057.  
  2058.    return (png_uint_16)value;
  2059. }
  2060.  
  2061. /* This does the right thing based on the bit_depth field of the
  2062.  * png_struct, interpreting values as 8 or 16 bit.  While the result
  2063.  * is nominally a 16 bit value if bit depth is 8 then the result is
  2064.  * 8 bit (as are the arguments.)
  2065.  */
  2066. png_uint_16 /* PRIVATE */
  2067. png_gamma_correct(png_structp png_ptr, unsigned int value,
  2068.     png_fixed_point gamma_val)
  2069. {
  2070.    if (png_ptr->bit_depth == 8)
  2071.       return png_gamma_8bit_correct(value, gamma_val);
  2072.  
  2073.    else
  2074.       return png_gamma_16bit_correct(value, gamma_val);
  2075. }
  2076.  
  2077. /* This is the shared test on whether a gamma value is 'significant' - whether
  2078.  * it is worth doing gamma correction.
  2079.  */
  2080. int /* PRIVATE */
  2081. png_gamma_significant(png_fixed_point gamma_val)
  2082. {
  2083.    return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
  2084.        gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
  2085. }
  2086.  
  2087. /* Internal function to build a single 16 bit table - the table consists of
  2088.  * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
  2089.  * to shift the input values right (or 16-number_of_signifiant_bits).
  2090.  *
  2091.  * The caller is responsible for ensuring that the table gets cleaned up on
  2092.  * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
  2093.  * should be somewhere that will be cleaned.
  2094.  */
  2095. static void
  2096. png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
  2097.    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
  2098. {
  2099.    /* Various values derived from 'shift': */
  2100.    PNG_CONST unsigned int num = 1U << (8U - shift);
  2101.    PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
  2102.    PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
  2103.    unsigned int i;
  2104.  
  2105.    png_uint_16pp table = *ptable =
  2106.        (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
  2107.  
  2108.    for (i = 0; i < num; i++)
  2109.    {
  2110.       png_uint_16p sub_table = table[i] =
  2111.           (png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16));
  2112.  
  2113.       /* The 'threshold' test is repeated here because it can arise for one of
  2114.        * the 16 bit tables even if the others don't hit it.
  2115.        */
  2116.       if (png_gamma_significant(gamma_val))
  2117.       {
  2118.          /* The old code would overflow at the end and this would cause the
  2119.           * 'pow' function to return a result >1, resulting in an
  2120.           * arithmetic error.  This code follows the spec exactly; ig is
  2121.           * the recovered input sample, it always has 8-16 bits.
  2122.           *
  2123.           * We want input * 65535/max, rounded, the arithmetic fits in 32
  2124.           * bits (unsigned) so long as max <= 32767.
  2125.           */
  2126.          unsigned int j;
  2127.          for (j = 0; j < 256; j++)
  2128.          {
  2129.             png_uint_32 ig = (j << (8-shift)) + i;
  2130. #           ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  2131.                /* Inline the 'max' scaling operation: */
  2132.                double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5);
  2133.                sub_table[j] = (png_uint_16)d;
  2134. #           else
  2135.                if (shift)
  2136.                   ig = (ig * 65535U + max_by_2)/max;
  2137.  
  2138.                sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
  2139. #           endif
  2140.          }
  2141.       }
  2142.       else
  2143.       {
  2144.          /* We must still build a table, but do it the fast way. */
  2145.          unsigned int j;
  2146.  
  2147.          for (j = 0; j < 256; j++)
  2148.          {
  2149.             png_uint_32 ig = (j << (8-shift)) + i;
  2150.  
  2151.             if (shift)
  2152.                ig = (ig * 65535U + max_by_2)/max;
  2153.  
  2154.             sub_table[j] = (png_uint_16)ig;
  2155.          }
  2156.       }
  2157.    }
  2158. }
  2159.  
  2160. /* NOTE: this function expects the *inverse* of the overall gamma transformation
  2161.  * required.
  2162.  */
  2163. static void
  2164. png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
  2165.    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
  2166. {
  2167.    PNG_CONST unsigned int num = 1U << (8U - shift);
  2168.    PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
  2169.    unsigned int i;
  2170.    png_uint_32 last;
  2171.  
  2172.    png_uint_16pp table = *ptable =
  2173.        (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
  2174.  
  2175.    /* 'num' is the number of tables and also the number of low bits of low
  2176.     * bits of the input 16 bit value used to select a table.  Each table is
  2177.     * itself index by the high 8 bits of the value.
  2178.     */
  2179.    for (i = 0; i < num; i++)
  2180.       table[i] = (png_uint_16p)png_malloc(png_ptr,
  2181.           256 * png_sizeof(png_uint_16));
  2182.  
  2183.    /* 'gamma_val' is set to the reciprocal of the value calculated above, so
  2184.     * pow(out,g) is an *input* value.  'last' is the last input value set.
  2185.     *
  2186.     * In the loop 'i' is used to find output values.  Since the output is 8
  2187.     * bit there are only 256 possible values.  The tables are set up to
  2188.     * select the closest possible output value for each input by finding
  2189.     * the input value at the boundary between each pair of output values
  2190.     * and filling the table up to that boundary with the lower output
  2191.     * value.
  2192.     *
  2193.     * The boundary values are 0.5,1.5..253.5,254.5.  Since these are 9 bit
  2194.     * values the code below uses a 16 bit value in i; the values start at
  2195.     * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
  2196.     * entries are filled with 255).  Start i at 128 and fill all 'last'
  2197.     * table entries <= 'max'
  2198.     */
  2199.    last = 0;
  2200.    for (i = 0; i < 255; ++i) /* 8 bit output value */
  2201.    {
  2202.       /* Find the corresponding maximum input value */
  2203.       png_uint_16 out = (png_uint_16)(i * 257U); /* 16 bit output value */
  2204.  
  2205.       /* Find the boundary value in 16 bits: */
  2206.       png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
  2207.  
  2208.       /* Adjust (round) to (16-shift) bits: */
  2209.       bound = (bound * max + 32768U)/65535U + 1U;
  2210.  
  2211.       while (last < bound)
  2212.       {
  2213.          table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
  2214.          last++;
  2215.       }
  2216.    }
  2217.  
  2218.    /* And fill in the final entries. */
  2219.    while (last < (num << 8))
  2220.    {
  2221.       table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
  2222.       last++;
  2223.    }
  2224. }
  2225.  
  2226. /* Build a single 8 bit table: same as the 16 bit case but much simpler (and
  2227.  * typically much faster).  Note that libpng currently does no sBIT processing
  2228.  * (apparently contrary to the spec) so a 256 entry table is always generated.
  2229.  */
  2230. static void
  2231. png_build_8bit_table(png_structp png_ptr, png_bytepp ptable,
  2232.    PNG_CONST png_fixed_point gamma_val)
  2233. {
  2234.    unsigned int i;
  2235.    png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
  2236.  
  2237.    if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++)
  2238.       table[i] = png_gamma_8bit_correct(i, gamma_val);
  2239.  
  2240.    else for (i=0; i<256; ++i)
  2241.       table[i] = (png_byte)i;
  2242. }
  2243.  
  2244. /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
  2245.  * tables, we don't make a full table if we are reducing to 8-bit in
  2246.  * the future.  Note also how the gamma_16 tables are segmented so that
  2247.  * we don't need to allocate > 64K chunks for a full 16-bit table.
  2248.  */
  2249. void /* PRIVATE */
  2250. png_build_gamma_table(png_structp png_ptr, int bit_depth)
  2251. {
  2252.   png_debug(1, "in png_build_gamma_table");
  2253.  
  2254.   if (bit_depth <= 8)
  2255.   {
  2256.      png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
  2257.          png_ptr->screen_gamma > 0 ?  png_reciprocal2(png_ptr->gamma,
  2258.          png_ptr->screen_gamma) : PNG_FP_1);
  2259.  
  2260. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  2261.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  2262.      if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
  2263.      {
  2264.         png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
  2265.             png_reciprocal(png_ptr->gamma));
  2266.  
  2267.         png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
  2268.             png_ptr->screen_gamma > 0 ?  png_reciprocal(png_ptr->screen_gamma) :
  2269.             png_ptr->gamma/* Probably doing rgb_to_gray */);
  2270.      }
  2271. #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
  2272.   }
  2273.   else
  2274.   {
  2275.      png_byte shift, sig_bit;
  2276.  
  2277.      if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  2278.      {
  2279.         sig_bit = png_ptr->sig_bit.red;
  2280.  
  2281.         if (png_ptr->sig_bit.green > sig_bit)
  2282.            sig_bit = png_ptr->sig_bit.green;
  2283.  
  2284.         if (png_ptr->sig_bit.blue > sig_bit)
  2285.            sig_bit = png_ptr->sig_bit.blue;
  2286.      }
  2287.      else
  2288.         sig_bit = png_ptr->sig_bit.gray;
  2289.  
  2290.      /* 16 bit gamma code uses this equation:
  2291.       *
  2292.       *   ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
  2293.       *
  2294.       * Where 'iv' is the input color value and 'ov' is the output value -
  2295.       * pow(iv, gamma).
  2296.       *
  2297.       * Thus the gamma table consists of up to 256 256 entry tables.  The table
  2298.       * is selected by the (8-gamma_shift) most significant of the low 8 bits of
  2299.       * the color value then indexed by the upper 8 bits:
  2300.       *
  2301.       *   table[low bits][high 8 bits]
  2302.       *
  2303.       * So the table 'n' corresponds to all those 'iv' of:
  2304.       *
  2305.       *   <all high 8 bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
  2306.       *
  2307.       */
  2308.      if (sig_bit > 0 && sig_bit < 16U)
  2309.         shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */
  2310.  
  2311.      else
  2312.         shift = 0; /* keep all 16 bits */
  2313.  
  2314.      if (png_ptr->transformations & PNG_16_TO_8)
  2315.      {
  2316.         /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
  2317.          * the significant bits in the *input* when the output will
  2318.          * eventually be 8 bits.  By default it is 11.
  2319.          */
  2320.         if (shift < (16U - PNG_MAX_GAMMA_8))
  2321.            shift = (16U - PNG_MAX_GAMMA_8);
  2322.      }
  2323.  
  2324.      if (shift > 8U)
  2325.         shift = 8U; /* Guarantees at least one table! */
  2326.  
  2327.      png_ptr->gamma_shift = shift;
  2328.  
  2329. #ifdef PNG_16BIT_SUPPORTED
  2330.      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
  2331. #endif
  2332.          png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
  2333.          png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma,
  2334.          png_ptr->screen_gamma) : PNG_FP_1);
  2335.  
  2336. #ifdef PNG_16BIT_SUPPORTED
  2337.      else
  2338.          png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
  2339.          png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
  2340.          png_ptr->screen_gamma) : PNG_FP_1);
  2341. #endif
  2342.  
  2343. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  2344.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  2345.      if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
  2346.      {
  2347.         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
  2348.             png_reciprocal(png_ptr->gamma));
  2349.  
  2350.         /* Notice that the '16 from 1' table should be full precision, however
  2351.          * the lookup on this table still uses gamma_shift, so it can't be.
  2352.          * TODO: fix this.
  2353.          */
  2354.         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
  2355.             png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
  2356.             png_ptr->gamma/* Probably doing rgb_to_gray */);
  2357.      }
  2358. #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
  2359.   }
  2360. }
  2361. #endif /* READ_GAMMA */
  2362. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  2363.