PageRenderTime 63ms CodeModel.GetById 5ms RepoModel.GetById 0ms app.codeStats 0ms

/src/FreeImage/Source/LibPNG/png.c

https://bitbucket.org/cabalistic/ogredeps/
C | 2870 lines | 1710 code | 392 blank | 768 comment | 442 complexity | 43d68f8e6f25295ba659fdd331ae0123 MD5 | raw file
Possible License(s): LGPL-3.0, BSD-3-Clause, CPL-1.0, Unlicense, GPL-2.0, GPL-3.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, BSD-2-Clause, LGPL-2.1 
    

  1. 

  2. /* png.c - location for general purpose libpng functions
    3. 

  3.  *
    4. 

  4.  * Last changed in libpng 1.5.7 [December 15, 2011]
    5. 

  5.  * Copyright (c) 1998-2011 Glenn Randers-Pehrson
    6. 

  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    7. 

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

  8.  *
    9. 

  9.  * This code is released under the libpng license.
    10. 

  10.  * For conditions of distribution and use, see the disclaimer
    11. 

  11.  * and license in png.h
    12. 

  12.  */
    13. 

  13. 

  14. #include "pngpriv.h"
    15. 

  15. 

  16. /* Generate a compiler error if there is an old png.h in the search path. */
    17. 

  17. typedef png_libpng_version_1_5_9 Your_png_h_is_not_version_1_5_9;
    18. 

  18. 

  19. /* Tells libpng that we have already handled the first "num_bytes" bytes
    20. 

  20.  * of the PNG file signature.  If the PNG data is embedded into another
    21. 

  21.  * stream we can set num_bytes = 8 so that libpng will not attempt to read
    22. 

  22.  * or write any of the magic bytes before it starts on the IHDR.
    23. 

  23.  */
    24. 

  24. 

  25. #ifdef PNG_READ_SUPPORTED
    26. 

  26. void PNGAPI
    27. 

  27. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
    28. 

  28. {
    29. 

  29.    png_debug(1, "in png_set_sig_bytes");
    30. 

  30. 

  31.    if (png_ptr == NULL)
    32. 

  32.       return;
    33. 

  33. 

  34.    if (num_bytes > 8)
    35. 

  35.       png_error(png_ptr, "Too many bytes for PNG signature");
    36. 

  36. 

  37.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
    38. 

  38. }
    39. 

  39. 

  40. /* Checks whether the supplied bytes match the PNG signature.  We allow
    41. 

  41.  * checking less than the full 8-byte signature so that those apps that
    42. 

  42.  * already read the first few bytes of a file to determine the file type
    43. 

  43.  * can simply check the remaining bytes for extra assurance.  Returns
    44. 

  44.  * an integer less than, equal to, or greater than zero if sig is found,
    45. 

  45.  * respectively, to be less than, to match, or be greater than the correct
    46. 

  46.  * PNG signature (this is the same behavior as strcmp, memcmp, etc).
    47. 

  47.  */
    48. 

  48. int PNGAPI
    49. 

  49. png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
    50. 

  50. {
    51. 

  51.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
    52. 

  52. 

  53.    if (num_to_check > 8)
    54. 

  54.       num_to_check = 8;
    55. 

  55. 

  56.    else if (num_to_check < 1)
    57. 

  57.       return (-1);
    58. 

  58. 

  59.    if (start > 7)
    60. 

  60.       return (-1);
    61. 

  61. 

  62.    if (start + num_to_check > 8)
    63. 

  63.       num_to_check = 8 - start;
    64. 

  64. 

  65.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
    66. 

  66. }
    67. 

  67. 

  68. #endif /* PNG_READ_SUPPORTED */
    69. 

  69. 

  70. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
    71. 

  71. /* Function to allocate memory for zlib */
    72. 

  72. PNG_FUNCTION(voidpf /* PRIVATE */,
    73. 

  73. png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
    74. 

  74. {
    75. 

  75.    png_voidp ptr;
    76. 

  76.    png_structp p=(png_structp)png_ptr;
    77. 

  77.    png_uint_32 save_flags=p->flags;
    78. 

  78.    png_alloc_size_t num_bytes;
    79. 

  79. 

  80.    if (png_ptr == NULL)
    81. 

  81.       return (NULL);
    82. 

  82. 

  83.    if (items > PNG_UINT_32_MAX/size)
    84. 

  84.    {
    85. 

  85.      png_warning (p, "Potential overflow in png_zalloc()");
    86. 

  86.      return (NULL);
    87. 

  87.    }
    88. 

  88.    num_bytes = (png_alloc_size_t)items * size;
    89. 

  89. 

  90.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
    91. 

  91.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
    92. 

  92.    p->flags=save_flags;
    93. 

  93. 

  94.    return ((voidpf)ptr);
    95. 

  95. }
    96. 

  96. 

  97. /* Function to free memory for zlib */
    98. 

  98. void /* PRIVATE */
    99. 

  99. png_zfree(voidpf png_ptr, voidpf ptr)
    100. 

  100. {
    101. 

  101.    png_free((png_structp)png_ptr, (png_voidp)ptr);
    102. 

  102. }
    103. 

  103. 

  104. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
    105. 

  105.  * in case CRC is > 32 bits to leave the top bits 0.
    106. 

  106.  */
    107. 

  107. void /* PRIVATE */
    108. 

  108. png_reset_crc(png_structp png_ptr)
    109. 

  109. {
    110. 

  110.    /* The cast is safe because the crc is a 32 bit value. */
    111. 

  111.    png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
    112. 

  112. }
    113. 

  113. 

  114. /* Calculate the CRC over a section of data.  We can only pass as
    115. 

  115.  * much data to this routine as the largest single buffer size.  We
    116. 

  116.  * also check that this data will actually be used before going to the
    117. 

  117.  * trouble of calculating it.
    118. 

  118.  */
    119. 

  119. void /* PRIVATE */
    120. 

  120. png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length)
    121. 

  121. {
    122. 

  122.    int need_crc = 1;
    123. 

  123. 

  124.    if (PNG_CHUNK_ANCILLIARY(png_ptr->chunk_name))
    125. 

  125.    {
    126. 

  126.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
    127. 

  127.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
    128. 

  128.          need_crc = 0;
    129. 

  129.    }
    130. 

  130. 

  131.    else /* critical */
    132. 

  132.    {
    133. 

  133.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
    134. 

  134.          need_crc = 0;
    135. 

  135.    }
    136. 

  136. 

  137.    /* 'uLong' is defined as unsigned long, this means that on some systems it is
    138. 

  138.     * a 64 bit value.  crc32, however, returns 32 bits so the following cast is
    139. 

  139.     * safe.  'uInt' may be no more than 16 bits, so it is necessary to perform a
    140. 

  140.     * loop here.
    141. 

  141.     */
    142. 

  142.    if (need_crc && length > 0)
    143. 

  143.    {
    144. 

  144.       uLong crc = png_ptr->crc; /* Should never issue a warning */
    145. 

  145. 

  146.       do
    147. 

  147.       {
    148. 

  148.          uInt safeLength = (uInt)length;
    149. 

  149.          if (safeLength == 0)
    150. 

  150.             safeLength = (uInt)-1; /* evil, but safe */
    151. 

  151. 

  152.          crc = crc32(crc, ptr, safeLength);
    153. 

  153. 

  154.          /* The following should never issue compiler warnings, if they do the
    155. 

  155.           * target system has characteristics that will probably violate other
    156. 

  156.           * assumptions within the libpng code.
    157. 

  157.           */
    158. 

  158.          ptr += safeLength;
    159. 

  159.          length -= safeLength;
    160. 

  160.       }
    161. 

  161.       while (length > 0);
    162. 

  162. 

  163.       /* And the following is always safe because the crc is only 32 bits. */
    164. 

  164.       png_ptr->crc = (png_uint_32)crc;
    165. 

  165.    }
    166. 

  166. }
    167. 

  167. 

  168. /* Check a user supplied version number, called from both read and write
    169. 

  169.  * functions that create a png_struct
    170. 

  170.  */
    171. 

  171. int
    172. 

  172. png_user_version_check(png_structp png_ptr, png_const_charp user_png_ver)
    173. 

  173. {
    174. 

  174.    if (user_png_ver)
    175. 

  175.    {
    176. 

  176.       int i = 0;
    177. 

  177. 

  178.       do
    179. 

  179.       {
    180. 

  180.          if (user_png_ver[i] != png_libpng_ver[i])
    181. 

  181.             png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
    182. 

  182.       } while (png_libpng_ver[i++]);
    183. 

  183.    }
    184. 

  184. 

  185.    else
    186. 

  186.       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
    187. 

  187. 

  188.    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
    189. 

  189.    {
    190. 

  190.      /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
    191. 

  191.       * we must recompile any applications that use any older library version.
    192. 

  192.       * For versions after libpng 1.0, we will be compatible, so we need
    193. 

  193.       * only check the first digit.
    194. 

  194.       */
    195. 

  195.       if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
    196. 

  196.           (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
    197. 

  197.           (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
    198. 

  198.       {
    199. 

  199. #ifdef PNG_WARNINGS_SUPPORTED
    200. 

  200.          size_t pos = 0;
    201. 

  201.          char m[128];
    202. 

  202. 

  203.          pos = png_safecat(m, sizeof m, pos, "Application built with libpng-");
    204. 

  204.          pos = png_safecat(m, sizeof m, pos, user_png_ver);
    205. 

  205.          pos = png_safecat(m, sizeof m, pos, " but running with ");
    206. 

  206.          pos = png_safecat(m, sizeof m, pos, png_libpng_ver);
    207. 

  207. 

  208.          png_warning(png_ptr, m);
    209. 

  209. #endif
    210. 

  210. 

  211. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
    212. 

  212.          png_ptr->flags = 0;
    213. 

  213. #endif
    214. 

  214. 

  215.          return 0;
    216. 

  216.       }
    217. 

  217.    }
    218. 

  218. 

  219.    /* Success return. */
    220. 

  220.    return 1;
    221. 

  221. }
    222. 

  222. 

  223. /* Allocate the memory for an info_struct for the application.  We don't
    224. 

  224.  * really need the png_ptr, but it could potentially be useful in the
    225. 

  225.  * future.  This should be used in favour of malloc(png_sizeof(png_info))
    226. 

  226.  * and png_info_init() so that applications that want to use a shared
    227. 

  227.  * libpng don't have to be recompiled if png_info changes size.
    228. 

  228.  */
    229. 

  229. PNG_FUNCTION(png_infop,PNGAPI
    230. 

  230. png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED)
    231. 

  231. {
    232. 

  232.    png_infop info_ptr;
    233. 

  233. 

  234.    png_debug(1, "in png_create_info_struct");
    235. 

  235. 

  236.    if (png_ptr == NULL)
    237. 

  237.       return (NULL);
    238. 

  238. 

  239. #ifdef PNG_USER_MEM_SUPPORTED
    240. 

  240.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
    241. 

  241.       png_ptr->malloc_fn, png_ptr->mem_ptr);
    242. 

  242. #else
    243. 

  243.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
    244. 

  244. #endif
    245. 

  245.    if (info_ptr != NULL)
    246. 

  246.       png_info_init_3(&info_ptr, png_sizeof(png_info));
    247. 

  247. 

  248.    return (info_ptr);
    249. 

  249. }
    250. 

  250. 

  251. /* This function frees the memory associated with a single info struct.
    252. 

  252.  * Normally, one would use either png_destroy_read_struct() or
    253. 

  253.  * png_destroy_write_struct() to free an info struct, but this may be
    254. 

  254.  * useful for some applications.
    255. 

  255.  */
    256. 

  256. void PNGAPI
    257. 

  257. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
    258. 

  258. {
    259. 

  259.    png_infop info_ptr = NULL;
    260. 

  260. 

  261.    png_debug(1, "in png_destroy_info_struct");
    262. 

  262. 

  263.    if (png_ptr == NULL)
    264. 

  264.       return;
    265. 

  265. 

  266.    if (info_ptr_ptr != NULL)
    267. 

  267.       info_ptr = *info_ptr_ptr;
    268. 

  268. 

  269.    if (info_ptr != NULL)
    270. 

  270.    {
    271. 

  271.       png_info_destroy(png_ptr, info_ptr);
    272. 

  272. 

  273. #ifdef PNG_USER_MEM_SUPPORTED
    274. 

  274.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
    275. 

  275.           png_ptr->mem_ptr);
    276. 

  276. #else
    277. 

  277.       png_destroy_struct((png_voidp)info_ptr);
    278. 

  278. #endif
    279. 

  279.       *info_ptr_ptr = NULL;
    280. 

  280.    }
    281. 

  281. }
    282. 

  282. 

  283. /* Initialize the info structure.  This is now an internal function (0.89)
    284. 

  284.  * and applications using it are urged to use png_create_info_struct()
    285. 

  285.  * instead.
    286. 

  286.  */
    287. 

  287. 

  288. void PNGAPI
    289. 

  289. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
    290. 

  290. {
    291. 

  291.    png_infop info_ptr = *ptr_ptr;
    292. 

  292. 

  293.    png_debug(1, "in png_info_init_3");
    294. 

  294. 

  295.    if (info_ptr == NULL)
    296. 

  296.       return;
    297. 

  297. 

  298.    if (png_sizeof(png_info) > png_info_struct_size)
    299. 

  299.    {
    300. 

  300.       png_destroy_struct(info_ptr);
    301. 

  301.       info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
    302. 

  302.       *ptr_ptr = info_ptr;
    303. 

  303.    }
    304. 

  304. 

  305.    /* Set everything to 0 */
    306. 

  306.    png_memset(info_ptr, 0, png_sizeof(png_info));
    307. 

  307. }
    308. 

  308. 

  309. void PNGAPI
    310. 

  310. png_data_freer(png_structp png_ptr, png_infop info_ptr,
    311. 

  311.    int freer, png_uint_32 mask)
    312. 

  312. {
    313. 

  313.    png_debug(1, "in png_data_freer");
    314. 

  314. 

  315.    if (png_ptr == NULL || info_ptr == NULL)
    316. 

  316.       return;
    317. 

  317. 

  318.    if (freer == PNG_DESTROY_WILL_FREE_DATA)
    319. 

  319.       info_ptr->free_me |= mask;
    320. 

  320. 

  321.    else if (freer == PNG_USER_WILL_FREE_DATA)
    322. 

  322.       info_ptr->free_me &= ~mask;
    323. 

  323. 

  324.    else
    325. 

  325.       png_warning(png_ptr,
    326. 

  326.          "Unknown freer parameter in png_data_freer");
    327. 

  327. }
    328. 

  328. 

  329. void PNGAPI
    330. 

  330. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
    331. 

  331.    int num)
    332. 

  332. {
    333. 

  333.    png_debug(1, "in png_free_data");
    334. 

  334. 

  335.    if (png_ptr == NULL || info_ptr == NULL)
    336. 

  336.       return;
    337. 

  337. 

  338. #ifdef PNG_TEXT_SUPPORTED
    339. 

  339.    /* Free text item num or (if num == -1) all text items */
    340. 

  340.    if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
    341. 

  341.    {
    342. 

  342.       if (num != -1)
    343. 

  343.       {
    344. 

  344.          if (info_ptr->text && info_ptr->text[num].key)
    345. 

  345.          {
    346. 

  346.             png_free(png_ptr, info_ptr->text[num].key);
    347. 

  347.             info_ptr->text[num].key = NULL;
    348. 

  348.          }
    349. 

  349.       }
    350. 

  350. 

  351.       else
    352. 

  352.       {
    353. 

  353.          int i;
    354. 

  354.          for (i = 0; i < info_ptr->num_text; i++)
    355. 

  355.              png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
    356. 

  356.          png_free(png_ptr, info_ptr->text);
    357. 

  357.          info_ptr->text = NULL;
    358. 

  358.          info_ptr->num_text=0;
    359. 

  359.       }
    360. 

  360.    }
    361. 

  361. #endif
    362. 

  362. 

  363. #ifdef PNG_tRNS_SUPPORTED
    364. 

  364.    /* Free any tRNS entry */
    365. 

  365.    if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
    366. 

  366.    {
    367. 

  367.       png_free(png_ptr, info_ptr->trans_alpha);
    368. 

  368.       info_ptr->trans_alpha = NULL;
    369. 

  369.       info_ptr->valid &= ~PNG_INFO_tRNS;
    370. 

  370.    }
    371. 

  371. #endif
    372. 

  372. 

  373. #ifdef PNG_sCAL_SUPPORTED
    374. 

  374.    /* Free any sCAL entry */
    375. 

  375.    if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
    376. 

  376.    {
    377. 

  377.       png_free(png_ptr, info_ptr->scal_s_width);
    378. 

  378.       png_free(png_ptr, info_ptr->scal_s_height);
    379. 

  379.       info_ptr->scal_s_width = NULL;
    380. 

  380.       info_ptr->scal_s_height = NULL;
    381. 

  381.       info_ptr->valid &= ~PNG_INFO_sCAL;
    382. 

  382.    }
    383. 

  383. #endif
    384. 

  384. 

  385. #ifdef PNG_pCAL_SUPPORTED
    386. 

  386.    /* Free any pCAL entry */
    387. 

  387.    if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
    388. 

  388.    {
    389. 

  389.       png_free(png_ptr, info_ptr->pcal_purpose);
    390. 

  390.       png_free(png_ptr, info_ptr->pcal_units);
    391. 

  391.       info_ptr->pcal_purpose = NULL;
    392. 

  392.       info_ptr->pcal_units = NULL;
    393. 

  393.       if (info_ptr->pcal_params != NULL)
    394. 

  394.          {
    395. 

  395.             int i;
    396. 

  396.             for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
    397. 

  397.             {
    398. 

  398.                png_free(png_ptr, info_ptr->pcal_params[i]);
    399. 

  399.                info_ptr->pcal_params[i] = NULL;
    400. 

  400.             }
    401. 

  401.             png_free(png_ptr, info_ptr->pcal_params);
    402. 

  402.             info_ptr->pcal_params = NULL;
    403. 

  403.          }
    404. 

  404.       info_ptr->valid &= ~PNG_INFO_pCAL;
    405. 

  405.    }
    406. 

  406. #endif
    407. 

  407. 

  408. #ifdef PNG_iCCP_SUPPORTED
    409. 

  409.    /* Free any iCCP entry */
    410. 

  410.    if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
    411. 

  411.    {
    412. 

  412.       png_free(png_ptr, info_ptr->iccp_name);
    413. 

  413.       png_free(png_ptr, info_ptr->iccp_profile);
    414. 

  414.       info_ptr->iccp_name = NULL;
    415. 

  415.       info_ptr->iccp_profile = NULL;
    416. 

  416.       info_ptr->valid &= ~PNG_INFO_iCCP;
    417. 

  417.    }
    418. 

  418. #endif
    419. 

  419. 

  420. #ifdef PNG_sPLT_SUPPORTED
    421. 

  421.    /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
    422. 

  422.    if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
    423. 

  423.    {
    424. 

  424.       if (num != -1)
    425. 

  425.       {
    426. 

  426.          if (info_ptr->splt_palettes)
    427. 

  427.          {
    428. 

  428.             png_free(png_ptr, info_ptr->splt_palettes[num].name);
    429. 

  429.             png_free(png_ptr, info_ptr->splt_palettes[num].entries);
    430. 

  430.             info_ptr->splt_palettes[num].name = NULL;
    431. 

  431.             info_ptr->splt_palettes[num].entries = NULL;
    432. 

  432.          }
    433. 

  433.       }
    434. 

  434. 

  435.       else
    436. 

  436.       {
    437. 

  437.          if (info_ptr->splt_palettes_num)
    438. 

  438.          {
    439. 

  439.             int i;
    440. 

  440.             for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
    441. 

  441.                png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
    442. 

  442. 

  443.             png_free(png_ptr, info_ptr->splt_palettes);
    444. 

  444.             info_ptr->splt_palettes = NULL;
    445. 

  445.             info_ptr->splt_palettes_num = 0;
    446. 

  446.          }
    447. 

  447.          info_ptr->valid &= ~PNG_INFO_sPLT;
    448. 

  448.       }
    449. 

  449.    }
    450. 

  450. #endif
    451. 

  451. 

  452. #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
    453. 

  453.    if (png_ptr->unknown_chunk.data)
    454. 

  454.    {
    455. 

  455.       png_free(png_ptr, png_ptr->unknown_chunk.data);
    456. 

  456.       png_ptr->unknown_chunk.data = NULL;
    457. 

  457.    }
    458. 

  458. 

  459.    if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
    460. 

  460.    {
    461. 

  461.       if (num != -1)
    462. 

  462.       {
    463. 

  463.           if (info_ptr->unknown_chunks)
    464. 

  464.           {
    465. 

  465.              png_free(png_ptr, info_ptr->unknown_chunks[num].data);
    466. 

  466.              info_ptr->unknown_chunks[num].data = NULL;
    467. 

  467.           }
    468. 

  468.       }
    469. 

  469. 

  470.       else
    471. 

  471.       {
    472. 

  472.          int i;
    473. 

  473. 

  474.          if (info_ptr->unknown_chunks_num)
    475. 

  475.          {
    476. 

  476.             for (i = 0; i < info_ptr->unknown_chunks_num; i++)
    477. 

  477.                png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
    478. 

  478. 

  479.             png_free(png_ptr, info_ptr->unknown_chunks);
    480. 

  480.             info_ptr->unknown_chunks = NULL;
    481. 

  481.             info_ptr->unknown_chunks_num = 0;
    482. 

  482.          }
    483. 

  483.       }
    484. 

  484.    }
    485. 

  485. #endif
    486. 

  486. 

  487. #ifdef PNG_hIST_SUPPORTED
    488. 

  488.    /* Free any hIST entry */
    489. 

  489.    if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
    490. 

  490.    {
    491. 

  491.       png_free(png_ptr, info_ptr->hist);
    492. 

  492.       info_ptr->hist = NULL;
    493. 

  493.       info_ptr->valid &= ~PNG_INFO_hIST;
    494. 

  494.    }
    495. 

  495. #endif
    496. 

  496. 

  497.    /* Free any PLTE entry that was internally allocated */
    498. 

  498.    if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
    499. 

  499.    {
    500. 

  500.       png_zfree(png_ptr, info_ptr->palette);
    501. 

  501.       info_ptr->palette = NULL;
    502. 

  502.       info_ptr->valid &= ~PNG_INFO_PLTE;
    503. 

  503.       info_ptr->num_palette = 0;
    504. 

  504.    }
    505. 

  505. 

  506. #ifdef PNG_INFO_IMAGE_SUPPORTED
    507. 

  507.    /* Free any image bits attached to the info structure */
    508. 

  508.    if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
    509. 

  509.    {
    510. 

  510.       if (info_ptr->row_pointers)
    511. 

  511.       {
    512. 

  512.          int row;
    513. 

  513.          for (row = 0; row < (int)info_ptr->height; row++)
    514. 

  514.          {
    515. 

  515.             png_free(png_ptr, info_ptr->row_pointers[row]);
    516. 

  516.             info_ptr->row_pointers[row] = NULL;
    517. 

  517.          }
    518. 

  518.          png_free(png_ptr, info_ptr->row_pointers);
    519. 

  519.          info_ptr->row_pointers = NULL;
    520. 

  520.       }
    521. 

  521.       info_ptr->valid &= ~PNG_INFO_IDAT;
    522. 

  522.    }
    523. 

  523. #endif
    524. 

  524. 

  525.    if (num != -1)
    526. 

  526.       mask &= ~PNG_FREE_MUL;
    527. 

  527. 

  528.    info_ptr->free_me &= ~mask;
    529. 

  529. }
    530. 

  530. 

  531. /* This is an internal routine to free any memory that the info struct is
    532. 

  532.  * pointing to before re-using it or freeing the struct itself.  Recall
    533. 

  533.  * that png_free() checks for NULL pointers for us.
    534. 

  534.  */
    535. 

  535. void /* PRIVATE */
    536. 

  536. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
    537. 

  537. {
    538. 

  538.    png_debug(1, "in png_info_destroy");
    539. 

  539. 

  540.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
    541. 

  541. 

  542. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    543. 

  543.    if (png_ptr->num_chunk_list)
    544. 

  544.    {
    545. 

  545.       png_free(png_ptr, png_ptr->chunk_list);
    546. 

  546.       png_ptr->chunk_list = NULL;
    547. 

  547.       png_ptr->num_chunk_list = 0;
    548. 

  548.    }
    549. 

  549. #endif
    550. 

  550. 

  551.    png_info_init_3(&info_ptr, png_sizeof(png_info));
    552. 

  552. }
    553. 

  553. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
    554. 

  554. 

  555. /* This function returns a pointer to the io_ptr associated with the user
    556. 

  556.  * functions.  The application should free any memory associated with this
    557. 

  557.  * pointer before png_write_destroy() or png_read_destroy() are called.
    558. 

  558.  */
    559. 

  559. png_voidp PNGAPI
    560. 

  560. png_get_io_ptr(png_structp png_ptr)
    561. 

  561. {
    562. 

  562.    if (png_ptr == NULL)
    563. 

  563.       return (NULL);
    564. 

  564. 

  565.    return (png_ptr->io_ptr);
    566. 

  566. }
    567. 

  567. 

  568. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
    569. 

  569. #  ifdef PNG_STDIO_SUPPORTED
    570. 

  570. /* Initialize the default input/output functions for the PNG file.  If you
    571. 

  571.  * use your own read or write routines, you can call either png_set_read_fn()
    572. 

  572.  * or png_set_write_fn() instead of png_init_io().  If you have defined
    573. 

  573.  * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
    574. 

  574.  * function of your own because "FILE *" isn't necessarily available.
    575. 

  575.  */
    576. 

  576. void PNGAPI
    577. 

  577. png_init_io(png_structp png_ptr, png_FILE_p fp)
    578. 

  578. {
    579. 

  579.    png_debug(1, "in png_init_io");
    580. 

  580. 

  581.    if (png_ptr == NULL)
    582. 

  582.       return;
    583. 

  583. 

  584.    png_ptr->io_ptr = (png_voidp)fp;
    585. 

  585. }
    586. 

  586. #  endif
    587. 

  587. 

  588. #  ifdef PNG_TIME_RFC1123_SUPPORTED
    589. 

  589. /* Convert the supplied time into an RFC 1123 string suitable for use in
    590. 

  590.  * a "Creation Time" or other text-based time string.
    591. 

  591.  */
    592. 

  592. png_const_charp PNGAPI
    593. 

  593. png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime)
    594. 

  594. {
    595. 

  595.    static PNG_CONST char short_months[12][4] =
    596. 

  596.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
    597. 

  597.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
    598. 

  598. 

  599.    if (png_ptr == NULL)
    600. 

  600.       return (NULL);
    601. 

  601. 

  602.    if (ptime->year > 9999 /* RFC1123 limitation */ ||
    603. 

  603.        ptime->month == 0    ||  ptime->month > 12  ||
    604. 

  604.        ptime->day   == 0    ||  ptime->day   > 31  ||
    605. 

  605.        ptime->hour  > 23    ||  ptime->minute > 59 ||
    606. 

  606.        ptime->second > 60)
    607. 

  607.    {
    608. 

  608.       png_warning(png_ptr, "Ignoring invalid time value");
    609. 

  609.       return (NULL);
    610. 

  610.    }
    611. 

  611. 

  612.    {
    613. 

  613.       size_t pos = 0;
    614. 

  614.       char number_buf[5]; /* enough for a four-digit year */
    615. 

  615. 

  616. #     define APPEND_STRING(string)\
    617. 

  617.          pos = png_safecat(png_ptr->time_buffer, sizeof png_ptr->time_buffer,\
    618. 

  618.             pos, (string))
    619. 

  619. #     define APPEND_NUMBER(format, value)\
    620. 

  620.          APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
    621. 

  621. #     define APPEND(ch)\
    622. 

  622.          if (pos < (sizeof png_ptr->time_buffer)-1)\
    623. 

  623.             png_ptr->time_buffer[pos++] = (ch)
    624. 

  624. 

  625.       APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
    626. 

  626.       APPEND(' ');
    627. 

  627.       APPEND_STRING(short_months[(ptime->month - 1)]);
    628. 

  628.       APPEND(' ');
    629. 

  629.       APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
    630. 

  630.       APPEND(' ');
    631. 

  631.       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
    632. 

  632.       APPEND(':');
    633. 

  633.       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
    634. 

  634.       APPEND(':');
    635. 

  635.       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
    636. 

  636.       APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
    637. 

  637. 

  638. #     undef APPEND
    639. 

  639. #     undef APPEND_NUMBER
    640. 

  640. #     undef APPEND_STRING
    641. 

  641.    }
    642. 

  642. 

  643.    return png_ptr->time_buffer;
    644. 

  644. }
    645. 

  645. #  endif /* PNG_TIME_RFC1123_SUPPORTED */
    646. 

  646. 

  647. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
    648. 

  648. 

  649. png_const_charp PNGAPI
    650. 

  650. png_get_copyright(png_const_structp png_ptr)
    651. 

  651. {
    652. 

  652.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
    653. 

  653. #ifdef PNG_STRING_COPYRIGHT
    654. 

  654.    return PNG_STRING_COPYRIGHT
    655. 

  655. #else
    656. 

  656. #  ifdef __STDC__
    657. 

  657.    return PNG_STRING_NEWLINE \
    658. 

  658.      "libpng version 1.5.9 - February 18, 2012" PNG_STRING_NEWLINE \
    659. 

  659.      "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
    660. 

  660.      "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
    661. 

  661.      "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
    662. 

  662.      PNG_STRING_NEWLINE;
    663. 

  663. #  else
    664. 

  664.       return "libpng version 1.5.9 - February 18, 2012\
    665. 

  665.       Copyright (c) 1998-2011 Glenn Randers-Pehrson\
    666. 

  666.       Copyright (c) 1996-1997 Andreas Dilger\
    667. 

  667.       Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
    668. 

  668. #  endif
    669. 

  669. #endif
    670. 

  670. }
    671. 

  671. 

  672. /* The following return the library version as a short string in the
    673. 

  673.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
    674. 

  674.  * used with your application, print out PNG_LIBPNG_VER_STRING, which
    675. 

  675.  * is defined in png.h.
    676. 

  676.  * Note: now there is no difference between png_get_libpng_ver() and
    677. 

  677.  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
    678. 

  678.  * it is guaranteed that png.c uses the correct version of png.h.
    679. 

  679.  */
    680. 

  680. png_const_charp PNGAPI
    681. 

  681. png_get_libpng_ver(png_const_structp png_ptr)
    682. 

  682. {
    683. 

  683.    /* Version of *.c files used when building libpng */
    684. 

  684.    return png_get_header_ver(png_ptr);
    685. 

  685. }
    686. 

  686. 

  687. png_const_charp PNGAPI
    688. 

  688. png_get_header_ver(png_const_structp png_ptr)
    689. 

  689. {
    690. 

  690.    /* Version of *.h files used when building libpng */
    691. 

  691.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
    692. 

  692.    return PNG_LIBPNG_VER_STRING;
    693. 

  693. }
    694. 

  694. 

  695. png_const_charp PNGAPI
    696. 

  696. png_get_header_version(png_const_structp png_ptr)
    697. 

  697. {
    698. 

  698.    /* Returns longer string containing both version and date */
    699. 

  699.    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
    700. 

  700. #ifdef __STDC__
    701. 

  701.    return PNG_HEADER_VERSION_STRING
    702. 

  702. #  ifndef PNG_READ_SUPPORTED
    703. 

  703.    "     (NO READ SUPPORT)"
    704. 

  704. #  endif
    705. 

  705.    PNG_STRING_NEWLINE;
    706. 

  706. #else
    707. 

  707.    return PNG_HEADER_VERSION_STRING;
    708. 

  708. #endif
    709. 

  709. }
    710. 

  710. 

  711. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    712. 

  712. int PNGAPI
    713. 

  713. png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name)
    714. 

  714. {
    715. 

  715.    /* Check chunk_name and return "keep" value if it's on the list, else 0 */
    716. 

  716.    png_const_bytep p, p_end;
    717. 

  717. 

  718.    if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list <= 0)
    719. 

  719.       return PNG_HANDLE_CHUNK_AS_DEFAULT;
    720. 

  720. 

  721.    p_end = png_ptr->chunk_list;
    722. 

  722.    p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
    723. 

  723. 

  724.    /* The code is the fifth byte after each four byte string.  Historically this
    725. 

  725.     * code was always searched from the end of the list, so it should continue
    726. 

  726.     * to do so in case there are duplicated entries.
    727. 

  727.     */
    728. 

  728.    do /* num_chunk_list > 0, so at least one */
    729. 

  729.    {
    730. 

  730.       p -= 5;
    731. 

  731.       if (!png_memcmp(chunk_name, p, 4))
    732. 

  732.          return p[4];
    733. 

  733.    }
    734. 

  734.    while (p > p_end);
    735. 

  735. 

  736.    return PNG_HANDLE_CHUNK_AS_DEFAULT;
    737. 

  737. }
    738. 

  738. 

  739. int /* PRIVATE */
    740. 

  740. png_chunk_unknown_handling(png_structp png_ptr, png_uint_32 chunk_name)
    741. 

  741. {
    742. 

  742.    png_byte chunk_string[5];
    743. 

  743. 

  744.    PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
    745. 

  745.    return png_handle_as_unknown(png_ptr, chunk_string);
    746. 

  746. }
    747. 

  747. #endif
    748. 

  748. 

  749. #ifdef PNG_READ_SUPPORTED
    750. 

  750. /* This function, added to libpng-1.0.6g, is untested. */
    751. 

  751. int PNGAPI
    752. 

  752. png_reset_zstream(png_structp png_ptr)
    753. 

  753. {
    754. 

  754.    if (png_ptr == NULL)
    755. 

  755.       return Z_STREAM_ERROR;
    756. 

  756. 

  757.    return (inflateReset(&png_ptr->zstream));
    758. 

  758. }
    759. 

  759. #endif /* PNG_READ_SUPPORTED */
    760. 

  760. 

  761. /* This function was added to libpng-1.0.7 */
    762. 

  762. png_uint_32 PNGAPI
    763. 

  763. png_access_version_number(void)
    764. 

  764. {
    765. 

  765.    /* Version of *.c files used when building libpng */
    766. 

  766.    return((png_uint_32)PNG_LIBPNG_VER);
    767. 

  767. }
    768. 

  768. 

  769. 

  770. 

  771. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
    772. 

  772. /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
    773. 

  773.  * at libpng 1.5.5!
    774. 

  774.  */
    775. 

  775. 

  776. /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
    777. 

  777. #  ifdef PNG_CHECK_cHRM_SUPPORTED
    778. 

  778. 

  779. int /* PRIVATE */
    780. 

  780. png_check_cHRM_fixed(png_structp png_ptr,
    781. 

  781.    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
    782. 

  782.    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
    783. 

  783.    png_fixed_point blue_x, png_fixed_point blue_y)
    784. 

  784. {
    785. 

  785.    int ret = 1;
    786. 

  786.    unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
    787. 

  787. 

  788.    png_debug(1, "in function png_check_cHRM_fixed");
    789. 

  789. 

  790.    if (png_ptr == NULL)
    791. 

  791.       return 0;
    792. 

  792. 

  793.    /* (x,y,z) values are first limited to 0..100000 (PNG_FP_1), the white
    794. 

  794.     * y must also be greater than 0.  To test for the upper limit calculate
    795. 

  795.     * (PNG_FP_1-y) - x must be <= to this for z to be >= 0 (and the expression
    796. 

  796.     * cannot overflow.)  At this point we know x and y are >= 0 and (x+y) is
    797. 

  797.     * <= PNG_FP_1.  The previous test on PNG_MAX_UINT_31 is removed because it
    798. 

  798.     * pointless (and it produces compiler warnings!)
    799. 

  799.     */
    800. 

  800.    if (white_x < 0 || white_y <= 0 ||
    801. 

  801.          red_x < 0 ||   red_y <  0 ||
    802. 

  802.        green_x < 0 || green_y <  0 ||
    803. 

  803.         blue_x < 0 ||  blue_y <  0)
    804. 

  804.    {
    805. 

  805.       png_warning(png_ptr,
    806. 

  806.         "Ignoring attempt to set negative chromaticity value");
    807. 

  807.       ret = 0;
    808. 

  808.    }
    809. 

  809.    /* And (x+y) must be <= PNG_FP_1 (so z is >= 0) */
    810. 

  810.    if (white_x > PNG_FP_1 - white_y)
    811. 

  811.    {
    812. 

  812.       png_warning(png_ptr, "Invalid cHRM white point");
    813. 

  813.       ret = 0;
    814. 

  814.    }
    815. 

  815. 

  816.    if (red_x > PNG_FP_1 - red_y)
    817. 

  817.    {
    818. 

  818.       png_warning(png_ptr, "Invalid cHRM red point");
    819. 

  819.       ret = 0;
    820. 

  820.    }
    821. 

  821. 

  822.    if (green_x > PNG_FP_1 - green_y)
    823. 

  823.    {
    824. 

  824.       png_warning(png_ptr, "Invalid cHRM green point");
    825. 

  825.       ret = 0;
    826. 

  826.    }
    827. 

  827. 

  828.    if (blue_x > PNG_FP_1 - blue_y)
    829. 

  829.    {
    830. 

  830.       png_warning(png_ptr, "Invalid cHRM blue point");
    831. 

  831.       ret = 0;
    832. 

  832.    }
    833. 

  833. 

  834.    png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
    835. 

  835.    png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
    836. 

  836. 

  837.    if (xy_hi == yx_hi && xy_lo == yx_lo)
    838. 

  838.    {
    839. 

  839.       png_warning(png_ptr,
    840. 

  840.          "Ignoring attempt to set cHRM RGB triangle with zero area");
    841. 

  841.       ret = 0;
    842. 

  842.    }
    843. 

  843. 

  844.    return ret;
    845. 

  845. }
    846. 

  846. #  endif /* PNG_CHECK_cHRM_SUPPORTED */
    847. 

  847. 

  848. #ifdef PNG_cHRM_SUPPORTED
    849. 

  849. /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
    850. 

  850.  * cHRM, as opposed to using chromaticities.  These internal APIs return
    851. 

  851.  * non-zero on a parameter error.  The X, Y and Z values are required to be
    852. 

  852.  * positive and less than 1.0.
    853. 

  853.  */
    854. 

  854. int png_xy_from_XYZ(png_xy *xy, png_XYZ XYZ)
    855. 

  855. {
    856. 

  856.    png_int_32 d, dwhite, whiteX, whiteY;
    857. 

  857. 

  858.    d = XYZ.redX + XYZ.redY + XYZ.redZ;
    859. 

  859.    if (!png_muldiv(&xy->redx, XYZ.redX, PNG_FP_1, d)) return 1;
    860. 

  860.    if (!png_muldiv(&xy->redy, XYZ.redY, PNG_FP_1, d)) return 1;
    861. 

  861.    dwhite = d;
    862. 

  862.    whiteX = XYZ.redX;
    863. 

  863.    whiteY = XYZ.redY;
    864. 

  864. 

  865.    d = XYZ.greenX + XYZ.greenY + XYZ.greenZ;
    866. 

  866.    if (!png_muldiv(&xy->greenx, XYZ.greenX, PNG_FP_1, d)) return 1;
    867. 

  867.    if (!png_muldiv(&xy->greeny, XYZ.greenY, PNG_FP_1, d)) return 1;
    868. 

  868.    dwhite += d;
    869. 

  869.    whiteX += XYZ.greenX;
    870. 

  870.    whiteY += XYZ.greenY;
    871. 

  871. 

  872.    d = XYZ.blueX + XYZ.blueY + XYZ.blueZ;
    873. 

  873.    if (!png_muldiv(&xy->bluex, XYZ.blueX, PNG_FP_1, d)) return 1;
    874. 

  874.    if (!png_muldiv(&xy->bluey, XYZ.blueY, PNG_FP_1, d)) return 1;
    875. 

  875.    dwhite += d;
    876. 

  876.    whiteX += XYZ.blueX;
    877. 

  877.    whiteY += XYZ.blueY;
    878. 

  878. 

  879.    /* The reference white is simply the same of the end-point (X,Y,Z) vectors,
    880. 

  880.     * thus:
    881. 

  881.     */
    882. 

  882.    if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1;
    883. 

  883.    if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1;
    884. 

  884. 

  885.    return 0;
    886. 

  886. }
    887. 

  887. 

  888. int png_XYZ_from_xy(png_XYZ *XYZ, png_xy xy)
    889. 

  889. {
    890. 

  890.    png_fixed_point red_inverse, green_inverse, blue_scale;
    891. 

  891.    png_fixed_point left, right, denominator;
    892. 

  892. 

  893.    /* Check xy and, implicitly, z.  Note that wide gamut color spaces typically
    894. 

  894.     * have end points with 0 tristimulus values (these are impossible end
    895. 

  895.     * points, but they are used to cover the possible colors.)
    896. 

  896.     */
    897. 

  897.    if (xy.redx < 0 || xy.redx > PNG_FP_1) return 1;
    898. 

  898.    if (xy.redy < 0 || xy.redy > PNG_FP_1-xy.redx) return 1;
    899. 

  899.    if (xy.greenx < 0 || xy.greenx > PNG_FP_1) return 1;
    900. 

  900.    if (xy.greeny < 0 || xy.greeny > PNG_FP_1-xy.greenx) return 1;
    901. 

  901.    if (xy.bluex < 0 || xy.bluex > PNG_FP_1) return 1;
    902. 

  902.    if (xy.bluey < 0 || xy.bluey > PNG_FP_1-xy.bluex) return 1;
    903. 

  903.    if (xy.whitex < 0 || xy.whitex > PNG_FP_1) return 1;
    904. 

  904.    if (xy.whitey < 0 || xy.whitey > PNG_FP_1-xy.whitex) return 1;
    905. 

  905. 

  906.    /* The reverse calculation is more difficult because the original tristimulus
    907. 

  907.     * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
    908. 

  908.     * derived values were recorded in the cHRM chunk;
    909. 

  909.     * (red,green,blue,white)x(x,y).  This loses one degree of freedom and
    910. 

  910.     * therefore an arbitrary ninth value has to be introduced to undo the
    911. 

  911.     * original transformations.
    912. 

  912.     *
    913. 

  913.     * Think of the original end-points as points in (X,Y,Z) space.  The
    914. 

  914.     * chromaticity values (c) have the property:
    915. 

  915.     *
    916. 

  916.     *           C
    917. 

  917.     *   c = ---------
    918. 

  918.     *       X + Y + Z
    919. 

  919.     *
    920. 

  920.     * For each c (x,y,z) from the corresponding original C (X,Y,Z).  Thus the
    921. 

  921.     * three chromaticity values (x,y,z) for each end-point obey the
    922. 

  922.     * relationship:
    923. 

  923.     *
    924. 

  924.     *   x + y + z = 1
    925. 

  925.     *
    926. 

  926.     * This describes the plane in (X,Y,Z) space that intersects each axis at the
    927. 

  927.     * value 1.0; call this the chromaticity plane.  Thus the chromaticity
    928. 

  928.     * calculation has scaled each end-point so that it is on the x+y+z=1 plane
    929. 

  929.     * and chromaticity is the intersection of the vector from the origin to the
    930. 

  930.     * (X,Y,Z) value with the chromaticity plane.
    931. 

  931.     *
    932. 

  932.     * To fully invert the chromaticity calculation we would need the three
    933. 

  933.     * end-point scale factors, (red-scale, green-scale, blue-scale), but these
    934. 

  934.     * were not recorded.  Instead we calculated the reference white (X,Y,Z) and
    935. 

  935.     * recorded the chromaticity of this.  The reference white (X,Y,Z) would have
    936. 

  936.     * given all three of the scale factors since:
    937. 

  937.     *
    938. 

  938.     *    color-C = color-c * color-scale
    939. 

  939.     *    white-C = red-C + green-C + blue-C
    940. 

  940.     *            = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
    941. 

  941.     *
    942. 

  942.     * But cHRM records only white-x and white-y, so we have lost the white scale
    943. 

  943.     * factor:
    944. 

  944.     *
    945. 

  945.     *    white-C = white-c*white-scale
    946. 

  946.     *
    947. 

  947.     * To handle this the inverse transformation makes an arbitrary assumption
    948. 

  948.     * about white-scale:
    949. 

  949.     *
    950. 

  950.     *    Assume: white-Y = 1.0
    951. 

  951.     *    Hence:  white-scale = 1/white-y
    952. 

  952.     *    Or:     red-Y + green-Y + blue-Y = 1.0
    953. 

  953.     *
    954. 

  954.     * Notice the last statement of the assumption gives an equation in three of
    955. 

  955.     * the nine values we want to calculate.  8 more equations come from the
    956. 

  956.     * above routine as summarised at the top above (the chromaticity
    957. 

  957.     * calculation):
    958. 

  958.     *
    959. 

  959.     *    Given: color-x = color-X / (color-X + color-Y + color-Z)
    960. 

  960.     *    Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
    961. 

  961.     *
    962. 

  962.     * This is 9 simultaneous equations in the 9 variables "color-C" and can be
    963. 

  963.     * solved by Cramer's rule.  Cramer's rule requires calculating 10 9x9 matrix
    964. 

  964.     * determinants, however this is not as bad as it seems because only 28 of
    965. 

  965.     * the total of 90 terms in the various matrices are non-zero.  Nevertheless
    966. 

  966.     * Cramer's rule is notoriously numerically unstable because the determinant
    967. 

  967.     * calculation involves the difference of large, but similar, numbers.  It is
    968. 

  968.     * difficult to be sure that the calculation is stable for real world values
    969. 

  969.     * and it is certain that it becomes unstable where the end points are close
    970. 

  970.     * together.
    971. 

  971.     *
    972. 

  972.     * So this code uses the perhaps slighly less optimal but more understandable
    973. 

  973.     * and totally obvious approach of calculating color-scale.
    974. 

  974.     *
    975. 

  975.     * This algorithm depends on the precision in white-scale and that is
    976. 

  976.     * (1/white-y), so we can immediately see that as white-y approaches 0 the
    977. 

  977.     * accuracy inherent in the cHRM chunk drops off substantially.
    978. 

  978.     *
    979. 

  979.     * libpng arithmetic: a simple invertion of the above equations
    980. 

  980.     * ------------------------------------------------------------
    981. 

  981.     *
    982. 

  982.     *    white_scale = 1/white-y
    983. 

  983.     *    white-X = white-x * white-scale
    984. 

  984.     *    white-Y = 1.0
    985. 

  985.     *    white-Z = (1 - white-x - white-y) * white_scale
    986. 

  986.     *
    987. 

  987.     *    white-C = red-C + green-C + blue-C
    988. 

  988.     *            = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
    989. 

  989.     *
    990. 

  990.     * This gives us three equations in (red-scale,green-scale,blue-scale) where
    991. 

  991.     * all the coefficients are now known:
    992. 

  992.     *
    993. 

  993.     *    red-x*red-scale + green-x*green-scale + blue-x*blue-scale
    994. 

  994.     *       = white-x/white-y
    995. 

  995.     *    red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
    996. 

  996.     *    red-z*red-scale + green-z*green-scale + blue-z*blue-scale
    997. 

  997.     *       = (1 - white-x - white-y)/white-y
    998. 

  998.     *
    999. 

  999.     * In the last equation color-z is (1 - color-x - color-y) so we can add all
    1000. 

  1000.     * three equations together to get an alternative third:
    1001. 

  1001.     *
    1002. 

  1002.     *    red-scale + green-scale + blue-scale = 1/white-y = white-scale
    1003. 

  1003.     *
    1004. 

  1004.     * So now we have a Cramer's rule solution where the determinants are just
    1005. 

  1005.     * 3x3 - far more tractible.  Unfortunately 3x3 determinants still involve
    1006. 

  1006.     * multiplication of three coefficients so we can't guarantee to avoid
    1007. 

  1007.     * overflow in the libpng fixed point representation.  Using Cramer's rule in
    1008. 

  1008.     * floating point is probably a good choice here, but it's not an option for
    1009. 

  1009.     * fixed point.  Instead proceed to simplify the first two equations by
    1010. 

  1010.     * eliminating what is likely to be the largest value, blue-scale:
    1011. 

  1011.     *
    1012. 

  1012.     *    blue-scale = white-scale - red-scale - green-scale
    1013. 

  1013.     *
    1014. 

  1014.     * Hence:
    1015. 

  1015.     *
    1016. 

  1016.     *    (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
    1017. 

  1017.     *                (white-x - blue-x)*white-scale
    1018. 

  1018.     *
    1019. 

  1019.     *    (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
    1020. 

  1020.     *                1 - blue-y*white-scale
    1021. 

  1021.     *
    1022. 

  1022.     * And now we can trivially solve for (red-scale,green-scale):
    1023. 

  1023.     *
    1024. 

  1024.     *    green-scale =
    1025. 

  1025.     *                (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
    1026. 

  1026.     *                -----------------------------------------------------------
    1027. 

  1027.     *                                  green-x - blue-x
    1028. 

  1028.     *
    1029. 

  1029.     *    red-scale =
    1030. 

  1030.     *                1 - blue-y*white-scale - (green-y - blue-y) * green-scale
    1031. 

  1031.     *                ---------------------------------------------------------
    1032. 

  1032.     *                                  red-y - blue-y
    1033. 

  1033.     *
    1034. 

  1034.     * Hence:
    1035. 

  1035.     *
    1036. 

  1036.     *    red-scale =
    1037. 

  1037.     *          ( (green-x - blue-x) * (white-y - blue-y) -
    1038. 

  1038.     *            (green-y - blue-y) * (white-x - blue-x) ) / white-y
    1039. 

  1039.     * -------------------------------------------------------------------------
    1040. 

  1040.     *  (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
    1041. 

  1041.     *
    1042. 

  1042.     *    green-scale =
    1043. 

  1043.     *          ( (red-y - blue-y) * (white-x - blue-x) -
    1044. 

  1044.     *            (red-x - blue-x) * (white-y - blue-y) ) / white-y
    1045. 

  1045.     * -------------------------------------------------------------------------
    1046. 

  1046.     *  (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
    1047. 

  1047.     *
    1048. 

  1048.     * Accuracy:
    1049. 

  1049.     * The input values have 5 decimal digits of accuracy.  The values are all in
    1050. 

  1050.     * the range 0 < value < 1, so simple products are in the same range but may
    1051. 

  1051.     * need up to 10 decimal digits to preserve the original precision and avoid
    1052. 

  1052.     * underflow.  Because we are using a 32-bit signed representation we cannot
    1053. 

  1053.     * match this; the best is a little over 9 decimal digits, less than 10.
    1054. 

  1054.     *
    1055. 

  1055.     * The approach used here is to preserve the maximum precision within the
    1056. 

  1056.     * signed representation.  Because the red-scale calculation above uses the
    1057. 

  1057.     * difference between two products of values that must be in the range -1..+1
    1058. 

  1058.     * it is sufficient to divide the product by 7; ceil(100,000/32767*2).  The
    1059. 

  1059.     * factor is irrelevant in the calculation because it is applied to both
    1060. 

  1060.     * numerator and denominator.
    1061. 

  1061.     *
    1062. 

  1062.     * Note that the values of the differences of the products of the
    1063. 

  1063.     * chromaticities in the above equations tend to be small, for example for
    1064. 

  1064.     * the sRGB chromaticities they are:
    1065. 

  1065.     *
    1066. 

  1066.     * red numerator:    -0.04751
    1067. 

  1067.     * green numerator:  -0.08788
    1068. 

  1068.     * denominator:      -0.2241 (without white-y multiplication)
    1069. 

  1069.     *
    1070. 

  1070.     *  The resultant Y coefficients from the chromaticities of some widely used
    1071. 

  1071.     *  color space definitions are (to 15 decimal places):
    1072. 

  1072.     *
    1073. 

  1073.     *  sRGB
    1074. 

  1074.     *    0.212639005871510 0.715168678767756 0.072192315360734
    1075. 

  1075.     *  Kodak ProPhoto
    1076. 

  1076.     *    0.288071128229293 0.711843217810102 0.000085653960605
    1077. 

  1077.     *  Adobe RGB
    1078. 

  1078.     *    0.297344975250536 0.627363566255466 0.075291458493998
    1079. 

  1079.     *  Adobe Wide Gamut RGB
    1080. 

  1080.     *    0.258728243040113 0.724682314948566 0.016589442011321
    1081. 

  1081.     */
    1082. 

  1082.    /* By the argument, above overflow should be impossible here. The return
    1083. 

  1083.     * value of 2 indicates an internal error to the caller.
    1084. 

  1084.     */
    1085. 

  1085.    if (!png_muldiv(&left, xy.greenx-xy.bluex, xy.redy - xy.bluey, 7)) return 2;
    1086. 

  1086.    if (!png_muldiv(&right, xy.greeny-xy.bluey, xy.redx - xy.bluex, 7)) return 2;
    1087. 

  1087.    denominator = left - right;
    1088. 

  1088. 

  1089.    /* Now find the red numerator. */
    1090. 

  1090.    if (!png_muldiv(&left, xy.greenx-xy.bluex, xy.whitey-xy.bluey, 7)) return 2;
    1091. 

  1091.    if (!png_muldiv(&right, xy.greeny-xy.bluey, xy.whitex-xy.bluex, 7)) return 2;
    1092. 

  1092. 

  1093.    /* Overflow is possible here and it indicates an extreme set of PNG cHRM
    1094. 

  1094.     * chunk values.  This calculation actually returns the reciprocal of the
    1095. 

  1095.     * scale value because this allows us to delay the multiplication of white-y
    1096. 

  1096.     * into the denominator, which tends to produce a small number.
    1097. 

  1097.     */
    1098. 

  1098.    if (!png_muldiv(&red_inverse, xy.whitey, denominator, left-right) ||
    1099. 

  1099.        red_inverse <= xy.whitey /* r+g+b scales = white scale */)
    1100. 

  1100.       return 1;
    1101. 

  1101. 

  1102.    /* Similarly for green_inverse: */
    1103. 

  1103.    if (!png_muldiv(&left, xy.redy-xy.bluey, xy.whitex-xy.bluex, 7)) return 2;
    1104. 

  1104.    if (!png_muldiv(&right, xy.redx-xy.bluex, xy.whitey-xy.bluey, 7)) return 2;
    1105. 

  1105.    if (!png_muldiv(&green_inverse, xy.whitey, denominator, left-right) ||
    1106. 

  1106.        green_inverse <= xy.whitey)
    1107. 

  1107.       return 1;
    1108. 

  1108. 

  1109.    /* And the blue scale, the checks above guarantee this can't overflow but it
    1110. 

  1110.     * can still produce 0 for extreme cHRM values.
    1111. 

  1111.     */
    1112. 

  1112.    blue_scale = png_reciprocal(xy.whitey) - png_reciprocal(red_inverse) -
    1113. 

  1113.       png_reciprocal(green_inverse);
    1114. 

  1114.    if (blue_scale <= 0) return 1;
    1115. 

  1115. 

  1116. 

  1117.    /* And fill in the png_XYZ: */
    1118. 

  1118.    if (!png_muldiv(&XYZ->redX, xy.redx, PNG_FP_1, red_inverse)) return 1;
    1119. 

  1119.    if (!png_muldiv(&XYZ->redY, xy.redy, PNG_FP_1, red_inverse)) return 1;
    1120. 

  1120.    if (!png_muldiv(&XYZ->redZ, PNG_FP_1 - xy.redx - xy.redy, PNG_FP_1,
    1121. 

  1121.       red_inverse))
    1122. 

  1122.       return 1;
    1123. 

  1123. 

  1124.    if (!png_muldiv(&XYZ->greenX, xy.greenx, PNG_FP_1, green_inverse)) return 1;
    1125. 

  1125.    if (!png_muldiv(&XYZ->greenY, xy.greeny, PNG_FP_1, green_inverse)) return 1;
    1126. 

  1126.    if (!png_muldiv(&XYZ->greenZ, PNG_FP_1 - xy.greenx - xy.greeny, PNG_FP_1,
    1127. 

  1127.       green_inverse))
    1128. 

  1128.       return 1;
    1129. 

  1129. 

  1130.    if (!png_muldiv(&XYZ->blueX, xy.bluex, blue_scale, PNG_FP_1)) return 1;
    1131. 

  1131.    if (!png_muldiv(&XYZ->blueY, xy.bluey, blue_scale, PNG_FP_1)) return 1;
    1132. 

  1132.    if (!png_muldiv(&XYZ->blueZ, PNG_FP_1 - xy.bluex - xy.bluey, blue_scale,
    1133. 

  1133.       PNG_FP_1))
    1134. 

  1134.       return 1;
    1135. 

  1135. 

  1136.    return 0; /*success*/
    1137. 

  1137. }
    1138. 

  1138. 

  1139. int png_XYZ_from_xy_checked(png_structp png_ptr, png_XYZ *XYZ, png_xy xy)
    1140. 

  1140. {
    1141. 

  1141.    switch (png_XYZ_from_xy(XYZ, xy))
    1142. 

  1142.    {
    1143. 

  1143.       case 0: /* success */
    1144. 

  1144.          return 1;
    1145. 

  1145. 

  1146.       case 1:
    1147. 

  1147.          /* The chunk may be technically valid, but we got png_fixed_point
    1148. 

  1148.           * overflow while trying to get XYZ values out of it.  This is
    1149. 

  1149.           * entirely benign - the cHRM chunk is pretty extreme.
    1150. 

  1150.           */
    1151. 

  1151.          png_warning(png_ptr,
    1152. 

  1152.             "extreme cHRM chunk cannot be converted to tristimulus values");
    1153. 

  1153.          break;
    1154. 

  1154. 

  1155.       default:
    1156. 

  1156.          /* libpng is broken; this should be a warning but if it happens we
    1157. 

  1157.           * want error reports so for the moment it is an error.
    1158. 

  1158.           */
    1159. 

  1159.          png_error(png_ptr, "internal error in png_XYZ_from_xy");
    1160. 

  1160.          break;
    1161. 

  1161.    }
    1162. 

  1162. 

  1163.    /* ERROR RETURN */
    1164. 

  1164.    return 0;
    1165. 

  1165. }
    1166. 

  1166. #endif
    1167. 

  1167. 

  1168. void /* PRIVATE */
    1169. 

  1169. png_check_IHDR(png_structp png_ptr,
    1170. 

  1170.    png_uint_32 width, png_uint_32 height, int bit_depth,
    1171. 

  1171.    int color_type, int interlace_type, int compression_type,
    1172. 

  1172.    int filter_type)
    1173. 

  1173. {
    1174. 

  1174.    int error = 0;
    1175. 

  1175. 

  1176.    /* Check for width and height valid values */
    1177. 

  1177.    if (width == 0)
    1178. 

  1178.    {
    1179. 

  1179.       png_warning(png_ptr, "Image width is zero in IHDR");
    1180. 

  1180.       error = 1;
    1181. 

  1181.    }
    1182. 

  1182. 

  1183.    if (height == 0)
    1184. 

  1184.    {
    1185. 

  1185.       png_warning(png_ptr, "Image height is zero in IHDR");
    1186. 

  1186.       error = 1;
    1187. 

  1187.    }
    1188. 

  1188. 

  1189. #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
    1190. 

  1190.    if (width > png_ptr->user_width_max)
    1191. 

  1191. 

  1192. #  else
    1193. 

  1193.    if (width > PNG_USER_WIDTH_MAX)
    1194. 

  1194. #  endif
    1195. 

  1195.    {
    1196. 

  1196.       png_warning(png_ptr, "Image width exceeds user limit in IHDR");
    1197. 

  1197.       error = 1;
    1198. 

  1198.    }
    1199. 

  1199. 

  1200. #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
    1201. 

  1201.    if (height > png_ptr->user_height_max)
    1202. 

  1202. #  else
    1203. 

  1203.    if (height > PNG_USER_HEIGHT_MAX)
    1204. 

  1204. #  endif
    1205. 

  1205.    {
    1206. 

  1206.       png_warning(png_ptr, "Image height exceeds user limit in IHDR");
    1207. 

  1207.       error = 1;
    1208. 

  1208.    }
    1209. 

  1209. 

  1210.    if (width > PNG_UINT_31_MAX)
    1211. 

  1211.    {
    1212. 

  1212.       png_warning(png_ptr, "Invalid image width in IHDR");
    1213. 

  1213.       error = 1;
    1214. 

  1214.    }
    1215. 

  1215. 

  1216.    if (height > PNG_UINT_31_MAX)
    1217. 

  1217.    {
    1218. 

  1218.       png_warning(png_ptr, "Invalid image height in IHDR");
    1219. 

  1219.       error = 1;
    1220. 

  1220.    }
    1221. 

  1221. 

  1222.    if (width > (PNG_UINT_32_MAX
    1223. 

  1223.                  >> 3)      /* 8-byte RGBA pixels */
    1224. 

  1224.                  - 48       /* bigrowbuf hack */
    1225. 

  1225.                  - 1        /* filter byte */
    1226. 

  1226.                  - 7*8      /* rounding of width to multiple of 8 pixels */
    1227. 

  1227.                  - 8)       /* extra max_pixel_depth pad */
    1228. 

  1228.       png_warning(png_ptr, "Width is too large for libpng to process pixels");
    1229. 

  1229. 

  1230.    /* Check other values */
    1231. 

  1231.    if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
    1232. 

  1232.        bit_depth != 8 && bit_depth != 16)
    1233. 

  1233.    {
    1234. 

  1234.       png_warning(png_ptr, "Invalid bit depth in IHDR");
    1235. 

  1235.       error = 1;
    1236. 

  1236.    }
    1237. 

  1237. 

  1238.    if (color_type < 0 || color_type == 1 ||
    1239. 

  1239.        color_type == 5 || color_type > 6)
    1240. 

  1240.    {
    1241. 

  1241.       png_warning(png_ptr, "Invalid color type in IHDR");
    1242. 

  1242.       error = 1;
    1243. 

  1243.    }
    1244. 

  1244. 

  1245.    if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
    1246. 

  1246.        ((color_type == PNG_COLOR_TYPE_RGB ||
    1247. 

  1247.          color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
    1248. 

  1248.          color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
    1249. 

  1249.    {
    1250. 

  1250.       png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
    1251. 

  1251.       error = 1;
    1252. 

  1252.    }
    1253. 

  1253. 

  1254.    if (interlace_type >= PNG_INTERLACE_LAST)
    1255. 

  1255.    {
    1256. 

  1256.       png_warning(png_ptr, "Unknown interlace method in IHDR");
    1257. 

  1257.       error = 1;
    1258. 

  1258.    }
    1259. 

  1259. 

  1260.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
    1261. 

  1261.    {
    1262. 

  1262.       png_warning(png_ptr, "Unknown compression method in IHDR");
    1263. 

  1263.       error = 1;
    1264. 

  1264.    }
    1265. 

  1265. 

  1266. #  ifdef PNG_MNG_FEATURES_SUPPORTED
    1267. 

  1267.    /* Accept filter_method 64 (intrapixel differencing) only if
    1268. 

  1268.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
    1269. 

  1269.     * 2. Libpng did not read a PNG signature (this filter_method is only
    1270. 

  1270.     *    used in PNG datastreams that are embedded in MNG datastreams) and
    1271. 

  1271.     * 3. The application called png_permit_mng_features with a mask that
    1272. 

  1272.     *    included PNG_FLAG_MNG_FILTER_64 and
    1273. 

  1273.     * 4. The filter_method is 64 and
    1274. 

  1274.     * 5. The color_type is RGB or RGBA
    1275. 

  1275.     */
    1276. 

  1276.    if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
    1277. 

  1277.        png_ptr->mng_features_permitted)
    1278. 

  1278.       png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
    1279. 

  1279. 

  1280.    if (filter_type != PNG_FILTER_TYPE_BASE)
    1281. 

  1281.    {
    1282. 

  1282.       if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
    1283. 

  1283.           (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
    1284. 

  1284.           ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
    1285. 

  1285.           (color_type == PNG_COLOR_TYPE_RGB ||
    1286. 

  1286.           color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
    1287. 

  1287.       {
    1288. 

  1288.          png_warning(png_ptr, "Unknown filter method in IHDR");
    1289. 

  1289.          error = 1;
    1290. 

  1290.       }
    1291. 

  1291. 

  1292.       if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
    1293. 

  1293.       {
    1294. 

  1294.          png_warning(png_ptr, "Invalid filter method in IHDR");
    1295. 

  1295.          error = 1;
    1296. 

  1296.       }
    1297. 

  1297.    }
    1298. 

  1298. 

  1299. #  else
    1300. 

  1300.    if (filter_type != PNG_FILTER_TYPE_BASE)
    1301. 

  1301.    {
    1302. 

  1302.       png_warning(png_ptr, "Unknown filter method in IHDR");
    1303. 

  1303.       error = 1;
    1304. 

  1304.    }
    1305. 

  1305. #  endif
    1306. 

  1306. 

  1307.    if (error == 1)
    1308. 

  1308.       png_error(png_ptr, "Invalid IHDR data");
    1309. 

  1309. }
    1310. 

  1310. 

  1311. #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
    1312. 

  1312. /* ASCII to fp functions */
    1313. 

  1313. /* Check an ASCII formated floating point value, see the more detailed
    1314. 

  1314.  * comments in pngpriv.h
    1315. 

  1315.  */
    1316. 

  1316. /* The following is used internally to preserve the sticky flags */
    1317. 

  1317. #define png_fp_add(state, flags) ((state) |= (flags))
    1318. 

  1318. #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
    1319. 

  1319. 

  1320. int /* PRIVATE */
    1321. 

  1321. png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
    1322. 

  1322.    png_size_tp whereami)
    1323. 

  1323. {
    1324. 

  1324.    int state = *statep;
    1325. 

  1325.    png_size_t i = *whereami;
    1326. 

  1326. 

  1327.    while (i < size)
    1328. 

  1328.    {
    1329. 

  1329.       int type;
    1330. 

  1330.       /* First find the type of the next character */
    1331. 

  1331.       switch (string[i])
    1332. 

  1332.       {
    1333. 

  1333.       case 43:  type = PNG_FP_SAW_SIGN;                   break;
    1334. 

  1334.       case 45:  type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
    1335. 

  1335.       case 46:  type = PNG_FP_SAW_DOT;                    break;
    1336. 

  1336.       case 48:  type = PNG_FP_SAW_DIGIT;                  break;
    1337. 

  1337.       case 49: case 50: case 51: case 52:
    1338. 

  1338.       case 53: case 54: case 55: case 56:
    1339. 

  1339.       case 57:  type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
    1340. 

  1340.       case 69:
    1341. 

  1341.       case 101: type = PNG_FP_SAW_E;                      break;
    1342. 

  1342.       default:  goto PNG_FP_End;
    1343. 

  1343.       }
    1344. 

  1344. 

  1345.       /* Now deal with this type according to the current
    1346. 

  1346.        * state, the type is arranged to not overlap the
    1347. 

  1347.        * bits of the PNG_FP_STATE.
    1348. 

  1348.        */
    1349. 

  1349.       switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
    1350. 

  1350.       {
    1351. 

  1351.       case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
    1352. 

  1352.          if (state & PNG_FP_SAW_ANY)
    1353. 

  1353.             goto PNG_FP_End; /* not a part of the number */
    1354. 

  1354. 

  1355.          png_fp_add(state, type);
    1356. 

  1356.          break;
    1357. 

  1357. 

  1358.       case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
    1359. 

  1359.          /* Ok as trailer, ok as lead of fraction. */
    1360. 

  1360.          if (state & PNG_FP_SAW_DOT) /* two dots */
    1361. 

  1361.             goto PNG_FP_End;
    1362. 

  1362. 

  1363.          else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */
    1364. 

  1364.             png_fp_add(state, type);
    1365. 

  1365. 

  1366.          else
    1367. 

  1367.             png_fp_set(state, PNG_FP_FRACTION | type);
    1368. 

  1368. 

  1369.          break;
    1370. 

  1370. 

  1371.       case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
    1372. 

  1372.          if (state & PNG_FP_SAW_DOT) /* delayed fraction */
    1373. 

  1373.             png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
    1374. 

  1374. 

  1375.          png_fp_add(state, type | PNG_FP_WAS_VALID);
    1376. 

  1376. 

  1377.          break;
    1378. 

  1378. 

  1379.       case PNG_FP_INTEGER + PNG_FP_SAW_E:
    1380. 

  1380.          if ((state & PNG_FP_SAW_DIGIT) == 0)
    1381. 

  1381.             goto PNG_FP_End;
    1382. 

  1382. 

  1383.          png_fp_set(state, PNG_FP_EXPONENT);
    1384. 

  1384. 

  1385.          break;
    1386. 

  1386. 

  1387.    /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
    1388. 

  1388.          goto PNG_FP_End; ** no sign in fraction */
    1389. 

  1389. 

  1390.    /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
    1391. 

  1391.          goto PNG_FP_End; ** Because SAW_DOT is always set */
    1392. 

  1392. 

  1393.       case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
    1394. 

  1394.          png_fp_add(state, type | PNG_FP_WAS_VALID);
    1395. 

  1395.          break;
    1396. 

  1396. 

  1397.       case PNG_FP_FRACTION + PNG_FP_SAW_E:
    1398. 

  1398.          /* This is correct because the trailing '.' on an
    1399. 

  1399.           * integer is handled above - so we can only get here
    1400. 

  1400.           * with the sequence ".E" (with no preceding digits).
    1401. 

  1401.           */
    1402. 

  1402.          if ((state & PNG_FP_SAW_DIGIT) == 0)
    1403. 

  1403.             goto PNG_FP_End;
    1404. 

  1404. 

  1405.          png_fp_set(state, PNG_FP_EXPONENT);
    1406. 

  1406. 

  1407.          break;
    1408. 

  1408. 

  1409.       case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
    1410. 

  1410.          if (state & PNG_FP_SAW_ANY)
    1411. 

  1411.             goto PNG_FP_End; /* not a part of the number */
    1412. 

  1412. 

  1413.          png_fp_add(state, PNG_FP_SAW_SIGN);
    1414. 

  1414. 

  1415.          break;
    1416. 

  1416. 

  1417.    /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
    1418. 

  1418.          goto PNG_FP_End; */
    1419. 

  1419. 

  1420.       case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
    1421. 

  1421.          png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
    1422. 

  1422. 

  1423.          break;
    1424. 

  1424. 

  1425.    /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
    1426. 

  1426.          goto PNG_FP_End; */
    1427. 

  1427. 

  1428.       default: goto PNG_FP_End; /* I.e. break 2 */
    1429. 

  1429.       }
    1430. 

  1430. 

  1431.       /* The character seems ok, continue. */
    1432. 

  1432.       ++i;
    1433. 

  1433.    }
    1434. 

  1434. 

  1435. PNG_FP_End:
    1436. 

  1436.    /* Here at the end, update the state and return the correct
    1437. 

  1437.     * return code.
    1438. 

  1438.     */
    1439. 

  1439.    *statep = state;
    1440. 

  1440.    *whereami = i;
    1441. 

  1441. 

  1442.    return (state & PNG_FP_SAW_DIGIT) != 0;
    1443. 

  1443. }
    1444. 

  1444. 

  1445. 

  1446. /* The same but for a complete string. */
    1447. 

  1447. int
    1448. 

  1448. png_check_fp_string(png_const_charp string, png_size_t size)
    1449. 

  1449. {
    1450. 

  1450.    int        state=0;
    1451. 

  1451.    png_size_t char_index=0;
    1452. 

  1452. 

  1453.    if (png_check_fp_number(string, size, &state, &char_index) &&
    1454. 

  1454.       (char_index == size || string[char_index] == 0))
    1455. 

  1455.       return state /* must be non-zero - see above */;
    1456. 

  1456. 

  1457.    return 0; /* i.e. fail */
    1458. 

  1458. }
    1459. 

  1459. #endif /* pCAL or sCAL */
    1460. 

  1460. 

  1461. #ifdef PNG_READ_sCAL_SUPPORTED
    1462. 

  1462. #  ifdef PNG_FLOATING_POINT_SUPPORTED
    1463. 

  1463. /* Utility used below - a simple accurate power of ten from an integral
    1464. 

  1464.  * exponent.
    1465. 

  1465.  */
    1466. 

  1466. static double
    1467. 

  1467. png_pow10(int power)
    1468. 

  1468. {
    1469. 

  1469.    int recip = 0;
    1470. 

  1470.    double d = 1;
    1471. 

  1471. 

  1472.    /* Handle negative exponent with a reciprocal at the end because
    1473. 

  1473.     * 10 is exact whereas .1 is inexact in base 2
    1474. 

  1474.     */
    1475. 

  1475.    if (power < 0)
    1476. 

  1476.    {
    1477. 

  1477.       if (power < DBL_MIN_10_EXP) return 0;
    1478. 

  1478.       recip = 1, power = -power;
    1479. 

  1479.    }
    1480. 

  1480. 

  1481.    if (power > 0)
    1482. 

  1482.    {
    1483. 

  1483.       /* Decompose power bitwise. */
    1484. 

  1484.       double mult = 10;
    1485. 

  1485.       do
    1486. 

  1486.       {
    1487. 

  1487.          if (power & 1) d *= mult;
    1488. 

  1488.          mult *= mult;
    1489. 

  1489.          power >>= 1;
    1490. 

  1490.       }
    1491. 

  1491.       while (power > 0);
    1492. 

  1492. 

  1493.       if (recip) d = 1/d;
    1494. 

  1494.    }
    1495. 

  1495.    /* else power is 0 and d is 1 */
    1496. 

  1496. 

  1497.    return d;
    1498. 

  1498. }
    1499. 

  1499. 

  1500. /* Function to format a floating point value in ASCII with a given
    1501. 

  1501.  * precision.
    1502. 

  1502.  */
    1503. 

  1503. void /* PRIVATE */
    1504. 

  1504. png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size,
    1505. 

  1505.     double fp, unsigned int precision)
    1506. 

  1506. {
    1507. 

  1507.    /* We use standard functions from math.h, but not printf because
    1508. 

  1508.     * that would require stdio.  The caller must supply a buffer of
    1509. 

  1509.     * sufficient size or we will png_error.  The tests on size and
    1510. 

  1510.     * the space in ascii[] consumed are indicated below.
    1511. 

  1511.     */
    1512. 

  1512.    if (precision < 1)
    1513. 

  1513.       precision = DBL_DIG;
    1514. 

  1514. 

  1515.    /* Enforce the limit of the implementation precision too. */
    1516. 

  1516.    if (precision > DBL_DIG+1)
    1517. 

  1517.       precision = DBL_DIG+1;
    1518. 

  1518. 

  1519.    /* Basic sanity checks */
    1520. 

  1520.    if (size >= precision+5) /* See the requirements below. */
    1521. 

  1521.    {
    1522. 

  1522.       if (fp < 0)
    1523. 

  1523.       {
    1524. 

  1524.          fp = -fp;
    1525. 

  1525.          *ascii++ = 45; /* '-'  PLUS 1 TOTAL 1 */
    1526. 

  1526.          --size;
    1527. 

  1527.       }
    1528. 

  1528. 

  1529.       if (fp >= DBL_MIN && fp <= DBL_MAX)
    1530. 

  1530.       {
    1531. 

  1531.          int exp_b10;       /* A base 10 exponent */
    1532. 

  1532.          double base;   /* 10^exp_b10 */
    1533. 

  1533. 

  1534.          /* First extract a base 10 exponent of the number,
    1535. 

  1535.           * the calculation below rounds down when converting
    1536. 

  1536.           * from base 2 to base 10 (multiply by log10(2) -
    1537. 

  1537.           * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
    1538. 

  1538.           * be increased.  Note that the arithmetic shift
    1539. 

  1539.           * performs a floor() unlike C arithmetic - using a
    1540. 

  1540.           * C multiply would break the following for negative
    1541. 

  1541.           * exponents.
    1542. 

  1542.           */
    1543. 

  1543.          (void)frexp(fp, &exp_b10); /* exponent to base 2 */
    1544. 

  1544. 

  1545.          exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
    1546. 

  1546. 

  1547.          /* Avoid underflow here. */
    1548. 

  1548.          base = png_pow10(exp_b10); /* May underflow */
    1549. 

  1549. 

  1550.          while (base < DBL_MIN || base < fp)
    1551. 

  1551.          {
    1552. 

  1552.             /* And this may overflow. */
    1553. 

  1553.             double test = png_pow10(exp_b10+1);
    1554. 

  1554. 

  1555.             if (test <= DBL_MAX)
    1556. 

  1556.                ++exp_b10, base = test;
    1557. 

  1557. 

  1558.             else
    1559. 

  1559.                break;
    1560. 

  1560.          }
    1561. 

  1561. 

  1562.          /* Normalize fp and correct exp_b10, after this fp is in the
    1563. 

  1563.           * range [.1,1) and exp_b10 is both the exponent and the digit
    1564. 

  1564.           * *before* which the decimal point should be inserted
    1565. 

  1565.           * (starting with 0 for the first digit).  Note that this
    1566. 

  1566.           * works even if 10^exp_b10 is out of range because of the
    1567. 

  1567.           * test on DBL_MAX above.
    1568. 

  1568.           */
    1569. 

  1569.          fp /= base;
    1570. 

  1570.          while (fp >= 1) fp /= 10, ++exp_b10;
    1571. 

  1571. 

  1572.          /* Because of the code above fp may, at this point, be
    1573. 

  1573.           * less than .1, this is ok because the code below can
    1574. 

  1574.           * handle the leading zeros this generates, so no attempt
    1575. 

  1575.           * is made to correct that here.
    1576. 

  1576.           */
    1577. 

  1577. 

  1578.          {
    1579. 

  1579.             int czero, clead, cdigits;
    1580. 

  1580.             char exponent[10];
    1581. 

  1581. 

  1582.             /* Allow up to two leading zeros - this will not lengthen
    1583. 

  1583.              * the number compared to using E-n.
    1584. 

  1584.              */
    1585. 

  1585.             if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
    1586. 

  1586.             {
    1587. 

  1587.                czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
    1588. 

  1588.                exp_b10 = 0;      /* Dot added below before first output. */
    1589. 

  1589.             }
    1590. 

  1590.             else
    1591. 

  1591.                czero = 0;    /* No zeros to add */
    1592. 

  1592. 

  1593.             /* Generate the digit list, stripping trailing zeros and
    1594. 

  1594.              * inserting a '.' before a digit if the exponent is 0.
    1595. 

  1595.              */
    1596. 

  1596.             clead = czero; /* Count of leading zeros */
    1597. 

  1597.             cdigits = 0;   /* Count of digits in list. */
    1598. 

  1598. 

  1599.             do
    1600. 

  1600.             {
    1601. 

  1601.                double d;
    1602. 

  1602. 

  1603.                fp *= 10;
    1604. 

  1604.                /* Use modf here, not floor and subtract, so that
    1605. 

  1605.                 * the separation is done in one step.  At the end
    1606. 

  1606.                 * of the loop don't break the number into parts so
    1607. 

  1607.                 * that the final digit is rounded.
    1608. 

  1608.                 */
    1609. 

  1609.                if (cdigits+czero-clead+1 < (int)precision)
    1610. 

  1610.                   fp = modf(fp, &d);
    1611. 

  1611. 

  1612.                else
    1613. 

  1613.                {
    1614. 

  1614.                   d = floor(fp + .5);
    1615. 

  1615. 

  1616.                   if (d > 9)
    1617. 

  1617.                   {
    1618. 

  1618.                      /* Rounding up to 10, handle that here. */
    1619. 

  1619.                      if (czero > 0)
    1620. 

  1620.                      {
    1621. 

  1621.                         --czero, d = 1;
    1622. 

  1622.                         if (cdigits == 0) --clead;
    1623. 

  1623.                      }
    1624. 

  1624.                      else
    1625. 

  1625.                      {
    1626. 

  1626.                         while (cdigits > 0 && d > 9)
    1627. 

  1627.                         {
    1628. 

  1628.                            int ch = *--ascii;
    1629. 

  1629. 

  1630.                            if (exp_b10 != (-1))
    1631. 

  1631.                               ++exp_b10;
    1632. 

  1632. 

  1633.                            else if (ch == 46)
    1634. 

  1634.                            {
    1635. 

  1635.                               ch = *--ascii, ++size;
    1636. 

  1636.                               /* Advance exp_b10 to '1', so that the
    1637. 

  1637.                                * decimal point happens after the
    1638. 

  1638.                                * previous digit.
    1639. 

  1639.                                */
    1640. 

  1640.                               exp_b10 = 1;
    1641. 

  1641.                            }
    1642. 

  1642. 

  1643.                            --cdigits;
    1644. 

  1644.                            d = ch - 47;  /* I.e. 1+(ch-48) */
    1645. 

  1645.                         }
    1646. 

  1646. 

  1647.                         /* Did we reach the beginning? If so adjust the
    1648. 

  1648.                          * exponent but take into account the leading
    1649. 

  1649.                          * decimal point.
    1650. 

  1650.                          */
    1651. 

  1651.                         if (d > 9)  /* cdigits == 0 */
    1652. 

  1652.                         {
    1653. 

  1653.                            if (exp_b10 == (-1))
    1654. 

  1654.                            {
    1655. 

  1655.                               /* Leading decimal point (plus zeros?), if
    1656. 

  1656.                                * we lose the decimal point here it must
    1657. 

  1657.                                * be reentered below.
    1658. 

  1658.                                */
    1659. 

  1659.                               int ch = *--ascii;
    1660. 

  1660. 

  1661.                               if (ch == 46)
    1662. 

  1662.                                  ++size, exp_b10 = 1;
    1663. 

  1663. 

  1664.                               /* Else lost a leading zero, so 'exp_b10' is
    1665. 

  1665.                                * still ok at (-1)
    1666. 

  1666.                                */
    1667. 

  1667.                            }
    1668. 

  1668.                            else
    1669. 

  1669.                               ++exp_b10;
    1670. 

  1670. 

  1671.                            /* In all cases we output a '1' */
    1672. 

  1672.                            d = 1;
    1673. 

  1673.                         }
    1674. 

  1674.                      }
    1675. 

  1675.                   }
    1676. 

  1676.                   fp = 0; /* Guarantees termination below. */
    1677. 

  1677.                }
    1678. 

  1678. 

  1679.                if (d == 0)
    1680. 

  1680.                {
    1681. 

  1681.                   ++czero;
    1682. 

  1682.                   if (cdigits == 0) ++clead;
    1683. 

  1683.                }
    1684. 

  1684.                else
    1685. 

  1685.                {
    1686. 

  1686.                   /* Included embedded zeros in the digit count. */
    1687. 

  1687.                   cdigits += czero - clead;
    1688. 

  1688.                   clead = 0;
    1689. 

  1689. 

  1690.                   while (czero > 0)
    1691. 

  1691.                   {
    1692. 

  1692.                      /* exp_b10 == (-1) means we just output the decimal
    1693. 

  1693.                       * place - after the DP don't adjust 'exp_b10' any
    1694. 

  1694.                       * more!
    1695. 

  1695.                       */
    1696. 

  1696.                      if (exp_b10 != (-1))
    1697. 

  1697.                      {
    1698. 

  1698.                         if (exp_b10 == 0) *ascii++ = 46, --size;
    1699. 

  1699.                         /* PLUS 1: TOTAL 4 */
    1700. 

  1700.                         --exp_b10;
    1701. 

  1701.                      }
    1702. 

  1702.                      *ascii++ = 48, --czero;
    1703. 

  1703.                   }
    1704. 

  1704. 

  1705.                   if (exp_b10 != (-1))
    1706. 

  1706.                   {
    1707. 

  1707.                      if (exp_b10 == 0) *ascii++ = 46, --size; /* counted
    1708. 

  1708.                                                                  above */
    1709. 

  1709.                      --exp_b10;
    1710. 

  1710.                   }
    1711. 

  1711.                   *ascii++ = (char)(48 + (int)d), ++cdigits;
    1712. 

  1712.                }
    1713. 

  1713.             }
    1714. 

  1714.             while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);
    1715. 

  1715. 

  1716.             /* The total output count (max) is now 4+precision */
    1717. 

  1717. 

  1718.             /* Check for an exponent, if we don't need one we are
    1719. 

  1719.              * done and just need to terminate the string.  At
    1720. 

  1720.              * this point exp_b10==(-1) is effectively if flag - it got
    1721. 

  1721.              * to '-1' because of the decrement after outputing
    1722. 

  1722.              * the decimal point above (the exponent required is
    1723. 

  1723.              * *not* -1!)
    1724. 

  1724.              */
    1725. 

  1725.             if (exp_b10 >= (-1) && exp_b10 <= 2)
    1726. 

  1726.             {
    1727. 

  1727.                /* The following only happens if we didn't output the
    1728. 

  1728.                 * leading zeros above for negative exponent, so this
    1729. 

  1729.                 * doest add to the digit requirement.  Note that the
    1730. 

  1730.                 * two zeros here can only be output if the two leading
    1731. 

  1731.                 * zeros were *not* output, so this doesn't increase
    1732. 

  1732.                 * the output count.
    1733. 

  1733.                 */
    1734. 

  1734.                while (--exp_b10 >= 0) *ascii++ = 48;
    1735. 

  1735. 

  1736.                *ascii = 0;
    1737. 

  1737. 

  1738.                /* Total buffer requirement (including the '\0') is
    1739. 

  1739.                 * 5+precision - see check at the start.
    1740. 

  1740.                 */
    1741. 

  1741.                return;
    1742. 

  1742.             }
    1743. 

  1743. 

  1744.             /* Here if an exponent is required, adjust size for
    1745. 

  1745.              * the digits we output but did not count.  The total
    1746. 

  1746.              * digit output here so far is at most 1+precision - no
    1747. 

  1747.              * decimal point and no leading or trailing zeros have
    1748. 

  1748.              * been output.
    1749. 

  1749.              */
    1750. 

  1750.             size -= cdigits;
    1751. 

  1751. 

  1752.             *ascii++ = 69, --size;    /* 'E': PLUS 1 TOTAL 2+precision */
    1753. 

  1753. 

  1754.             /* The following use of an unsigned temporary avoids ambiguities in
    1755. 

  1755.              * the signed arithmetic on exp_b10 and permits GCC at least to do
    1756. 

  1756.              * better optimization.
    1757. 

  1757.              */
    1758. 

  1758.             {
    1759. 

  1759.                unsigned int uexp_b10;
    1760. 

  1760. 

  1761.                if (exp_b10 < 0)
    1762. 

  1762.                {
    1763. 

  1763.                   *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
    1764. 

  1764.                   uexp_b10 = -exp_b10;
    1765. 

  1765.                }
    1766. 

  1766. 

  1767.                else
    1768. 

  1768.                   uexp_b10 = exp_b10;
    1769. 

  1769. 

  1770.                cdigits = 0;
    1771. 

  1771. 

  1772.                while (uexp_b10 > 0)
    1773. 

  1773.                {
    1774. 

  1774.                   exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
    1775. 

  1775.                   uexp_b10 /= 10;
    1776. 

  1776.                }
    1777. 

  1777.             }
    1778. 

  1778. 

  1779.             /* Need another size check here for the exponent digits, so
    1780. 

  1780.              * this need not be considered above.
    1781. 

  1781.              */
    1782. 

  1782.             if ((int)size > cdigits)
    1783. 

  1783.             {
    1784. 

  1784.                while (cdigits > 0) *ascii++ = exponent[--cdigits];
    1785. 

  1785. 

  1786.                *ascii = 0;
    1787. 

  1787. 

  1788.                return;
    1789. 

  1789.             }
    1790. 

  1790.          }
    1791. 

  1791.       }
    1792. 

  1792.       else if (!(fp >= DBL_MIN))
    1793. 

  1793.       {
    1794. 

  1794.          *ascii++ = 48; /* '0' */
    1795. 

  1795.          *ascii = 0;
    1796. 

  1796.          return;
    1797. 

  1797.       }
    1798. 

  1798.       else
    1799. 

  1799.       {
    1800. 

  1800.          *ascii++ = 105; /* 'i' */
    1801. 

  1801.          *ascii++ = 110; /* 'n' */
    1802. 

  1802.          *ascii++ = 102; /* 'f' */
    1803. 

  1803.          *ascii = 0;
    1804. 

  1804.          return;
    1805. 

  1805.       }
    1806. 

  1806.    }
    1807. 

  1807. 

  1808.    /* Here on buffer too small. */
    1809. 

  1809.    png_error(png_ptr, "ASCII conversion buffer too small");
    1810. 

  1810. }
    1811. 

  1811. 

  1812. #  endif /* FLOATING_POINT */
    1813. 

  1813. 

  1814. #  ifdef PNG_FIXED_POINT_SUPPORTED
    1815. 

  1815. /* Function to format a fixed point value in ASCII.
    1816. 

  1816.  */
    1817. 

  1817. void /* PRIVATE */
    1818. 

  1818. png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size,
    1819. 

  1819.     png_fixed_point fp)
    1820. 

  1820. {
    1821. 

  1821.    /* Require space for 10 decimal digits, a decimal point, a minus sign and a
    1822. 

  1822.     * trailing \0, 13 characters:
    1823. 

  1823.     */
    1824. 

  1824.    if (size > 12)
    1825. 

  1825.    {
    1826. 

  1826.       png_uint_32 num;
    1827. 

  1827. 

  1828.       /* Avoid overflow here on the minimum integer. */
    1829. 

  1829.       if (fp < 0)
    1830. 

  1830.          *ascii++ = 45, --size, num = -fp;
    1831. 

  1831.       else
    1832. 

  1832.          num = fp;
    1833. 

  1833. 

  1834.       if (num <= 0x80000000) /* else overflowed */
    1835. 

  1835.       {
    1836. 

  1836.          unsigned int ndigits = 0, first = 16 /* flag value */;
    1837. 

  1837.          char digits[10];
    1838. 

  1838. 

  1839.          while (num)
    1840. 

  1840.          {
    1841. 

  1841.             /* Split the low digit off num: */
    1842. 

  1842.             unsigned int tmp = num/10;
    1843. 

  1843.             num -= tmp*10;
    1844. 

  1844.             digits[ndigits++] = (char)(48 + num);
    1845. 

  1845.             /* Record the first non-zero digit, note that this is a number
    1846. 

  1846.              * starting at 1, it's not actually the array index.
    1847. 

  1847.              */
    1848. 

  1848.             if (first == 16 && num > 0)
    1849. 

  1849.                first = ndigits;
    1850. 

  1850.             num = tmp;
    1851. 

  1851.          }
    1852. 

  1852. 

  1853.          if (ndigits > 0)
    1854. 

  1854.          {
    1855. 

  1855.             while (ndigits > 5) *ascii++ = digits[--ndigits];
    1856. 

  1856.             /* The remaining digits are fractional digits, ndigits is '5' or
    1857. 

  1857.              * smaller at this point.  It is certainly not zero.  Check for a
    1858. 

  1858.              * non-zero fractional digit:
    1859. 

  1859.              */
    1860. 

  1860.             if (first <= 5)
    1861. 

  1861.             {
    1862. 

  1862.                unsigned int i;
    1863. 

  1863.                *ascii++ = 46; /* decimal point */
    1864. 

  1864.                /* ndigits may be <5 for small numbers, output leading zeros
    1865. 

  1865.                 * then ndigits digits to first:
    1866. 

  1866.                 */
    1867. 

  1867.                i = 5;
    1868. 

  1868.                while (ndigits < i) *ascii++ = 48, --i;
    1869. 

  1869.                while (ndigits >= first) *ascii++ = digits[--ndigits];
    1870. 

  1870.                /* Don't output the trailing zeros! */
    1871. 

  1871.             }
    1872. 

  1872.          }
    1873. 

  1873.          else
    1874. 

  1874.             *ascii++ = 48;
    1875. 

  1875. 

  1876.          /* And null terminate the string: */
    1877. 

  1877.          *ascii = 0;
    1878. 

  1878.          return;
    1879. 

  1879.       }
    1880. 

  1880.    }
    1881. 

  1881. 

  1882.    /* Here on buffer too small. */
    1883. 

  1883.    png_error(png_ptr, "ASCII conversion buffer too small");
    1884. 

  1884. }
    1885. 

  1885. #   endif /* FIXED_POINT */
    1886. 

  1886. #endif /* READ_SCAL */
    1887. 

  1887. 

  1888. #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
    1889. 

  1889.    !defined(PNG_FIXED_POINT_MACRO_SUPPORTED)
    1890. 

  1890. png_fixed_point
    1891. 

  1891. png_fixed(png_structp png_ptr, double fp, png_const_charp text)
    1892. 

  1892. {
    1893. 

  1893.    double r = floor(100000 * fp + .5);
    1894. 

  1894. 

  1895.    if (r > 2147483647. || r < -2147483648.)
    1896. 

  1896.       png_fixed_error(png_ptr, text);
    1897. 

  1897. 

  1898.    return (png_fixed_point)r;
    1899. 

  1899. }
    1900. 

  1900. #endif
    1901. 

  1901. 

  1902. #if defined(PNG_READ_GAMMA_SUPPORTED) || \
    1903. 

  1903.     defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED)
    1904. 

  1904. /* muldiv functions */
    1905. 

  1905. /* This API takes signed arguments and rounds the result to the nearest
    1906. 

  1906.  * integer (or, for a fixed point number - the standard argument - to
    1907. 

  1907.  * the nearest .00001).  Overflow and divide by zero are signalled in
    1908. 

  1908.  * the result, a boolean - true on success, false on overflow.
    1909. 

  1909.  */
    1910. 

  1910. int
    1911. 

  1911. png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
    1912. 

  1912.     png_int_32 divisor)
    1913. 

  1913. {
    1914. 

  1914.    /* Return a * times / divisor, rounded. */
    1915. 

  1915.    if (divisor != 0)
    1916. 

  1916.    {
    1917. 

  1917.       if (a == 0 || times == 0)
    1918. 

  1918.       {
    1919. 

  1919.          *res = 0;
    1920. 

  1920.          return 1;
    1921. 

  1921.       }
    1922. 

  1922.       else
    1923. 

  1923.       {
    1924. 

  1924. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    1925. 

  1925.          double r = a;
    1926. 

  1926.          r *= times;
    1927. 

  1927.          r /= divisor;
    1928. 

  1928.          r = floor(r+.5);
    1929. 

  1929. 

  1930.          /* A png_fixed_point is a 32-bit integer. */
    1931. 

  1931.          if (r <= 2147483647. && r >= -2147483648.)
    1932. 

  1932.          {
    1933. 

  1933.             *res = (png_fixed_point)r;
    1934. 

  1934.             return 1;
    1935. 

  1935.          }
    1936. 

  1936. #else
    1937. 

  1937.          int negative = 0;
    1938. 

  1938.          png_uint_32 A, T, D;
    1939. 

  1939.          png_uint_32 s16, s32, s00;
    1940. 

  1940. 

  1941.          if (a < 0)
    1942. 

  1942.             negative = 1, A = -a;
    1943. 

  1943.          else
    1944. 

  1944.             A = a;
    1945. 

  1945. 

  1946.          if (times < 0)
    1947. 

  1947.             negative = !negative, T = -times;
    1948. 

  1948.          else
    1949. 

  1949.             T = times;
    1950. 

  1950. 

  1951.          if (divisor < 0)
    1952. 

  1952.             negative = !negative, D = -divisor;
    1953. 

  1953.          else
    1954. 

  1954.             D = divisor;
    1955. 

  1955. 

  1956.          /* Following can't overflow because the arguments only
    1957. 

  1957.           * have 31 bits each, however the result may be 32 bits.
    1958. 

  1958.           */
    1959. 

  1959.          s16 = (A >> 16) * (T & 0xffff) +
    1960. 

  1960.                            (A & 0xffff) * (T >> 16);
    1961. 

  1961.          /* Can't overflow because the a*times bit is only 30
    1962. 

  1962.           * bits at most.
    1963. 

  1963.           */
    1964. 

  1964.          s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
    1965. 

  1965.          s00 = (A & 0xffff) * (T & 0xffff);
    1966. 

  1966. 

  1967.          s16 = (s16 & 0xffff) << 16;
    1968. 

  1968.          s00 += s16;
    1969. 

  1969. 

  1970.          if (s00 < s16)
    1971. 

  1971.             ++s32; /* carry */
    1972. 

  1972. 

  1973.          if (s32 < D) /* else overflow */
    1974. 

  1974.          {
    1975. 

  1975.             /* s32.s00 is now the 64-bit product, do a standard
    1976. 

  1976.              * division, we know that s32 < D, so the maximum
    1977. 

  1977.              * required shift is 31.
    1978. 

  1978.              */
    1979. 

  1979.             int bitshift = 32;
    1980. 

  1980.             png_fixed_point result = 0; /* NOTE: signed */
    1981. 

  1981. 

  1982.             while (--bitshift >= 0)
    1983. 

  1983.             {
    1984. 

  1984.                png_uint_32 d32, d00;
    1985. 

  1985. 

  1986.                if (bitshift > 0)
    1987. 

  1987.                   d32 = D >> (32-bitshift), d00 = D << bitshift;
    1988. 

  1988. 

  1989.                else
    1990. 

  1990.                   d32 = 0, d00 = D;
    1991. 

  1991. 

  1992.                if (s32 > d32)
    1993. 

  1993.                {
    1994. 

  1994.                   if (s00 < d00) --s32; /* carry */
    1995. 

  1995.                   s32 -= d32, s00 -= d00, result += 1<<bitshift;
    1996. 

  1996.                }
    1997. 

  1997. 

  1998.                else
    1999. 

  1999.                   if (s32 == d32 && s00 >= d00)
    2000. 

  2000.                      s32 = 0, s00 -= d00, result += 1<<bitshift;
    2001. 

  2001.             }
    2002. 

  2002. 

  2003.             /* Handle the rounding. */
    2004. 

  2004.             if (s00 >= (D >> 1))
    2005. 

  2005.                ++result;
    2006. 

  2006. 

  2007.             if (negative)
    2008. 

  2008.                result = -result;
    2009. 

  2009. 

  2010.             /* Check for overflow. */
    2011. 

  2011.             if ((negative && result <= 0) || (!negative && result >= 0))
    2012. 

  2012.             {
    2013. 

  2013.                *res = result;
    2014. 

  2014.                return 1;
    2015. 

  2015.             }
    2016. 

  2016.          }
    2017. 

  2017. #endif
    2018. 

  2018.       }
    2019. 

  2019.    }
    2020. 

  2020. 

  2021.    return 0;
    2022. 

  2022. }
    2023. 

  2023. #endif /* READ_GAMMA || INCH_CONVERSIONS */
    2024. 

  2024. 

  2025. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
    2026. 

  2026. /* The following is for when the caller doesn't much care about the
    2027. 

  2027.  * result.
    2028. 

  2028.  */
    2029. 

  2029. png_fixed_point
    2030. 

  2030. png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times,
    2031. 

  2031.     png_int_32 divisor)
    2032. 

  2032. {
    2033. 

  2033.    png_fixed_point result;
    2034. 

  2034. 

  2035.    if (png_muldiv(&result, a, times, divisor))
    2036. 

  2036.       return result;
    2037. 

  2037. 

  2038.    png_warning(png_ptr, "fixed point overflow ignored");
    2039. 

  2039.    return 0;
    2040. 

  2040. }
    2041. 

  2041. #endif
    2042. 

  2042. 

  2043. #ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */
    2044. 

  2044. /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
    2045. 

  2045. png_fixed_point
    2046. 

  2046. png_reciprocal(png_fixed_point a)
    2047. 

  2047. {
    2048. 

  2048. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2049. 

  2049.    double r = floor(1E10/a+.5);
    2050. 

  2050. 

  2051.    if (r <= 2147483647. && r >= -2147483648.)
    2052. 

  2052.       return (png_fixed_point)r;
    2053. 

  2053. #else
    2054. 

  2054.    png_fixed_point res;
    2055. 

  2055. 

  2056.    if (png_muldiv(&res, 100000, 100000, a))
    2057. 

  2057.       return res;
    2058. 

  2058. #endif
    2059. 

  2059. 

  2060.    return 0; /* error/overflow */
    2061. 

  2061. }
    2062. 

  2062. 

  2063. /* A local convenience routine. */
    2064. 

  2064. static png_fixed_point
    2065. 

  2065. png_product2(png_fixed_point a, png_fixed_point b)
    2066. 

  2066. {
    2067. 

  2067.    /* The required result is 1/a * 1/b; the following preserves accuracy. */
    2068. 

  2068. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2069. 

  2069.    double r = a * 1E-5;
    2070. 

  2070.    r *= b;
    2071. 

  2071.    r = floor(r+.5);
    2072. 

  2072. 

  2073.    if (r <= 2147483647. && r >= -2147483648.)
    2074. 

  2074.       return (png_fixed_point)r;
    2075. 

  2075. #else
    2076. 

  2076.    png_fixed_point res;
    2077. 

  2077. 

  2078.    if (png_muldiv(&res, a, b, 100000))
    2079. 

  2079.       return res;
    2080. 

  2080. #endif
    2081. 

  2081. 

  2082.    return 0; /* overflow */
    2083. 

  2083. }
    2084. 

  2084. 

  2085. /* The inverse of the above. */
    2086. 

  2086. png_fixed_point
    2087. 

  2087. png_reciprocal2(png_fixed_point a, png_fixed_point b)
    2088. 

  2088. {
    2089. 

  2089.    /* The required result is 1/a * 1/b; the following preserves accuracy. */
    2090. 

  2090. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2091. 

  2091.    double r = 1E15/a;
    2092. 

  2092.    r /= b;
    2093. 

  2093.    r = floor(r+.5);
    2094. 

  2094. 

  2095.    if (r <= 2147483647. && r >= -2147483648.)
    2096. 

  2096.       return (png_fixed_point)r;
    2097. 

  2097. #else
    2098. 

  2098.    /* This may overflow because the range of png_fixed_point isn't symmetric,
    2099. 

  2099.     * but this API is only used for the product of file and screen gamma so it
    2100. 

  2100.     * doesn't matter that the smallest number it can produce is 1/21474, not
    2101. 

  2101.     * 1/100000
    2102. 

  2102.     */
    2103. 

  2103.    png_fixed_point res = png_product2(a, b);
    2104. 

  2104. 

  2105.    if (res != 0)
    2106. 

  2106.       return png_reciprocal(res);
    2107. 

  2107. #endif
    2108. 

  2108. 

  2109.    return 0; /* overflow */
    2110. 

  2110. }
    2111. 

  2111. #endif /* READ_GAMMA */
    2112. 

  2112. 

  2113. #ifdef PNG_CHECK_cHRM_SUPPORTED
    2114. 

  2114. /* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2,
    2115. 

  2115.  * 2010: moved from pngset.c) */
    2116. 

  2116. /*
    2117. 

  2117.  *    Multiply two 32-bit numbers, V1 and V2, using 32-bit
    2118. 

  2118.  *    arithmetic, to produce a 64-bit result in the HI/LO words.
    2119. 

  2119.  *
    2120. 

  2120.  *                  A B
    2121. 

  2121.  *                x C D
    2122. 

  2122.  *               ------
    2123. 

  2123.  *              AD || BD
    2124. 

  2124.  *        AC || CB || 0
    2125. 

  2125.  *
    2126. 

  2126.  *    where A and B are the high and low 16-bit words of V1,
    2127. 

  2127.  *    C and D are the 16-bit words of V2, AD is the product of
    2128. 

  2128.  *    A and D, and X || Y is (X << 16) + Y.
    2129. 

  2129. */
    2130. 

  2130. 

  2131. void /* PRIVATE */
    2132. 

  2132. png_64bit_product (long v1, long v2, unsigned long *hi_product,
    2133. 

  2133.     unsigned long *lo_product)
    2134. 

  2134. {
    2135. 

  2135.    int a, b, c, d;
    2136. 

  2136.    long lo, hi, x, y;
    2137. 

  2137. 

  2138.    a = (v1 >> 16) & 0xffff;
    2139. 

  2139.    b = v1 & 0xffff;
    2140. 

  2140.    c = (v2 >> 16) & 0xffff;
    2141. 

  2141.    d = v2 & 0xffff;
    2142. 

  2142. 

  2143.    lo = b * d;                   /* BD */
    2144. 

  2144.    x = a * d + c * b;            /* AD + CB */
    2145. 

  2145.    y = ((lo >> 16) & 0xffff) + x;
    2146. 

  2146. 

  2147.    lo = (lo & 0xffff) | ((y & 0xffff) << 16);
    2148. 

  2148.    hi = (y >> 16) & 0xffff;
    2149. 

  2149. 

  2150.    hi += a * c;                  /* AC */
    2151. 

  2151. 

  2152.    *hi_product = (unsigned long)hi;
    2153. 

  2153.    *lo_product = (unsigned long)lo;
    2154. 

  2154. }
    2155. 

  2155. #endif /* CHECK_cHRM */
    2156. 

  2156. 

  2157. #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
    2158. 

  2158. #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2159. 

  2159. /* Fixed point gamma.
    2160. 

  2160.  *
    2161. 

  2161.  * To calculate gamma this code implements fast log() and exp() calls using only
    2162. 

  2162.  * fixed point arithmetic.  This code has sufficient precision for either 8-bit
    2163. 

  2163.  * or 16-bit sample values.
    2164. 

  2164.  *
    2165. 

  2165.  * The tables used here were calculated using simple 'bc' programs, but C double
    2166. 

  2166.  * precision floating point arithmetic would work fine.  The programs are given
    2167. 

  2167.  * at the head of each table.
    2168. 

  2168.  *
    2169. 

  2169.  * 8-bit log table
    2170. 

  2170.  *   This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
    2171. 

  2171.  *   255, so it's the base 2 logarithm of a normalized 8-bit floating point
    2172. 

  2172.  *   mantissa.  The numbers are 32-bit fractions.
    2173. 

  2173.  */
    2174. 

  2174. static png_uint_32
    2175. 

  2175. png_8bit_l2[128] =
    2176. 

  2176. {
    2177. 

  2177. #  ifdef PNG_DO_BC
    2178. 

  2178.       for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; }
    2179. 

  2179. #  else
    2180. 

  2180.    4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
    2181. 

  2181.    3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
    2182. 

  2182.    3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
    2183. 

  2183.    3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
    2184. 

  2184.    3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
    2185. 

  2185.    2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
    2186. 

  2186.    2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
    2187. 

  2187.    2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
    2188. 

  2188.    2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
    2189. 

  2189.    2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
    2190. 

  2190.    1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
    2191. 

  2191.    1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
    2192. 

  2192.    1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
    2193. 

  2193.    1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
    2194. 

  2194.    1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
    2195. 

  2195.    971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
    2196. 

  2196.    803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
    2197. 

  2197.    639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
    2198. 

  2198.    479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
    2199. 

  2199.    324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
    2200. 

  2200.    172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
    2201. 

  2201.    24347096U, 0U
    2202. 

  2202. #  endif
    2203. 

  2203. 

  2204. #if 0
    2205. 

  2205.    /* The following are the values for 16-bit tables - these work fine for the
    2206. 

  2206.     * 8-bit conversions but produce very slightly larger errors in the 16-bit
    2207. 

  2207.     * log (about 1.2 as opposed to 0.7 absolute error in the final value).  To
    2208. 

  2208.     * use these all the shifts below must be adjusted appropriately.
    2209. 

  2209.     */
    2210. 

  2210.    65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
    2211. 

  2211.    57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
    2212. 

  2212.    50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
    2213. 

  2213.    43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
    2214. 

  2214.    37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
    2215. 

  2215.    31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
    2216. 

  2216.    25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
    2217. 

  2217.    20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
    2218. 

  2218.    15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
    2219. 

  2219.    10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
    2220. 

  2220.    6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
    2221. 

  2221.    1119, 744, 372
    2222. 

  2222. #endif
    2223. 

  2223. };
    2224. 

  2224. 

  2225. PNG_STATIC png_int_32
    2226. 

  2226. png_log8bit(unsigned int x)
    2227. 

  2227. {
    2228. 

  2228.    unsigned int lg2 = 0;
    2229. 

  2229.    /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
    2230. 

  2230.     * because the log is actually negate that means adding 1.  The final
    2231. 

  2231.     * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
    2232. 

  2232.     * input), return 7.99998 for the overflow (log 0) case - so the result is
    2233. 

  2233.     * always at most 19 bits.
    2234. 

  2234.     */
    2235. 

  2235.    if ((x &= 0xff) == 0)
    2236. 

  2236.       return 0xffffffff;
    2237. 

  2237. 

  2238.    if ((x & 0xf0) == 0)
    2239. 

  2239.       lg2  = 4, x <<= 4;
    2240. 

  2240. 

  2241.    if ((x & 0xc0) == 0)
    2242. 

  2242.       lg2 += 2, x <<= 2;
    2243. 

  2243. 

  2244.    if ((x & 0x80) == 0)
    2245. 

  2245.       lg2 += 1, x <<= 1;
    2246. 

  2246. 

  2247.    /* result is at most 19 bits, so this cast is safe: */
    2248. 

  2248.    return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
    2249. 

  2249. }
    2250. 

  2250. 

  2251. /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
    2252. 

  2252.  * for 16-bit images we use the most significant 8 bits of the 16-bit value to
    2253. 

  2253.  * get an approximation then multiply the approximation by a correction factor
    2254. 

  2254.  * determined by the remaining up to 8 bits.  This requires an additional step
    2255. 

  2255.  * in the 16-bit case.
    2256. 

  2256.  *
    2257. 

  2257.  * We want log2(value/65535), we have log2(v'/255), where:
    2258. 

  2258.  *
    2259. 

  2259.  *    value = v' * 256 + v''
    2260. 

  2260.  *          = v' * f
    2261. 

  2261.  *
    2262. 

  2262.  * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
    2263. 

  2263.  * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
    2264. 

  2264.  * than 258.  The final factor also needs to correct for the fact that our 8-bit
    2265. 

  2265.  * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
    2266. 

  2266.  *
    2267. 

  2267.  * This gives a final formula using a calculated value 'x' which is value/v' and
    2268. 

  2268.  * scaling by 65536 to match the above table:
    2269. 

  2269.  *
    2270. 

  2270.  *   log2(x/257) * 65536
    2271. 

  2271.  *
    2272. 

  2272.  * Since these numbers are so close to '1' we can use simple linear
    2273. 

  2273.  * interpolation between the two end values 256/257 (result -368.61) and 258/257
    2274. 

  2274.  * (result 367.179).  The values used below are scaled by a further 64 to give
    2275. 

  2275.  * 16-bit precision in the interpolation:
    2276. 

  2276.  *
    2277. 

  2277.  * Start (256): -23591
    2278. 

  2278.  * Zero  (257):      0
    2279. 

  2279.  * End   (258):  23499
    2280. 

  2280.  */
    2281. 

  2281. PNG_STATIC png_int_32
    2282. 

  2282. png_log16bit(png_uint_32 x)
    2283. 

  2283. {
    2284. 

  2284.    unsigned int lg2 = 0;
    2285. 

  2285. 

  2286.    /* As above, but now the input has 16 bits. */
    2287. 

  2287.    if ((x &= 0xffff) == 0)
    2288. 

  2288.       return 0xffffffff;
    2289. 

  2289. 

  2290.    if ((x & 0xff00) == 0)
    2291. 

  2291.       lg2  = 8, x <<= 8;
    2292. 

  2292. 

  2293.    if ((x & 0xf000) == 0)
    2294. 

  2294.       lg2 += 4, x <<= 4;
    2295. 

  2295. 

  2296.    if ((x & 0xc000) == 0)
    2297. 

  2297.       lg2 += 2, x <<= 2;
    2298. 

  2298. 

  2299.    if ((x & 0x8000) == 0)
    2300. 

  2300.       lg2 += 1, x <<= 1;
    2301. 

  2301. 

  2302.    /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
    2303. 

  2303.     * value.
    2304. 

  2304.     */
    2305. 

  2305.    lg2 <<= 28;
    2306. 

  2306.    lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
    2307. 

  2307. 

  2308.    /* Now we need to interpolate the factor, this requires a division by the top
    2309. 

  2309.     * 8 bits.  Do this with maximum precision.
    2310. 

  2310.     */
    2311. 

  2311.    x = ((x << 16) + (x >> 9)) / (x >> 8);
    2312. 

  2312. 

  2313.    /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
    2314. 

  2314.     * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
    2315. 

  2315.     * 16 bits to interpolate to get the low bits of the result.  Round the
    2316. 

  2316.     * answer.  Note that the end point values are scaled by 64 to retain overall
    2317. 

  2317.     * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
    2318. 

  2318.     * the overall scaling by 6-12.  Round at every step.
    2319. 

  2319.     */
    2320. 

  2320.    x -= 1U << 24;
    2321. 

  2321. 

  2322.    if (x <= 65536U) /* <= '257' */
    2323. 

  2323.       lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
    2324. 

  2324. 

  2325.    else
    2326. 

  2326.       lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
    2327. 

  2327. 

  2328.    /* Safe, because the result can't have more than 20 bits: */
    2329. 

  2329.    return (png_int_32)((lg2 + 2048) >> 12);
    2330. 

  2330. }
    2331. 

  2331. 

  2332. /* The 'exp()' case must invert the above, taking a 20-bit fixed point
    2333. 

  2333.  * logarithmic value and returning a 16 or 8-bit number as appropriate.  In
    2334. 

  2334.  * each case only the low 16 bits are relevant - the fraction - since the
    2335. 

  2335.  * integer bits (the top 4) simply determine a shift.
    2336. 

  2336.  *
    2337. 

  2337.  * The worst case is the 16-bit distinction between 65535 and 65534, this
    2338. 

  2338.  * requires perhaps spurious accuracy in the decoding of the logarithm to
    2339. 

  2339.  * distinguish log2(65535/65534.5) - 10^-5 or 17 bits.  There is little chance
    2340. 

  2340.  * of getting this accuracy in practice.
    2341. 

  2341.  *
    2342. 

  2342.  * To deal with this the following exp() function works out the exponent of the
    2343. 

  2343.  * frational part of the logarithm by using an accurate 32-bit value from the
    2344. 

  2344.  * top four fractional bits then multiplying in the remaining bits.
    2345. 

  2345.  */
    2346. 

  2346. static png_uint_32
    2347. 

  2347. png_32bit_exp[16] =
    2348. 

  2348. {
    2349. 

  2349. #  ifdef PNG_DO_BC
    2350. 

  2350.       for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; }
    2351. 

  2351. #  else
    2352. 

  2352.    /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
    2353. 

  2353.    4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
    2354. 

  2354.    3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
    2355. 

  2355.    2553802834U, 2445529972U, 2341847524U, 2242560872U
    2356. 

  2356. #  endif
    2357. 

  2357. };
    2358. 

  2358. 

  2359. /* Adjustment table; provided to explain the numbers in the code below. */
    2360. 

  2360. #ifdef PNG_DO_BC
    2361. 

  2361. for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
    2362. 

  2362.    11 44937.64284865548751208448
    2363. 

  2363.    10 45180.98734845585101160448
    2364. 

  2364.     9 45303.31936980687359311872
    2365. 

  2365.     8 45364.65110595323018870784
    2366. 

  2366.     7 45395.35850361789624614912
    2367. 

  2367.     6 45410.72259715102037508096
    2368. 

  2368.     5 45418.40724413220722311168
    2369. 

  2369.     4 45422.25021786898173001728
    2370. 

  2370.     3 45424.17186732298419044352
    2371. 

  2371.     2 45425.13273269940811464704
    2372. 

  2372.     1 45425.61317555035558641664
    2373. 

  2373.     0 45425.85339951654943850496
    2374. 

  2374. #endif
    2375. 

  2375. 

  2376. PNG_STATIC png_uint_32
    2377. 

  2377. png_exp(png_fixed_point x)
    2378. 

  2378. {
    2379. 

  2379.    if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
    2380. 

  2380.    {
    2381. 

  2381.       /* Obtain a 4-bit approximation */
    2382. 

  2382.       png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf];
    2383. 

  2383. 

  2384.       /* Incorporate the low 12 bits - these decrease the returned value by
    2385. 

  2385.        * multiplying by a number less than 1 if the bit is set.  The multiplier
    2386. 

  2386.        * is determined by the above table and the shift. Notice that the values
    2387. 

  2387.        * converge on 45426 and this is used to allow linear interpolation of the
    2388. 

  2388.        * low bits.
    2389. 

  2389.        */
    2390. 

  2390.       if (x & 0x800)
    2391. 

  2391.          e -= (((e >> 16) * 44938U) +  16U) >> 5;
    2392. 

  2392. 

  2393.       if (x & 0x400)
    2394. 

  2394.          e -= (((e >> 16) * 45181U) +  32U) >> 6;
    2395. 

  2395. 

  2396.       if (x & 0x200)
    2397. 

  2397.          e -= (((e >> 16) * 45303U) +  64U) >> 7;
    2398. 

  2398. 

  2399.       if (x & 0x100)
    2400. 

  2400.          e -= (((e >> 16) * 45365U) + 128U) >> 8;
    2401. 

  2401. 

  2402.       if (x & 0x080)
    2403. 

  2403.          e -= (((e >> 16) * 45395U) + 256U) >> 9;
    2404. 

  2404. 

  2405.       if (x & 0x040)
    2406. 

  2406.          e -= (((e >> 16) * 45410U) + 512U) >> 10;
    2407. 

  2407. 

  2408.       /* And handle the low 6 bits in a single block. */
    2409. 

  2409.       e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
    2410. 

  2410. 

  2411.       /* Handle the upper bits of x. */
    2412. 

  2412.       e >>= x >> 16;
    2413. 

  2413.       return e;
    2414. 

  2414.    }
    2415. 

  2415. 

  2416.    /* Check for overflow */
    2417. 

  2417.    if (x <= 0)
    2418. 

  2418.       return png_32bit_exp[0];
    2419. 

  2419. 

  2420.    /* Else underflow */
    2421. 

  2421.    return 0;
    2422. 

  2422. }
    2423. 

  2423. 

  2424. PNG_STATIC png_byte
    2425. 

  2425. png_exp8bit(png_fixed_point lg2)
    2426. 

  2426. {
    2427. 

  2427.    /* Get a 32-bit value: */
    2428. 

  2428.    png_uint_32 x = png_exp(lg2);
    2429. 

  2429. 

  2430.    /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the
    2431. 

  2431.     * second, rounding, step can't overflow because of the first, subtraction,
    2432. 

  2432.     * step.
    2433. 

  2433.     */
    2434. 

  2434.    x -= x >> 8;
    2435. 

  2435.    return (png_byte)((x + 0x7fffffU) >> 24);
    2436. 

  2436. }
    2437. 

  2437. 

  2438. PNG_STATIC png_uint_16
    2439. 

  2439. png_exp16bit(png_fixed_point lg2)
    2440. 

  2440. {
    2441. 

  2441.    /* Get a 32-bit value: */
    2442. 

  2442.    png_uint_32 x = png_exp(lg2);
    2443. 

  2443. 

  2444.    /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
    2445. 

  2445.    x -= x >> 16;
    2446. 

  2446.    return (png_uint_16)((x + 32767U) >> 16);
    2447. 

  2447. }
    2448. 

  2448. #endif /* FLOATING_ARITHMETIC */
    2449. 

  2449. 

  2450. png_byte
    2451. 

  2451. png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
    2452. 

  2452. {
    2453. 

  2453.    if (value > 0 && value < 255)
    2454. 

  2454.    {
    2455. 

  2455. #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2456. 

  2456.          double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
    2457. 

  2457.          return (png_byte)r;
    2458. 

  2458. #     else
    2459. 

  2459.          png_int_32 lg2 = png_log8bit(value);
    2460. 

  2460.          png_fixed_point res;
    2461. 

  2461. 

  2462.          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
    2463. 

  2463.             return png_exp8bit(res);
    2464. 

  2464. 

  2465.          /* Overflow. */
    2466. 

  2466.          value = 0;
    2467. 

  2467. #     endif
    2468. 

  2468.    }
    2469. 

  2469. 

  2470.    return (png_byte)value;
    2471. 

  2471. }
    2472. 

  2472. 

  2473. png_uint_16
    2474. 

  2474. png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
    2475. 

  2475. {
    2476. 

  2476.    if (value > 0 && value < 65535)
    2477. 

  2477.    {
    2478. 

  2478. #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2479. 

  2479.          double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
    2480. 

  2480.          return (png_uint_16)r;
    2481. 

  2481. #     else
    2482. 

  2482.          png_int_32 lg2 = png_log16bit(value);
    2483. 

  2483.          png_fixed_point res;
    2484. 

  2484. 

  2485.          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
    2486. 

  2486.             return png_exp16bit(res);
    2487. 

  2487. 

  2488.          /* Overflow. */
    2489. 

  2489.          value = 0;
    2490. 

  2490. #     endif
    2491. 

  2491.    }
    2492. 

  2492. 

  2493.    return (png_uint_16)value;
    2494. 

  2494. }
    2495. 

  2495. 

  2496. /* This does the right thing based on the bit_depth field of the
    2497. 

  2497.  * png_struct, interpreting values as 8-bit or 16-bit.  While the result
    2498. 

  2498.  * is nominally a 16-bit value if bit depth is 8 then the result is
    2499. 

  2499.  * 8-bit (as are the arguments.)
    2500. 

  2500.  */
    2501. 

  2501. png_uint_16 /* PRIVATE */
    2502. 

  2502. png_gamma_correct(png_structp png_ptr, unsigned int value,
    2503. 

  2503.     png_fixed_point gamma_val)
    2504. 

  2504. {
    2505. 

  2505.    if (png_ptr->bit_depth == 8)
    2506. 

  2506.       return png_gamma_8bit_correct(value, gamma_val);
    2507. 

  2507. 

  2508.    else
    2509. 

  2509.       return png_gamma_16bit_correct(value, gamma_val);
    2510. 

  2510. }
    2511. 

  2511. 

  2512. /* This is the shared test on whether a gamma value is 'significant' - whether
    2513. 

  2513.  * it is worth doing gamma correction.
    2514. 

  2514.  */
    2515. 

  2515. int /* PRIVATE */
    2516. 

  2516. png_gamma_significant(png_fixed_point gamma_val)
    2517. 

  2517. {
    2518. 

  2518.    return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
    2519. 

  2519.        gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
    2520. 

  2520. }
    2521. 

  2521. 

  2522. /* Internal function to build a single 16-bit table - the table consists of
    2523. 

  2523.  * 'num' 256-entry subtables, where 'num' is determined by 'shift' - the amount
    2524. 

  2524.  * to shift the input values right (or 16-number_of_signifiant_bits).
    2525. 

  2525.  *
    2526. 

  2526.  * The caller is responsible for ensuring that the table gets cleaned up on
    2527. 

  2527.  * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
    2528. 

  2528.  * should be somewhere that will be cleaned.
    2529. 

  2529.  */
    2530. 

  2530. static void
    2531. 

  2531. png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable,
    2532. 

  2532.    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
    2533. 

  2533. {
    2534. 

  2534.    /* Various values derived from 'shift': */
    2535. 

  2535.    PNG_CONST unsigned int num = 1U << (8U - shift);
    2536. 

  2536.    PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
    2537. 

  2537.    PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
    2538. 

  2538.    unsigned int i;
    2539. 

  2539. 

  2540.    png_uint_16pp table = *ptable =
    2541. 

  2541.        (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
    2542. 

  2542. 

  2543.    for (i = 0; i < num; i++)
    2544. 

  2544.    {
    2545. 

  2545.       png_uint_16p sub_table = table[i] =
    2546. 

  2546.           (png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16));
    2547. 

  2547. 

  2548.       /* The 'threshold' test is repeated here because it can arise for one of
    2549. 

  2549.        * the 16-bit tables even if the others don't hit it.
    2550. 

  2550.        */
    2551. 

  2551.       if (png_gamma_significant(gamma_val))
    2552. 

  2552.       {
    2553. 

  2553.          /* The old code would overflow at the end and this would cause the
    2554. 

  2554.           * 'pow' function to return a result >1, resulting in an
    2555. 

  2555.           * arithmetic error.  This code follows the spec exactly; ig is
    2556. 

  2556.           * the recovered input sample, it always has 8-16 bits.
    2557. 

  2557.           *
    2558. 

  2558.           * We want input * 65535/max, rounded, the arithmetic fits in 32
    2559. 

  2559.           * bits (unsigned) so long as max <= 32767.
    2560. 

  2560.           */
    2561. 

  2561.          unsigned int j;
    2562. 

  2562.          for (j = 0; j < 256; j++)
    2563. 

  2563.          {
    2564. 

  2564.             png_uint_32 ig = (j << (8-shift)) + i;
    2565. 

  2565. #           ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    2566. 

  2566.                /* Inline the 'max' scaling operation: */
    2567. 

  2567.                double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5);
    2568. 

  2568.                sub_table[j] = (png_uint_16)d;
    2569. 

  2569. #           else
    2570. 

  2570.                if (shift)
    2571. 

  2571.                   ig = (ig * 65535U + max_by_2)/max;
    2572. 

  2572. 

  2573.                sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
    2574. 

  2574. #           endif
    2575. 

  2575.          }
    2576. 

  2576.       }
    2577. 

  2577.       else
    2578. 

  2578.       {
    2579. 

  2579.          /* We must still build a table, but do it the fast way. */
    2580. 

  2580.          unsigned int j;
    2581. 

  2581. 

  2582.          for (j = 0; j < 256; j++)
    2583. 

  2583.          {
    2584. 

  2584.             png_uint_32 ig = (j << (8-shift)) + i;
    2585. 

  2585. 

  2586.             if (shift)
    2587. 

  2587.                ig = (ig * 65535U + max_by_2)/max;
    2588. 

  2588. 

  2589.             sub_table[j] = (png_uint_16)ig;
    2590. 

  2590.          }
    2591. 

  2591.       }
    2592. 

  2592.    }
    2593. 

  2593. }
    2594. 

  2594. 

  2595. /* NOTE: this function expects the *inverse* of the overall gamma transformation
    2596. 

  2596.  * required.
    2597. 

  2597.  */
    2598. 

  2598. static void
    2599. 

  2599. png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable,
    2600. 

  2600.    PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
    2601. 

  2601. {
    2602. 

  2602.    PNG_CONST unsigned int num = 1U << (8U - shift);
    2603. 

  2603.    PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
    2604. 

  2604.    unsigned int i;
    2605. 

  2605.    png_uint_32 last;
    2606. 

  2606. 

  2607.    png_uint_16pp table = *ptable =
    2608. 

  2608.        (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p));
    2609. 

  2609. 

  2610.    /* 'num' is the number of tables and also the number of low bits of the
    2611. 

  2611.     * input 16-bit value used to select a table.  Each table is itself indexed
    2612. 

  2612.     * by the high 8 bits of the value.
    2613. 

  2613.     */
    2614. 

  2614.    for (i = 0; i < num; i++)
    2615. 

  2615.       table[i] = (png_uint_16p)png_malloc(png_ptr,
    2616. 

  2616.           256 * png_sizeof(png_uint_16));
    2617. 

  2617. 

  2618.    /* 'gamma_val' is set to the reciprocal of the value calculated above, so
    2619. 

  2619.     * pow(out,g) is an *input* value.  'last' is the last input value set.
    2620. 

  2620.     *
    2621. 

  2621.     * In the loop 'i' is used to find output values.  Since the output is
    2622. 

  2622.     * 8-bit there are only 256 possible values.  The tables are set up to
    2623. 

  2623.     * select the closest possible output value for each input by finding
    2624. 

  2624.     * the input value at the boundary between each pair of output values
    2625. 

  2625.     * and filling the table up to that boundary with the lower output
    2626. 

  2626.     * value.
    2627. 

  2627.     *
    2628. 

  2628.     * The boundary values are 0.5,1.5..253.5,254.5.  Since these are 9-bit
    2629. 

  2629.     * values the code below uses a 16-bit value in i; the values start at
    2630. 

  2630.     * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
    2631. 

  2631.     * entries are filled with 255).  Start i at 128 and fill all 'last'
    2632. 

  2632.     * table entries <= 'max'
    2633. 

  2633.     */
    2634. 

  2634.    last = 0;
    2635. 

  2635.    for (i = 0; i < 255; ++i) /* 8-bit output value */
    2636. 

  2636.    {
    2637. 

  2637.       /* Find the corresponding maximum input value */
    2638. 

  2638.       png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */
    2639. 

  2639. 

  2640.       /* Find the boundary value in 16 bits: */
    2641. 

  2641.       png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
    2642. 

  2642. 

  2643.       /* Adjust (round) to (16-shift) bits: */
    2644. 

  2644.       bound = (bound * max + 32768U)/65535U + 1U;
    2645. 

  2645. 

  2646.       while (last < bound)
    2647. 

  2647.       {
    2648. 

  2648.          table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
    2649. 

  2649.          last++;
    2650. 

  2650.       }
    2651. 

  2651.    }
    2652. 

  2652. 

  2653.    /* And fill in the final entries. */
    2654. 

  2654.    while (last < (num << 8))
    2655. 

  2655.    {
    2656. 

  2656.       table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
    2657. 

  2657.       last++;
    2658. 

  2658.    }
    2659. 

  2659. }
    2660. 

  2660. 

  2661. /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
    2662. 

  2662.  * typically much faster).  Note that libpng currently does no sBIT processing
    2663. 

  2663.  * (apparently contrary to the spec) so a 256-entry table is always generated.
    2664. 

  2664.  */
    2665. 

  2665. static void
    2666. 

  2666. png_build_8bit_table(png_structp png_ptr, png_bytepp ptable,
    2667. 

  2667.    PNG_CONST png_fixed_point gamma_val)
    2668. 

  2668. {
    2669. 

  2669.    unsigned int i;
    2670. 

  2670.    png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
    2671. 

  2671. 

  2672.    if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++)
    2673. 

  2673.       table[i] = png_gamma_8bit_correct(i, gamma_val);
    2674. 

  2674. 

  2675.    else for (i=0; i<256; ++i)
    2676. 

  2676.       table[i] = (png_byte)i;
    2677. 

  2677. }
    2678. 

  2678. 

  2679. /* Used from png_read_destroy and below to release the memory used by the gamma
    2680. 

  2680.  * tables.
    2681. 

  2681.  */
    2682. 

  2682. void /* PRIVATE */
    2683. 

  2683. png_destroy_gamma_table(png_structp png_ptr)
    2684. 

  2684. {
    2685. 

  2685.    png_free(png_ptr, png_ptr->gamma_table);
    2686. 

  2686.    png_ptr->gamma_table = NULL;
    2687. 

  2687. 

  2688.    if (png_ptr->gamma_16_table != NULL)
    2689. 

  2689.    {
    2690. 

  2690.       int i;
    2691. 

  2691.       int istop = (1 << (8 - png_ptr->gamma_shift));
    2692. 

  2692.       for (i = 0; i < istop; i++)
    2693. 

  2693.       {
    2694. 

  2694.          png_free(png_ptr, png_ptr->gamma_16_table[i]);
    2695. 

  2695.       }
    2696. 

  2696.    png_free(png_ptr, png_ptr->gamma_16_table);
    2697. 

  2697.    png_ptr->gamma_16_table = NULL;
    2698. 

  2698.    }
    2699. 

  2699. 

  2700. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    2701. 

  2701.    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    2702. 

  2702.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
    2703. 

  2703.    png_free(png_ptr, png_ptr->gamma_from_1);
    2704. 

  2704.    png_ptr->gamma_from_1 = NULL;
    2705. 

  2705.    png_free(png_ptr, png_ptr->gamma_to_1);
    2706. 

  2706.    png_ptr->gamma_to_1 = NULL;
    2707. 

  2707. 

  2708.    if (png_ptr->gamma_16_from_1 != NULL)
    2709. 

  2709.    {
    2710. 

  2710.       int i;
    2711. 

  2711.       int istop = (1 << (8 - png_ptr->gamma_shift));
    2712. 

  2712.       for (i = 0; i < istop; i++)
    2713. 

  2713.       {
    2714. 

  2714.          png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
    2715. 

  2715.       }
    2716. 

  2716.    png_free(png_ptr, png_ptr->gamma_16_from_1);
    2717. 

  2717.    png_ptr->gamma_16_from_1 = NULL;
    2718. 

  2718.    }
    2719. 

  2719.    if (png_ptr->gamma_16_to_1 != NULL)
    2720. 

  2720.    {
    2721. 

  2721.       int i;
    2722. 

  2722.       int istop = (1 << (8 - png_ptr->gamma_shift));
    2723. 

  2723.       for (i = 0; i < istop; i++)
    2724. 

  2724.       {
    2725. 

  2725.          png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
    2726. 

  2726.       }
    2727. 

  2727.    png_free(png_ptr, png_ptr->gamma_16_to_1);
    2728. 

  2728.    png_ptr->gamma_16_to_1 = NULL;
    2729. 

  2729.    }
    2730. 

  2730. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
    2731. 

  2731. }
    2732. 

  2732. 

  2733. /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
    2734. 

  2734.  * tables, we don't make a full table if we are reducing to 8-bit in
    2735. 

  2735.  * the future.  Note also how the gamma_16 tables are segmented so that
    2736. 

  2736.  * we don't need to allocate > 64K chunks for a full 16-bit table.
    2737. 

  2737.  */
    2738. 

  2738. void /* PRIVATE */
    2739. 

  2739. png_build_gamma_table(png_structp png_ptr, int bit_depth)
    2740. 

  2740. {
    2741. 

  2741.   png_debug(1, "in png_build_gamma_table");
    2742. 

  2742. 

  2743.   /* Remove any existing table; this copes with multiple calls to
    2744. 

  2744.    * png_read_update_info.  The warning is because building the gamma tables
    2745. 

  2745.    * multiple times is a performance hit - it's harmless but the ability to call
    2746. 

  2746.    * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
    2747. 

  2747.    * to warn if the app introduces such a hit.
    2748. 

  2748.    */
    2749. 

  2749.   if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
    2750. 

  2750.   {
    2751. 

  2751.     png_warning(png_ptr, "gamma table being rebuilt");
    2752. 

  2752.     png_destroy_gamma_table(png_ptr);
    2753. 

  2753.   }
    2754. 

  2754. 

  2755.   if (bit_depth <= 8)
    2756. 

  2756.   {
    2757. 

  2757.      png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
    2758. 

  2758.          png_ptr->screen_gamma > 0 ?  png_reciprocal2(png_ptr->gamma,
    2759. 

  2759.          png_ptr->screen_gamma) : PNG_FP_1);
    2760. 

  2760. 

  2761. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    2762. 

  2762.    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    2763. 

  2763.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
    2764. 

  2764.      if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
    2765. 

  2765.      {
    2766. 

  2766.         png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
    2767. 

  2767.             png_reciprocal(png_ptr->gamma));
    2768. 

  2768. 

  2769.         png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
    2770. 

  2770.             png_ptr->screen_gamma > 0 ?  png_reciprocal(png_ptr->screen_gamma) :
    2771. 

  2771.             png_ptr->gamma/* Probably doing rgb_to_gray */);
    2772. 

  2772.      }
    2773. 

  2773. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
    2774. 

  2774.   }
    2775. 

  2775.   else
    2776. 

  2776.   {
    2777. 

  2777.      png_byte shift, sig_bit;
    2778. 

  2778. 

  2779.      if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
    2780. 

  2780.      {
    2781. 

  2781.         sig_bit = png_ptr->sig_bit.red;
    2782. 

  2782. 

  2783.         if (png_ptr->sig_bit.green > sig_bit)
    2784. 

  2784.            sig_bit = png_ptr->sig_bit.green;
    2785. 

  2785. 

  2786.         if (png_ptr->sig_bit.blue > sig_bit)
    2787. 

  2787.            sig_bit = png_ptr->sig_bit.blue;
    2788. 

  2788.      }
    2789. 

  2789.      else
    2790. 

  2790.         sig_bit = png_ptr->sig_bit.gray;
    2791. 

  2791. 

  2792.      /* 16-bit gamma code uses this equation:
    2793. 

  2793.       *
    2794. 

  2794.       *   ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
    2795. 

  2795.       *
    2796. 

  2796.       * Where 'iv' is the input color value and 'ov' is the output value -
    2797. 

  2797.       * pow(iv, gamma).
    2798. 

  2798.       *
    2799. 

  2799.       * Thus the gamma table consists of up to 256 256-entry tables.  The table
    2800. 

  2800.       * is selected by the (8-gamma_shift) most significant of the low 8 bits of
    2801. 

  2801.       * the color value then indexed by the upper 8 bits:
    2802. 

  2802.       *
    2803. 

  2803.       *   table[low bits][high 8 bits]
    2804. 

  2804.       *
    2805. 

  2805.       * So the table 'n' corresponds to all those 'iv' of:
    2806. 

  2806.       *
    2807. 

  2807.       *   <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
    2808. 

  2808.       *
    2809. 

  2809.       */
    2810. 

  2810.      if (sig_bit > 0 && sig_bit < 16U)
    2811. 

  2811.         shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */
    2812. 

  2812. 

  2813.      else
    2814. 

  2814.         shift = 0; /* keep all 16 bits */
    2815. 

  2815. 

  2816.      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
    2817. 

  2817.      {
    2818. 

  2818.         /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
    2819. 

  2819.          * the significant bits in the *input* when the output will
    2820. 

  2820.          * eventually be 8 bits.  By default it is 11.
    2821. 

  2821.          */
    2822. 

  2822.         if (shift < (16U - PNG_MAX_GAMMA_8))
    2823. 

  2823.            shift = (16U - PNG_MAX_GAMMA_8);
    2824. 

  2824.      }
    2825. 

  2825. 

  2826.      if (shift > 8U)
    2827. 

  2827.         shift = 8U; /* Guarantees at least one table! */
    2828. 

  2828. 

  2829.      png_ptr->gamma_shift = shift;
    2830. 

  2830. 

  2831. #ifdef PNG_16BIT_SUPPORTED
    2832. 

  2832.      /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
    2833. 

  2833.       * PNG_COMPOSE).  This effectively smashed the background calculation for
    2834. 

  2834.       * 16-bit output because the 8-bit table assumes the result will be reduced
    2835. 

  2835.       * to 8 bits.
    2836. 

  2836.       */
    2837. 

  2837.      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
    2838. 

  2838. #endif
    2839. 

  2839.          png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
    2840. 

  2840.          png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma,
    2841. 

  2841.          png_ptr->screen_gamma) : PNG_FP_1);
    2842. 

  2842. 

  2843. #ifdef PNG_16BIT_SUPPORTED
    2844. 

  2844.      else
    2845. 

  2845.          png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
    2846. 

  2846.          png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma,
    2847. 

  2847.          png_ptr->screen_gamma) : PNG_FP_1);
    2848. 

  2848. #endif
    2849. 

  2849. 

  2850. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    2851. 

  2851.    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    2852. 

  2852.    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
    2853. 

  2853.      if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
    2854. 

  2854.      {
    2855. 

  2855.         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
    2856. 

  2856.             png_reciprocal(png_ptr->gamma));
    2857. 

  2857. 

  2858.         /* Notice that the '16 from 1' table should be full precision, however
    2859. 

  2859.          * the lookup on this table still uses gamma_shift, so it can't be.
    2860. 

  2860.          * TODO: fix this.
    2861. 

  2861.          */
    2862. 

  2862.         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
    2863. 

  2863.             png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
    2864. 

  2864.             png_ptr->gamma/* Probably doing rgb_to_gray */);
    2865. 

  2865.      }
    2866. 

  2866. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
    2867. 

  2867.   }
    2868. 

  2868. }
    2869. 

  2869. #endif /* READ_GAMMA */
    2870. 

  2870. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
    2871. 

  2871.