/libpng/png.c

https://code.google.com/p/xee/ · C · 828 lines · 618 code · 92 blank · 118 comment · 111 complexity · f88818cd80573a586f202496a8b6b728 MD5 · raw file 

    

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

  2.  *
    3. 

  3.  * libpng version 1.2.8 - December 3, 2004
    4. 

  4.  * For conditions of distribution and use, see copyright notice in png.h
    5. 

  5.  * Copyright (c) 1998-2004 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. 

  10. #define PNG_INTERNAL
    11. 

  11. #define PNG_NO_EXTERN
    12. 

  12. #include "png.h"
    13. 

  13. 

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

  15. typedef version_1_2_8 Your_png_h_is_not_version_1_2_8;
    16. 

  16. 

  17. /* Version information for C files.  This had better match the version
    18. 

  18.  * string defined in png.h.  */
    19. 

  19. 

  20. #ifdef PNG_USE_GLOBAL_ARRAYS
    21. 

  21. /* png_libpng_ver was changed to a function in version 1.0.5c */
    22. 

  22. const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
    23. 

  23. 

  24. /* png_sig was changed to a function in version 1.0.5c */
    25. 

  25. /* Place to hold the signature string for a PNG file. */
    26. 

  26. const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
    27. 

  27. 

  28. /* Invoke global declarations for constant strings for known chunk types */
    29. 

  29. PNG_IHDR;
    30. 

  30. PNG_IDAT;
    31. 

  31. PNG_IEND;
    32. 

  32. PNG_PLTE;
    33. 

  33. PNG_bKGD;
    34. 

  34. PNG_cHRM;
    35. 

  35. PNG_gAMA;
    36. 

  36. PNG_hIST;
    37. 

  37. PNG_iCCP;
    38. 

  38. PNG_iTXt;
    39. 

  39. PNG_oFFs;
    40. 

  40. PNG_pCAL;
    41. 

  41. PNG_sCAL;
    42. 

  42. PNG_pHYs;
    43. 

  43. PNG_sBIT;
    44. 

  44. PNG_sPLT;
    45. 

  45. PNG_sRGB;
    46. 

  46. PNG_tEXt;
    47. 

  47. PNG_tIME;
    48. 

  48. PNG_tRNS;
    49. 

  49. PNG_zTXt;
    50. 

  50. 

  51. /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
    52. 

  52. 

  53. /* start of interlace block */
    54. 

  54. const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
    55. 

  55. 

  56. /* offset to next interlace block */
    57. 

  57. const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
    58. 

  58. 

  59. /* start of interlace block in the y direction */
    60. 

  60. const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
    61. 

  61. 

  62. /* offset to next interlace block in the y direction */
    63. 

  63. const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
    64. 

  64. 

  65. /* width of interlace block (used in assembler routines only) */
    66. 

  66. #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
    67. 

  67. const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
    68. 

  68. #endif
    69. 

  69. 

  70. /* Height of interlace block.  This is not currently used - if you need
    71. 

  71.  * it, uncomment it here and in png.h
    72. 

  72. const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
    73. 

  73. */
    74. 

  74. 

  75. /* Mask to determine which pixels are valid in a pass */
    76. 

  76. const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
    77. 

  77. 

  78. /* Mask to determine which pixels to overwrite while displaying */
    79. 

  79. const int FARDATA png_pass_dsp_mask[]
    80. 

  80.    = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
    81. 

  81. 

  82. #endif /* PNG_USE_GLOBAL_ARRAYS */
    83. 

  83. 

  84. /* Tells libpng that we have already handled the first "num_bytes" bytes
    85. 

  85.  * of the PNG file signature.  If the PNG data is embedded into another
    86. 

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

  87.  * or write any of the magic bytes before it starts on the IHDR.
    88. 

  88.  */
    89. 

  89. 

  90. void PNGAPI
    91. 

  91. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
    92. 

  92. {
    93. 

  93.    png_debug(1, "in png_set_sig_bytes\n");
    94. 

  94.    if (num_bytes > 8)
    95. 

  95.       png_error(png_ptr, "Too many bytes for PNG signature.");
    96. 

  96. 

  97.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
    98. 

  98. }
    99. 

  99. 

  100. /* Checks whether the supplied bytes match the PNG signature.  We allow
    101. 

  101.  * checking less than the full 8-byte signature so that those apps that
    102. 

  102.  * already read the first few bytes of a file to determine the file type
    103. 

  103.  * can simply check the remaining bytes for extra assurance.  Returns
    104. 

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

  105.  * respectively, to be less than, to match, or be greater than the correct
    106. 

  106.  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
    107. 

  107.  */
    108. 

  108. int PNGAPI
    109. 

  109. png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
    110. 

  110. {
    111. 

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

  112.    if (num_to_check > 8)
    113. 

  113.       num_to_check = 8;
    114. 

  114.    else if (num_to_check < 1)
    115. 

  115.       return (0);
    116. 

  116. 

  117.    if (start > 7)
    118. 

  118.       return (0);
    119. 

  119. 

  120.    if (start + num_to_check > 8)
    121. 

  121.       num_to_check = 8 - start;
    122. 

  122. 

  123.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
    124. 

  124. }
    125. 

  125. 

  126. /* (Obsolete) function to check signature bytes.  It does not allow one
    127. 

  127.  * to check a partial signature.  This function might be removed in the
    128. 

  128.  * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
    129. 

  129.  */
    130. 

  130. int PNGAPI
    131. 

  131. png_check_sig(png_bytep sig, int num)
    132. 

  132. {
    133. 

  133.   return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
    134. 

  134. }
    135. 

  135. 

  136. /* Function to allocate memory for zlib and clear it to 0. */
    137. 

  137. #ifdef PNG_1_0_X
    138. 

  138. voidpf PNGAPI
    139. 

  139. #else
    140. 

  140. voidpf /* private */
    141. 

  141. #endif
    142. 

  142. png_zalloc(voidpf png_ptr, uInt items, uInt size)
    143. 

  143. {
    144. 

  144.    png_voidp ptr;
    145. 

  145.    png_structp p=png_ptr;
    146. 

  146.    png_uint_32 save_flags=p->flags;
    147. 

  147.    png_uint_32 num_bytes;
    148. 

  148. 

  149.    if (items > PNG_UINT_32_MAX/size)
    150. 

  150.    {
    151. 

  151.      png_warning (png_ptr, "Potential overflow in png_zalloc()");
    152. 

  152.      return (NULL);
    153. 

  153.    }
    154. 

  154.    num_bytes = (png_uint_32)items * size;
    155. 

  155. 

  156.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
    157. 

  157.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
    158. 

  158.    p->flags=save_flags;
    159. 

  159. 

  160. #if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
    161. 

  161.    if (ptr == NULL)
    162. 

  162.        return ((voidpf)ptr);
    163. 

  163. 

  164.    if (num_bytes > (png_uint_32)0x8000L)
    165. 

  165.    {
    166. 

  166.       png_memset(ptr, 0, (png_size_t)0x8000L);
    167. 

  167.       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
    168. 

  168.          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
    169. 

  169.    }
    170. 

  170.    else
    171. 

  171.    {
    172. 

  172.       png_memset(ptr, 0, (png_size_t)num_bytes);
    173. 

  173.    }
    174. 

  174. #endif
    175. 

  175.    return ((voidpf)ptr);
    176. 

  176. }
    177. 

  177. 

  178. /* function to free memory for zlib */
    179. 

  179. #ifdef PNG_1_0_X
    180. 

  180. void PNGAPI
    181. 

  181. #else
    182. 

  182. void /* private */
    183. 

  183. #endif
    184. 

  184. png_zfree(voidpf png_ptr, voidpf ptr)
    185. 

  185. {
    186. 

  186.    png_free((png_structp)png_ptr, (png_voidp)ptr);
    187. 

  187. }
    188. 

  188. 

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

  190.  * in case CRC is > 32 bits to leave the top bits 0.
    191. 

  191.  */
    192. 

  192. void /* PRIVATE */
    193. 

  193. png_reset_crc(png_structp png_ptr)
    194. 

  194. {
    195. 

  195.    png_ptr->crc = crc32(0, Z_NULL, 0);
    196. 

  196. }
    197. 

  197. 

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

  199.  * much data to this routine as the largest single buffer size.  We
    200. 

  200.  * also check that this data will actually be used before going to the
    201. 

  201.  * trouble of calculating it.
    202. 

  202.  */
    203. 

  203. void /* PRIVATE */
    204. 

  204. png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
    205. 

  205. {
    206. 

  206.    int need_crc = 1;
    207. 

  207. 

  208.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
    209. 

  209.    {
    210. 

  210.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
    211. 

  211.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
    212. 

  212.          need_crc = 0;
    213. 

  213.    }
    214. 

  214.    else                                                    /* critical */
    215. 

  215.    {
    216. 

  216.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
    217. 

  217.          need_crc = 0;
    218. 

  218.    }
    219. 

  219. 

  220.    if (need_crc)
    221. 

  221.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
    222. 

  222. }
    223. 

  223. 

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

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

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

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

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

  229.  */
    230. 

  230. png_infop PNGAPI
    231. 

  231. png_create_info_struct(png_structp png_ptr)
    232. 

  232. {
    233. 

  233.    png_infop info_ptr;
    234. 

  234. 

  235.    png_debug(1, "in png_create_info_struct\n");
    236. 

  236.    if(png_ptr == NULL) return (NULL);
    237. 

  237. #ifdef PNG_USER_MEM_SUPPORTED
    238. 

  238.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
    239. 

  239.       png_ptr->malloc_fn, png_ptr->mem_ptr);
    240. 

  240. #else
    241. 

  241.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
    242. 

  242. #endif
    243. 

  243.    if (info_ptr != NULL)
    244. 

  244.       png_info_init_3(&info_ptr, png_sizeof(png_info));
    245. 

  245. 

  246.    return (info_ptr);
    247. 

  247. }
    248. 

  248. 

  249. /* This function frees the memory associated with a single info struct.
    250. 

  250.  * Normally, one would use either png_destroy_read_struct() or
    251. 

  251.  * png_destroy_write_struct() to free an info struct, but this may be
    252. 

  252.  * useful for some applications.
    253. 

  253.  */
    254. 

  254. void PNGAPI
    255. 

  255. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
    256. 

  256. {
    257. 

  257.    png_infop info_ptr = NULL;
    258. 

  258. 

  259.    png_debug(1, "in png_destroy_info_struct\n");
    260. 

  260.    if (info_ptr_ptr != NULL)
    261. 

  261.       info_ptr = *info_ptr_ptr;
    262. 

  262. 

  263.    if (info_ptr != NULL)
    264. 

  264.    {
    265. 

  265.       png_info_destroy(png_ptr, info_ptr);
    266. 

  266. 

  267. #ifdef PNG_USER_MEM_SUPPORTED
    268. 

  268.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
    269. 

  269.           png_ptr->mem_ptr);
    270. 

  270. #else
    271. 

  271.       png_destroy_struct((png_voidp)info_ptr);
    272. 

  272. #endif
    273. 

  273.       *info_ptr_ptr = NULL;
    274. 

  274.    }
    275. 

  275. }
    276. 

  276. 

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

  278.  * and applications using it are urged to use png_create_info_struct()
    279. 

  279.  * instead.
    280. 

  280.  */
    281. 

  281. #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
    282. 

  282. #undef png_info_init
    283. 

  283. void PNGAPI
    284. 

  284. png_info_init(png_infop info_ptr)
    285. 

  285. {
    286. 

  286.    /* We only come here via pre-1.0.12-compiled applications */
    287. 

  287.    png_info_init_3(&info_ptr, 0);
    288. 

  288. }
    289. 

  289. #endif
    290. 

  290. 

  291. void PNGAPI
    292. 

  292. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
    293. 

  293. {
    294. 

  294.    png_infop info_ptr = *ptr_ptr;
    295. 

  295. 

  296.    png_debug(1, "in png_info_init_3\n");
    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. #ifdef PNG_FREE_ME_SUPPORTED
    310. 

  310. void PNGAPI
    311. 

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

  312.    int freer, png_uint_32 mask)
    313. 

  313. {
    314. 

  314.    png_debug(1, "in png_data_freer\n");
    315. 

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

  316.       return;
    317. 

  317.    if(freer == PNG_DESTROY_WILL_FREE_DATA)
    318. 

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

  319.    else if(freer == PNG_USER_WILL_FREE_DATA)
    320. 

  320.       info_ptr->free_me &= ~mask;
    321. 

  321.    else
    322. 

  322.       png_warning(png_ptr,
    323. 

  323.          "Unknown freer parameter in png_data_freer.");
    324. 

  324. }
    325. 

  325. #endif
    326. 

  326. 

  327. void PNGAPI
    328. 

  328. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
    329. 

  329.    int num)
    330. 

  330. {
    331. 

  331.    png_debug(1, "in png_free_data\n");
    332. 

  332.    if (png_ptr == NULL || info_ptr == NULL)
    333. 

  333.       return;
    334. 

  334. 

  335. #if defined(PNG_TEXT_SUPPORTED)
    336. 

  336. /* free text item num or (if num == -1) all text items */
    337. 

  337. #ifdef PNG_FREE_ME_SUPPORTED
    338. 

  338. if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
    339. 

  339. #else
    340. 

  340. if (mask & PNG_FREE_TEXT)
    341. 

  341. #endif
    342. 

  342. {
    343. 

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

  344.    {
    345. 

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

  346.      {
    347. 

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

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

  349.      }
    350. 

  350.    }
    351. 

  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. #if defined(PNG_tRNS_SUPPORTED)
    364. 

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

  365. #ifdef PNG_FREE_ME_SUPPORTED
    366. 

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

  367. #else
    368. 

  368. if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
    369. 

  369. #endif
    370. 

  370. {
    371. 

  371.     png_free(png_ptr, info_ptr->trans);
    372. 

  372.     info_ptr->valid &= ~PNG_INFO_tRNS;
    373. 

  373. #ifndef PNG_FREE_ME_SUPPORTED
    374. 

  374.     png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
    375. 

  375. #endif
    376. 

  376.     info_ptr->trans = NULL;
    377. 

  377. }
    378. 

  378. #endif
    379. 

  379. 

  380. #if defined(PNG_sCAL_SUPPORTED)
    381. 

  381. /* free any sCAL entry */
    382. 

  382. #ifdef PNG_FREE_ME_SUPPORTED
    383. 

  383. if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
    384. 

  384. #else
    385. 

  385. if (mask & PNG_FREE_SCAL)
    386. 

  386. #endif
    387. 

  387. {
    388. 

  388. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
    389. 

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

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

  391.     info_ptr->scal_s_width = NULL;
    392. 

  392.     info_ptr->scal_s_height = NULL;
    393. 

  393. #endif
    394. 

  394.     info_ptr->valid &= ~PNG_INFO_sCAL;
    395. 

  395. }
    396. 

  396. #endif
    397. 

  397. 

  398. #if defined(PNG_pCAL_SUPPORTED)
    399. 

  399. /* free any pCAL entry */
    400. 

  400. #ifdef PNG_FREE_ME_SUPPORTED
    401. 

  401. if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
    402. 

  402. #else
    403. 

  403. if (mask & PNG_FREE_PCAL)
    404. 

  404. #endif
    405. 

  405. {
    406. 

  406.     png_free(png_ptr, info_ptr->pcal_purpose);
    407. 

  407.     png_free(png_ptr, info_ptr->pcal_units);
    408. 

  408.     info_ptr->pcal_purpose = NULL;
    409. 

  409.     info_ptr->pcal_units = NULL;
    410. 

  410.     if (info_ptr->pcal_params != NULL)
    411. 

  411.     {
    412. 

  412.         int i;
    413. 

  413.         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
    414. 

  414.         {
    415. 

  415.           png_free(png_ptr, info_ptr->pcal_params[i]);
    416. 

  416.           info_ptr->pcal_params[i]=NULL;
    417. 

  417.         }
    418. 

  418.         png_free(png_ptr, info_ptr->pcal_params);
    419. 

  419.         info_ptr->pcal_params = NULL;
    420. 

  420.     }
    421. 

  421.     info_ptr->valid &= ~PNG_INFO_pCAL;
    422. 

  422. }
    423. 

  423. #endif
    424. 

  424. 

  425. #if defined(PNG_iCCP_SUPPORTED)
    426. 

  426. /* free any iCCP entry */
    427. 

  427. #ifdef PNG_FREE_ME_SUPPORTED
    428. 

  428. if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
    429. 

  429. #else
    430. 

  430. if (mask & PNG_FREE_ICCP)
    431. 

  431. #endif
    432. 

  432. {
    433. 

  433.     png_free(png_ptr, info_ptr->iccp_name);
    434. 

  434.     png_free(png_ptr, info_ptr->iccp_profile);
    435. 

  435.     info_ptr->iccp_name = NULL;
    436. 

  436.     info_ptr->iccp_profile = NULL;
    437. 

  437.     info_ptr->valid &= ~PNG_INFO_iCCP;
    438. 

  438. }
    439. 

  439. #endif
    440. 

  440. 

  441. #if defined(PNG_sPLT_SUPPORTED)
    442. 

  442. /* free a given sPLT entry, or (if num == -1) all sPLT entries */
    443. 

  443. #ifdef PNG_FREE_ME_SUPPORTED
    444. 

  444. if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
    445. 

  445. #else
    446. 

  446. if (mask & PNG_FREE_SPLT)
    447. 

  447. #endif
    448. 

  448. {
    449. 

  449.    if (num != -1)
    450. 

  450.    {
    451. 

  451.       if(info_ptr->splt_palettes)
    452. 

  452.       {
    453. 

  453.           png_free(png_ptr, info_ptr->splt_palettes[num].name);
    454. 

  454.           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
    455. 

  455.           info_ptr->splt_palettes[num].name = NULL;
    456. 

  456.           info_ptr->splt_palettes[num].entries = NULL;
    457. 

  457.       }
    458. 

  458.    }
    459. 

  459.    else
    460. 

  460.    {
    461. 

  461.        if(info_ptr->splt_palettes_num)
    462. 

  462.        {
    463. 

  463.          int i;
    464. 

  464.          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
    465. 

  465.             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
    466. 

  466. 

  467.          png_free(png_ptr, info_ptr->splt_palettes);
    468. 

  468.          info_ptr->splt_palettes = NULL;
    469. 

  469.          info_ptr->splt_palettes_num = 0;
    470. 

  470.        }
    471. 

  471.        info_ptr->valid &= ~PNG_INFO_sPLT;
    472. 

  472.    }
    473. 

  473. }
    474. 

  474. #endif
    475. 

  475. 

  476. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
    477. 

  477. #ifdef PNG_FREE_ME_SUPPORTED
    478. 

  478. if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
    479. 

  479. #else
    480. 

  480. if (mask & PNG_FREE_UNKN)
    481. 

  481. #endif
    482. 

  482. {
    483. 

  483.    if (num != -1)
    484. 

  484.    {
    485. 

  485.        if(info_ptr->unknown_chunks)
    486. 

  486.        {
    487. 

  487.           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
    488. 

  488.           info_ptr->unknown_chunks[num].data = NULL;
    489. 

  489.        }
    490. 

  490.    }
    491. 

  491.    else
    492. 

  492.    {
    493. 

  493.        int i;
    494. 

  494. 

  495.        if(info_ptr->unknown_chunks_num)
    496. 

  496.        {
    497. 

  497.          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
    498. 

  498.             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
    499. 

  499. 

  500.          png_free(png_ptr, info_ptr->unknown_chunks);
    501. 

  501.          info_ptr->unknown_chunks = NULL;
    502. 

  502.          info_ptr->unknown_chunks_num = 0;
    503. 

  503.        }
    504. 

  504.    }
    505. 

  505. }
    506. 

  506. #endif
    507. 

  507. 

  508. #if defined(PNG_hIST_SUPPORTED)
    509. 

  509. /* free any hIST entry */
    510. 

  510. #ifdef PNG_FREE_ME_SUPPORTED
    511. 

  511. if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
    512. 

  512. #else
    513. 

  513. if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
    514. 

  514. #endif
    515. 

  515. {
    516. 

  516.     png_free(png_ptr, info_ptr->hist);
    517. 

  517.     info_ptr->hist = NULL;
    518. 

  518.     info_ptr->valid &= ~PNG_INFO_hIST;
    519. 

  519. #ifndef PNG_FREE_ME_SUPPORTED
    520. 

  520.     png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
    521. 

  521. #endif
    522. 

  522. }
    523. 

  523. #endif
    524. 

  524. 

  525. /* free any PLTE entry that was internally allocated */
    526. 

  526. #ifdef PNG_FREE_ME_SUPPORTED
    527. 

  527. if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
    528. 

  528. #else
    529. 

  529. if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
    530. 

  530. #endif
    531. 

  531. {
    532. 

  532.     png_zfree(png_ptr, info_ptr->palette);
    533. 

  533.     info_ptr->palette = NULL;
    534. 

  534.     info_ptr->valid &= ~PNG_INFO_PLTE;
    535. 

  535. #ifndef PNG_FREE_ME_SUPPORTED
    536. 

  536.     png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
    537. 

  537. #endif
    538. 

  538.     info_ptr->num_palette = 0;
    539. 

  539. }
    540. 

  540. 

  541. #if defined(PNG_INFO_IMAGE_SUPPORTED)
    542. 

  542. /* free any image bits attached to the info structure */
    543. 

  543. #ifdef PNG_FREE_ME_SUPPORTED
    544. 

  544. if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
    545. 

  545. #else
    546. 

  546. if (mask & PNG_FREE_ROWS)
    547. 

  547. #endif
    548. 

  548. {
    549. 

  549.     if(info_ptr->row_pointers)
    550. 

  550.     {
    551. 

  551.        int row;
    552. 

  552.        for (row = 0; row < (int)info_ptr->height; row++)
    553. 

  553.        {
    554. 

  554.           png_free(png_ptr, info_ptr->row_pointers[row]);
    555. 

  555.           info_ptr->row_pointers[row]=NULL;
    556. 

  556.        }
    557. 

  557.        png_free(png_ptr, info_ptr->row_pointers);
    558. 

  558.        info_ptr->row_pointers=NULL;
    559. 

  559.     }
    560. 

  560.     info_ptr->valid &= ~PNG_INFO_IDAT;
    561. 

  561. }
    562. 

  562. #endif
    563. 

  563. 

  564. #ifdef PNG_FREE_ME_SUPPORTED
    565. 

  565.    if(num == -1)
    566. 

  566.      info_ptr->free_me &= ~mask;
    567. 

  567.    else
    568. 

  568.      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
    569. 

  569. #endif
    570. 

  570. }
    571. 

  571. 

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

  573.  * pointing to before re-using it or freeing the struct itself.  Recall
    574. 

  574.  * that png_free() checks for NULL pointers for us.
    575. 

  575.  */
    576. 

  576. void /* PRIVATE */
    577. 

  577. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
    578. 

  578. {
    579. 

  579.    png_debug(1, "in png_info_destroy\n");
    580. 

  580. 

  581.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
    582. 

  582. 

  583. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
    584. 

  584.    if (png_ptr->num_chunk_list)
    585. 

  585.    {
    586. 

  586.        png_free(png_ptr, png_ptr->chunk_list);
    587. 

  587.        png_ptr->chunk_list=NULL;
    588. 

  588.        png_ptr->num_chunk_list=0;
    589. 

  589.    }
    590. 

  590. #endif
    591. 

  591. 

  592.    png_info_init_3(&info_ptr, png_sizeof(png_info));
    593. 

  593. }
    594. 

  594. 

  595. /* This function returns a pointer to the io_ptr associated with the user
    596. 

  596.  * functions.  The application should free any memory associated with this
    597. 

  597.  * pointer before png_write_destroy() or png_read_destroy() are called.
    598. 

  598.  */
    599. 

  599. png_voidp PNGAPI
    600. 

  600. png_get_io_ptr(png_structp png_ptr)
    601. 

  601. {
    602. 

  602.    return (png_ptr->io_ptr);
    603. 

  603. }
    604. 

  604. 

  605. #if !defined(PNG_NO_STDIO)
    606. 

  606. /* Initialize the default input/output functions for the PNG file.  If you
    607. 

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

  608.  * or png_set_write_fn() instead of png_init_io().  If you have defined
    609. 

  609.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
    610. 

  610.  * necessarily available.
    611. 

  611.  */
    612. 

  612. void PNGAPI
    613. 

  613. png_init_io(png_structp png_ptr, png_FILE_p fp)
    614. 

  614. {
    615. 

  615.    png_debug(1, "in png_init_io\n");
    616. 

  616.    png_ptr->io_ptr = (png_voidp)fp;
    617. 

  617. }
    618. 

  618. #endif
    619. 

  619. 

  620. #if defined(PNG_TIME_RFC1123_SUPPORTED)
    621. 

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

  622.  * a "Creation Time" or other text-based time string.
    623. 

  623.  */
    624. 

  624. png_charp PNGAPI
    625. 

  625. png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
    626. 

  626. {
    627. 

  627.    static PNG_CONST char short_months[12][4] =
    628. 

  628.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
    629. 

  629.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
    630. 

  630. 

  631.    if (png_ptr->time_buffer == NULL)
    632. 

  632.    {
    633. 

  633.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
    634. 

  634.          png_sizeof(char)));
    635. 

  635.    }
    636. 

  636. 

  637. #if defined(_WIN32_WCE)
    638. 

  638.    {
    639. 

  639.       wchar_t time_buf[29];
    640. 

  640.       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
    641. 

  641.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
    642. 

  642.         ptime->year, ptime->hour % 24, ptime->minute % 60,
    643. 

  643.           ptime->second % 61);
    644. 

  644.       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
    645. 

  645.           NULL, NULL);
    646. 

  646.    }
    647. 

  647. #else
    648. 

  648. #ifdef USE_FAR_KEYWORD
    649. 

  649.    {
    650. 

  650.       char near_time_buf[29];
    651. 

  651.       sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
    652. 

  652.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
    653. 

  653.           ptime->year, ptime->hour % 24, ptime->minute % 60,
    654. 

  654.           ptime->second % 61);
    655. 

  655.       png_memcpy(png_ptr->time_buffer, near_time_buf,
    656. 

  656.           29*png_sizeof(char));
    657. 

  657.    }
    658. 

  658. #else
    659. 

  659.    sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
    660. 

  660.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
    661. 

  661.        ptime->year, ptime->hour % 24, ptime->minute % 60,
    662. 

  662.        ptime->second % 61);
    663. 

  663. #endif
    664. 

  664. #endif /* _WIN32_WCE */
    665. 

  665.    return ((png_charp)png_ptr->time_buffer);
    666. 

  666. }
    667. 

  667. #endif /* PNG_TIME_RFC1123_SUPPORTED */
    668. 

  668. 

  669. #if 0
    670. 

  670. /* Signature string for a PNG file. */
    671. 

  671. png_bytep PNGAPI
    672. 

  672. png_sig_bytes(void)
    673. 

  673. {
    674. 

  674.    return ((png_bytep)"\211\120\116\107\015\012\032\012");
    675. 

  675. }
    676. 

  676. #endif
    677. 

  677. 

  678. png_charp PNGAPI
    679. 

  679. png_get_copyright(png_structp png_ptr)
    680. 

  680. {
    681. 

  681.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
    682. 

  682.    return ((png_charp) "\n libpng version 1.2.8 - December 3, 2004\n\
    683. 

  683.    Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\
    684. 

  684.    Copyright (c) 1996-1997 Andreas Dilger\n\
    685. 

  685.    Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
    686. 

  686.    return ((png_charp) "");
    687. 

  687. }
    688. 

  688. 

  689. /* The following return the library version as a short string in the
    690. 

  690.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
    691. 

  691.  * used with your application, print out PNG_LIBPNG_VER_STRING, which
    692. 

  692.  * is defined in png.h.
    693. 

  693.  * Note: now there is no difference between png_get_libpng_ver() and
    694. 

  694.  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
    695. 

  695.  * it is guaranteed that png.c uses the correct version of png.h.
    696. 

  696.  */
    697. 

  697. png_charp PNGAPI
    698. 

  698. png_get_libpng_ver(png_structp png_ptr)
    699. 

  699. {
    700. 

  700.    /* Version of *.c files used when building libpng */
    701. 

  701.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
    702. 

  702.       return ((png_charp) PNG_LIBPNG_VER_STRING);
    703. 

  703.    return ((png_charp) "");
    704. 

  704. }
    705. 

  705. 

  706. png_charp PNGAPI
    707. 

  707. png_get_header_ver(png_structp png_ptr)
    708. 

  708. {
    709. 

  709.    /* Version of *.h files used when building libpng */
    710. 

  710.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
    711. 

  711.       return ((png_charp) PNG_LIBPNG_VER_STRING);
    712. 

  712.    return ((png_charp) "");
    713. 

  713. }
    714. 

  714. 

  715. png_charp PNGAPI
    716. 

  716. png_get_header_version(png_structp png_ptr)
    717. 

  717. {
    718. 

  718.    /* Returns longer string containing both version and date */
    719. 

  719.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
    720. 

  720.       return ((png_charp) PNG_HEADER_VERSION_STRING);
    721. 

  721.    return ((png_charp) "");
    722. 

  722. }
    723. 

  723. 

  724. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    725. 

  725. int PNGAPI
    726. 

  726. png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
    727. 

  727. {
    728. 

  728.    /* check chunk_name and return "keep" value if it's on the list, else 0 */
    729. 

  729.    int i;
    730. 

  730.    png_bytep p;
    731. 

  731.    if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
    732. 

  732.       return 0;
    733. 

  733.    p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
    734. 

  734.    for (i = png_ptr->num_chunk_list; i; i--, p-=5)
    735. 

  735.       if (!png_memcmp(chunk_name, p, 4))
    736. 

  736.         return ((int)*(p+4));
    737. 

  737.    return 0;
    738. 

  738. }
    739. 

  739. #endif
    740. 

  740. 

  741. /* This function, added to libpng-1.0.6g, is untested. */
    742. 

  742. int PNGAPI
    743. 

  743. png_reset_zstream(png_structp png_ptr)
    744. 

  744. {
    745. 

  745.    return (inflateReset(&png_ptr->zstream));
    746. 

  746. }
    747. 

  747. 

  748. /* This function was added to libpng-1.0.7 */
    749. 

  749. png_uint_32 PNGAPI
    750. 

  750. png_access_version_number(void)
    751. 

  751. {
    752. 

  752.    /* Version of *.c files used when building libpng */
    753. 

  753.    return((png_uint_32) PNG_LIBPNG_VER);
    754. 

  754. }
    755. 

  755. 

  756. 

  757. #if !defined(PNG_1_0_X)
    758. 

  758. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
    759. 

  759.     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
    760. 

  760. /* this INTERNAL function was added to libpng 1.2.0 */
    761. 

  761. void /* PRIVATE */
    762. 

  762. png_init_mmx_flags (png_structp png_ptr)
    763. 

  763. {
    764. 

  764.     png_ptr->mmx_rowbytes_threshold = 0;
    765. 

  765.     png_ptr->mmx_bitdepth_threshold = 0;
    766. 

  766. 

  767. #  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
    768. 

  768. 

  769.     png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
    770. 

  770. 

  771.     if (png_mmx_support() > 0) {
    772. 

  772.         png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
    773. 

  773. #    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
    774. 

  774.                               | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
    775. 

  775. #    endif
    776. 

  776. #    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
    777. 

  777.                               | PNG_ASM_FLAG_MMX_READ_INTERLACE
    778. 

  778. #    endif
    779. 

  779. #    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
    780. 

  780.                               ;
    781. 

  781. #    else
    782. 

  782.                               | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
    783. 

  783.                               | PNG_ASM_FLAG_MMX_READ_FILTER_UP
    784. 

  784.                               | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
    785. 

  785.                               | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
    786. 

  786. 

  787.         png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
    788. 

  788.         png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
    789. 

  789. #    endif
    790. 

  790.     } else {
    791. 

  791.         png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
    792. 

  792.                                | PNG_MMX_READ_FLAGS
    793. 

  793.                                | PNG_MMX_WRITE_FLAGS );
    794. 

  794.     }
    795. 

  795. 

  796. #  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
    797. 

  797. 

  798.     /* clear all MMX flags; no support is compiled in */
    799. 

  799.     png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
    800. 

  800. 

  801. #  endif /* ?(PNGVCRD || PNGGCCRD) */
    802. 

  802. }
    803. 

  803. 

  804. #endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */
    805. 

  805. 

  806. /* this function was added to libpng 1.2.0 */
    807. 

  807. #if !defined(PNG_USE_PNGGCCRD) && \
    808. 

  808.     !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
    809. 

  809. int PNGAPI
    810. 

  810. png_mmx_support(void)
    811. 

  811. {
    812. 

  812.     return -1;
    813. 

  813. }
    814. 

  814. #endif
    815. 

  815. #endif /* PNG_1_0_X */
    816. 

  816. 

  817. #ifdef PNG_SIZE_T
    818. 

  818. /* Added at libpng version 1.2.6 */
    819. 

  819.    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
    820. 

  820. png_size_t PNGAPI
    821. 

  821. png_convert_size(size_t size)
    822. 

  822. {
    823. 

  823.   if (size > (png_size_t)-1)
    824. 

  824.      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
    825. 

  825.   return ((png_size_t)size);
    826. 

  826. }
    827. 

  827. #endif /* PNG_SIZE_T */
    828.