开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
png.c
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：26k
源码类别：

界面编程

开发平台：

Visual C++

png.c：源码内容
  2. /* png.c - location for general purpose libpng functions
  3.  *
  4.  * Last changed in libpng 1.2.34 [December 18, 2008]
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2008 Glenn Randers-Pehrson
  7.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  8.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  9.  */
  11. #if ( ! defined _CRT_SECURE_NO_WARNINGS )
  12. #define _CRT_SECURE_NO_WARNINGS
  13. #endif
  15. #define PNG_INTERNAL
  16. #define PNG_NO_EXTERN
  17. #include "png.h"
  19. /* Generate a compiler error if there is an old png.h in the search path. */
  20. typedef version_1_2_34 Your_png_h_is_not_version_1_2_34;
  22. /* Version information for C files.  This had better match the version
  23.  * string defined in png.h.  */
  25. #ifdef PNG_USE_GLOBAL_ARRAYS
  26. /* png_libpng_ver was changed to a function in version 1.0.5c */
  27. PNG_CONST char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
  29. #ifdef PNG_READ_SUPPORTED
  31. /* png_sig was changed to a function in version 1.0.5c */
  32. /* Place to hold the signature string for a PNG file. */
  33. PNG_CONST png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  34. #endif /* PNG_READ_SUPPORTED */
  36. /* Invoke global declarations for constant strings for known chunk types */
  37. PNG_IHDR;
  38. PNG_IDAT;
  39. PNG_IEND;
  40. PNG_PLTE;
  41. PNG_bKGD;
  42. PNG_cHRM;
  43. PNG_gAMA;
  44. PNG_hIST;
  45. PNG_iCCP;
  46. PNG_iTXt;
  47. PNG_oFFs;
  48. PNG_pCAL;
  49. PNG_sCAL;
  50. PNG_pHYs;
  51. PNG_sBIT;
  52. PNG_sPLT;
  53. PNG_sRGB;
  54. PNG_tEXt;
  55. PNG_tIME;
  56. PNG_tRNS;
  57. PNG_zTXt;
  59. #ifdef PNG_READ_SUPPORTED
  60. /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  62. /* start of interlace block */
  63. PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
  65. /* offset to next interlace block */
  66. PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
  68. /* start of interlace block in the y direction */
  69. PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
  71. /* offset to next interlace block in the y direction */
  72. PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
  74. /* Height of interlace block.  This is not currently used - if you need
  75.  * it, uncomment it here and in png.h
  76. PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
  77. */
  79. /* Mask to determine which pixels are valid in a pass */
  80. PNG_CONST int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
  82. /* Mask to determine which pixels to overwrite while displaying */
  83. PNG_CONST int FARDATA png_pass_dsp_mask[]
  84.    = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
  86. #endif /* PNG_READ_SUPPORTED */
  87. #endif /* PNG_USE_GLOBAL_ARRAYS */
  89. /* Tells libpng that we have already handled the first "num_bytes" bytes
  90.  * of the PNG file signature.  If the PNG data is embedded into another
  91.  * stream we can set num_bytes = 8 so that libpng will not attempt to read
  92.  * or write any of the magic bytes before it starts on the IHDR.
  93.  */
  95. #ifdef PNG_READ_SUPPORTED
  96. void PNGAPI
  97. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
  98. {
  99.    if (png_ptr == NULL) return;
  100.    png_debug(1, "in png_set_sig_bytes");
  101.    if (num_bytes > 8)
  102.       png_error(png_ptr, "Too many bytes for PNG signature.");
  104.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
  105. }
  107. /* Checks whether the supplied bytes match the PNG signature.  We allow
  108.  * checking less than the full 8-byte signature so that those apps that
  109.  * already read the first few bytes of a file to determine the file type
  110.  * can simply check the remaining bytes for extra assurance.  Returns
  111.  * an integer less than, equal to, or greater than zero if sig is found,
  112.  * respectively, to be less than, to match, or be greater than the correct
  113.  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
  114.  */
  115. int PNGAPI
  116. png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
  117. {
  118.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  119.    if (num_to_check > 8)
  120.       num_to_check = 8;
  121.    else if (num_to_check < 1)
  122.       return (-1);
  124.    if (start > 7)
  125.       return (-1);
  127.    if (start + num_to_check > 8)
  128.       num_to_check = 8 - start;
  130.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
  131. }
  133. #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
  134. /* (Obsolete) function to check signature bytes.  It does not allow one
  135.  * to check a partial signature.  This function might be removed in the
  136.  * future - use png_sig_cmp().  Returns true (nonzero) if the file is PNG.
  137.  */
  138. int PNGAPI
  139. png_check_sig(png_bytep sig, int num)
  140. {
  141.   return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
  142. }
  143. #endif
  144. #endif /* PNG_READ_SUPPORTED */
  146. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  147. /* Function to allocate memory for zlib and clear it to 0. */
  148. #ifdef PNG_1_0_X
  149. voidpf PNGAPI
  150. #else
  151. voidpf /* private */
  152. #endif
  153. png_zalloc(voidpf png_ptr, uInt items, uInt size)
  154. {
  155.    png_voidp ptr;
  156.    png_structp p=(png_structp)png_ptr;
  157.    png_uint_32 save_flags=p->flags;
  158.    png_uint_32 num_bytes;
  160.    if (png_ptr == NULL) return (NULL);
  161.    if (items > PNG_UINT_32_MAX/size)
  162.    {
  163.      png_warning (p, "Potential overflow in png_zalloc()");
  164.      return (NULL);
  165.    }
  166.    num_bytes = (png_uint_32)items * size;
  168.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  169.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
  170.    p->flags=save_flags;
  172. #if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
  173.    if (ptr == NULL)
  174.        return ((voidpf)ptr);
  176.    if (num_bytes > (png_uint_32)0x8000L)
  177.    {
  178.       png_memset(ptr, 0, (png_size_t)0x8000L);
  179.       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
  180.          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
  181.    }
  182.    else
  183.    {
  184.       png_memset(ptr, 0, (png_size_t)num_bytes);
  185.    }
  186. #endif
  187.    return ((voidpf)ptr);
  188. }
  190. /* function to free memory for zlib */
  191. #ifdef PNG_1_0_X
  192. void PNGAPI
  193. #else
  194. void /* private */
  195. #endif
  196. png_zfree(voidpf png_ptr, voidpf ptr)
  197. {
  198.    png_free((png_structp)png_ptr, (png_voidp)ptr);
  199. }
  201. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
  202.  * in case CRC is > 32 bits to leave the top bits 0.
  203.  */
  204. void /* PRIVATE */
  205. png_reset_crc(png_structp png_ptr)
  206. {
  207.    png_ptr->crc = crc32(0, Z_NULL, 0);
  208. }
  210. /* Calculate the CRC over a section of data.  We can only pass as
  211.  * much data to this routine as the largest single buffer size.  We
  212.  * also check that this data will actually be used before going to the
  213.  * trouble of calculating it.
  214.  */
  215. void /* PRIVATE */
  216. png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
  217. {
  218.    int need_crc = 1;
  220.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
  221.    {
  222.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  223.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  224.          need_crc = 0;
  225.    }
  226.    else                                                    /* critical */
  227.    {
  228.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
  229.          need_crc = 0;
  230.    }
  232.    if (need_crc)
  233.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
  234. }
  236. /* Allocate the memory for an info_struct for the application.  We don't
  237.  * really need the png_ptr, but it could potentially be useful in the
  238.  * future.  This should be used in favour of malloc(png_sizeof(png_info))
  239.  * and png_info_init() so that applications that want to use a shared
  240.  * libpng don't have to be recompiled if png_info changes size.
  241.  */
  242. png_infop PNGAPI
  243. png_create_info_struct(png_structp png_ptr)
  244. {
  245.    png_infop info_ptr;
  247.    png_debug(1, "in png_create_info_struct");
  248.    if (png_ptr == NULL) return (NULL);
  249. #ifdef PNG_USER_MEM_SUPPORTED
  250.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
  251.       png_ptr->malloc_fn, png_ptr->mem_ptr);
  252. #else
  253.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  254. #endif
  255.    if (info_ptr != NULL)
  256.       png_info_init_3(&info_ptr, png_sizeof(png_info));
  258.    return (info_ptr);
  259. }
  261. /* This function frees the memory associated with a single info struct.
  262.  * Normally, one would use either png_destroy_read_struct() or
  263.  * png_destroy_write_struct() to free an info struct, but this may be
  264.  * useful for some applications.
  265.  */
  266. void PNGAPI
  267. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
  268. {
  269.    png_infop info_ptr = NULL;
  270.    if (png_ptr == NULL) return;
  272.    png_debug(1, "in png_destroy_info_struct");
  273.    if (info_ptr_ptr != NULL)
  274.       info_ptr = *info_ptr_ptr;
  276.    if (info_ptr != NULL)
  277.    {
  278.       png_info_destroy(png_ptr, info_ptr);
  280. #ifdef PNG_USER_MEM_SUPPORTED
  281.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
  282.           png_ptr->mem_ptr);
  283. #else
  284.       png_destroy_struct((png_voidp)info_ptr);
  285. #endif
  286.       *info_ptr_ptr = NULL;
  287.    }
  288. }
  290. /* Initialize the info structure.  This is now an internal function (0.89)
  291.  * and applications using it are urged to use png_create_info_struct()
  292.  * instead.
  293.  */
  294. #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
  295. #undef png_info_init
  296. void PNGAPI
  297. png_info_init(png_infop info_ptr)
  298. {
  299.    /* We only come here via pre-1.0.12-compiled applications */
  300.    png_info_init_3(&info_ptr, 0);
  301. }
  302. #endif
  304. void PNGAPI
  305. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
  306. {
  307.    png_infop info_ptr = *ptr_ptr;
  309.    if (info_ptr == NULL) return;
  311.    png_debug(1, "in png_info_init_3");
  313.    if (png_sizeof(png_info) > png_info_struct_size)
  314.      {
  315.        png_destroy_struct(info_ptr);
  316.        info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  317.        *ptr_ptr = info_ptr;
  318.      }
  320.    /* set everything to 0 */
  321.    png_memset(info_ptr, 0, png_sizeof(png_info));
  322. }
  324. #ifdef PNG_FREE_ME_SUPPORTED
  325. void PNGAPI
  326. png_data_freer(png_structp png_ptr, png_infop info_ptr,
  327.    int freer, png_uint_32 mask)
  328. {
  329.    png_debug(1, "in png_data_freer");
  330.    if (png_ptr == NULL || info_ptr == NULL)
  331.       return;
  332.    if (freer == PNG_DESTROY_WILL_FREE_DATA)
  333.       info_ptr->free_me |= mask;
  334.    else if (freer == PNG_USER_WILL_FREE_DATA)
  335.       info_ptr->free_me &= ~mask;
  336.    else
  337.       png_warning(png_ptr,
  338.          "Unknown freer parameter in png_data_freer.");
  339. }
  340. #endif
  342. void PNGAPI
  343. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
  344.    int num)
  345. {
  346.    png_debug(1, "in png_free_data");
  347.    if (png_ptr == NULL || info_ptr == NULL)
  348.       return;
  350. #if defined(PNG_TEXT_SUPPORTED)
  351. /* free text item num or (if num == -1) all text items */
  352. #ifdef PNG_FREE_ME_SUPPORTED
  353. if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
  354. #else
  355. if (mask & PNG_FREE_TEXT)
  356. #endif
  357. {
  358.    if (num != -1)
  359.    {
  360.      if (info_ptr->text && info_ptr->text[num].key)
  361.      {
  362.          png_free(png_ptr, info_ptr->text[num].key);
  363.          info_ptr->text[num].key = NULL;
  364.      }
  365.    }
  366.    else
  367.    {
  368.        int i;
  369.        for (i = 0; i < info_ptr->num_text; i++)
  370.            png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
  371.        png_free(png_ptr, info_ptr->text);
  372.        info_ptr->text = NULL;
  373.        info_ptr->num_text=0;
  374.    }
  375. }
  376. #endif
  378. #if defined(PNG_tRNS_SUPPORTED)
  379. /* free any tRNS entry */
  380. #ifdef PNG_FREE_ME_SUPPORTED
  381. if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
  382. #else
  383. if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
  384. #endif
  385. {
  386.     png_free(png_ptr, info_ptr->trans);
  387.     info_ptr->trans = NULL;
  388.     info_ptr->valid &= ~PNG_INFO_tRNS;
  389. #ifndef PNG_FREE_ME_SUPPORTED
  390.     png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
  391. #endif
  392. }
  393. #endif
  395. #if defined(PNG_sCAL_SUPPORTED)
  396. /* free any sCAL entry */
  397. #ifdef PNG_FREE_ME_SUPPORTED
  398. if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
  399. #else
  400. if (mask & PNG_FREE_SCAL)
  401. #endif
  402. {
  403. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
  404.     png_free(png_ptr, info_ptr->scal_s_width);
  405.     png_free(png_ptr, info_ptr->scal_s_height);
  406.     info_ptr->scal_s_width = NULL;
  407.     info_ptr->scal_s_height = NULL;
  408. #endif
  409.     info_ptr->valid &= ~PNG_INFO_sCAL;
  410. }
  411. #endif
  413. #if defined(PNG_pCAL_SUPPORTED)
  414. /* free any pCAL entry */
  415. #ifdef PNG_FREE_ME_SUPPORTED
  416. if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
  417. #else
  418. if (mask & PNG_FREE_PCAL)
  419. #endif
  420. {
  421.     png_free(png_ptr, info_ptr->pcal_purpose);
  422.     png_free(png_ptr, info_ptr->pcal_units);
  423.     info_ptr->pcal_purpose = NULL;
  424.     info_ptr->pcal_units = NULL;
  425.     if (info_ptr->pcal_params != NULL)
  426.     {
  427.         int i;
  428.         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
  429.         {
  430.           png_free(png_ptr, info_ptr->pcal_params[i]);
  431.           info_ptr->pcal_params[i]=NULL;
  432.         }
  433.         png_free(png_ptr, info_ptr->pcal_params);
  434.         info_ptr->pcal_params = NULL;
  435.     }
  436.     info_ptr->valid &= ~PNG_INFO_pCAL;
  437. }
  438. #endif
  440. #if defined(PNG_iCCP_SUPPORTED)
  441. /* free any iCCP entry */
  442. #ifdef PNG_FREE_ME_SUPPORTED
  443. if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
  444. #else
  445. if (mask & PNG_FREE_ICCP)
  446. #endif
  447. {
  448.     png_free(png_ptr, info_ptr->iccp_name);
  449.     png_free(png_ptr, info_ptr->iccp_profile);
  450.     info_ptr->iccp_name = NULL;
  451.     info_ptr->iccp_profile = NULL;
  452.     info_ptr->valid &= ~PNG_INFO_iCCP;
  453. }
  454. #endif
  456. #if defined(PNG_sPLT_SUPPORTED)
  457. /* free a given sPLT entry, or (if num == -1) all sPLT entries */
  458. #ifdef PNG_FREE_ME_SUPPORTED
  459. if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
  460. #else
  461. if (mask & PNG_FREE_SPLT)
  462. #endif
  463. {
  464.    if (num != -1)
  465.    {
  466.       if (info_ptr->splt_palettes)
  467.       {
  468.           png_free(png_ptr, info_ptr->splt_palettes[num].name);
  469.           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  470.           info_ptr->splt_palettes[num].name = NULL;
  471.           info_ptr->splt_palettes[num].entries = NULL;
  472.       }
  473.    }
  474.    else
  475.    {
  476.        if (info_ptr->splt_palettes_num)
  477.        {
  478.          int i;
  479.          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  480.             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
  482.          png_free(png_ptr, info_ptr->splt_palettes);
  483.          info_ptr->splt_palettes = NULL;
  484.          info_ptr->splt_palettes_num = 0;
  485.        }
  486.        info_ptr->valid &= ~PNG_INFO_sPLT;
  487.    }
  488. }
  489. #endif
  491. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  492.   if (png_ptr->unknown_chunk.data)
  493.   {
  494.     png_free(png_ptr, png_ptr->unknown_chunk.data);
  495.     png_ptr->unknown_chunk.data = NULL;
  496.   }
  498. #ifdef PNG_FREE_ME_SUPPORTED
  499. if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
  500. #else
  501. if (mask & PNG_FREE_UNKN)
  502. #endif
  503. {
  504.    if (num != -1)
  505.    {
  506.        if (info_ptr->unknown_chunks)
  507.        {
  508.           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  509.           info_ptr->unknown_chunks[num].data = NULL;
  510.        }
  511.    }
  512.    else
  513.    {
  514.        int i;
  516.        if (info_ptr->unknown_chunks_num)
  517.        {
  518.          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
  519.             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
  521.          png_free(png_ptr, info_ptr->unknown_chunks);
  522.          info_ptr->unknown_chunks = NULL;
  523.          info_ptr->unknown_chunks_num = 0;
  524.        }
  525.    }
  526. }
  527. #endif
  529. #if defined(PNG_hIST_SUPPORTED)
  530. /* free any hIST entry */
  531. #ifdef PNG_FREE_ME_SUPPORTED
  532. if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
  533. #else
  534. if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
  535. #endif
  536. {
  537.     png_free(png_ptr, info_ptr->hist);
  538.     info_ptr->hist = NULL;
  539.     info_ptr->valid &= ~PNG_INFO_hIST;
  540. #ifndef PNG_FREE_ME_SUPPORTED
  541.     png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
  542. #endif
  543. }
  544. #endif
  546. /* free any PLTE entry that was internally allocated */
  547. #ifdef PNG_FREE_ME_SUPPORTED
  548. if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
  549. #else
  550. if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
  551. #endif
  552. {
  553.     png_zfree(png_ptr, info_ptr->palette);
  554.     info_ptr->palette = NULL;
  555.     info_ptr->valid &= ~PNG_INFO_PLTE;
  556. #ifndef PNG_FREE_ME_SUPPORTED
  557.     png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
  558. #endif
  559.     info_ptr->num_palette = 0;
  560. }
  562. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  563. /* free any image bits attached to the info structure */
  564. #ifdef PNG_FREE_ME_SUPPORTED
  565. if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
  566. #else
  567. if (mask & PNG_FREE_ROWS)
  568. #endif
  569. {
  570.     if (info_ptr->row_pointers)
  571.     {
  572.        int row;
  573.        for (row = 0; row < (int)info_ptr->height; row++)
  574.        {
  575.           png_free(png_ptr, info_ptr->row_pointers[row]);
  576.           info_ptr->row_pointers[row]=NULL;
  577.        }
  578.        png_free(png_ptr, info_ptr->row_pointers);
  579.        info_ptr->row_pointers=NULL;
  580.     }
  581.     info_ptr->valid &= ~PNG_INFO_IDAT;
  582. }
  583. #endif
  585. #ifdef PNG_FREE_ME_SUPPORTED
  586.    if (num == -1)
  587.      info_ptr->free_me &= ~mask;
  588.    else
  589.      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
  590. #endif
  591. }
  593. /* This is an internal routine to free any memory that the info struct is
  594.  * pointing to before re-using it or freeing the struct itself.  Recall
  595.  * that png_free() checks for NULL pointers for us.
  596.  */
  597. void /* PRIVATE */
  598. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
  599. {
  600.    png_debug(1, "in png_info_destroy");
  602.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  604. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  605.    if (png_ptr->num_chunk_list)
  606.    {
  607.        png_free(png_ptr, png_ptr->chunk_list);
  608.        png_ptr->chunk_list=NULL;
  609.        png_ptr->num_chunk_list = 0;
  610.    }
  611. #endif
  613.    png_info_init_3(&info_ptr, png_sizeof(png_info));
  614. }
  615. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  617. /* This function returns a pointer to the io_ptr associated with the user
  618.  * functions.  The application should free any memory associated with this
  619.  * pointer before png_write_destroy() or png_read_destroy() are called.
  620.  */
  621. png_voidp PNGAPI
  622. png_get_io_ptr(png_structp png_ptr)
  623. {
  624.    if (png_ptr == NULL) return (NULL);
  625.    return (png_ptr->io_ptr);
  626. }
  628. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  629. #if !defined(PNG_NO_STDIO)
  630. /* Initialize the default input/output functions for the PNG file.  If you
  631.  * use your own read or write routines, you can call either png_set_read_fn()
  632.  * or png_set_write_fn() instead of png_init_io().  If you have defined
  633.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
  634.  * necessarily available.
  635.  */
  636. void PNGAPI
  637. png_init_io(png_structp png_ptr, png_FILE_p fp)
  638. {
  639.    png_debug(1, "in png_init_io");
  640.    if (png_ptr == NULL) return;
  641.    png_ptr->io_ptr = (png_voidp)fp;
  642. }
  643. #endif
  645. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  646. /* Convert the supplied time into an RFC 1123 string suitable for use in
  647.  * a "Creation Time" or other text-based time string.
  648.  */
  649. png_charp PNGAPI
  650. png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
  651. {
  652.    static PNG_CONST char short_months[12][4] =
  653.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  654.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  656.    if (png_ptr == NULL) return (NULL);
  657.    if (png_ptr->time_buffer == NULL)
  658.    {
  659.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
  660.          png_sizeof(char)));
  661.    }
  663. #if defined(_WIN32_WCE)
  664.    {
  665.       wchar_t time_buf[29];
  666.       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
  667.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  668.         ptime->year, ptime->hour % 24, ptime->minute % 60,
  669.           ptime->second % 61);
  670.       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
  671.           NULL, NULL);
  672.    }
  673. #else
  674. #ifdef USE_FAR_KEYWORD
  675.    {
  676.       char near_time_buf[29];
  677.       png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
  678.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  679.           ptime->year, ptime->hour % 24, ptime->minute % 60,
  680.           ptime->second % 61);
  681.       png_memcpy(png_ptr->time_buffer, near_time_buf,
  682.           29*png_sizeof(char));
  683.    }
  684. #else
  685.    png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
  686.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
  687.        ptime->year, ptime->hour % 24, ptime->minute % 60,
  688.        ptime->second % 61);
  689. #endif
  690. #endif /* _WIN32_WCE */
  691.    return ((png_charp)png_ptr->time_buffer);
  692. }
  693. #endif /* PNG_TIME_RFC1123_SUPPORTED */
  695. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  697. png_charp PNGAPI
  698. png_get_copyright(png_structp png_ptr)
  699. {
  700.    png_ptr = png_ptr;  /* silence compiler warning about unused png_ptr */
  701.    return ((png_charp) "n libpng version 1.2.34 - December 18, 2008n
  702.    Copyright (c) 1998-2008 Glenn Randers-Pehrsonn
  703.    Copyright (c) 1996-1997 Andreas Dilgern
  704.    Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.n");
  705. }
  707. /* The following return the library version as a short string in the
  708.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
  709.  * used with your application, print out PNG_LIBPNG_VER_STRING, which
  710.  * is defined in png.h.
  711.  * Note: now there is no difference between png_get_libpng_ver() and
  712.  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
  713.  * it is guaranteed that png.c uses the correct version of png.h.
  714.  */
  715. png_charp PNGAPI
  716. png_get_libpng_ver(png_structp png_ptr)
  717. {
  718.    /* Version of *.c files used when building libpng */
  719.    png_ptr = png_ptr;  /* silence compiler warning about unused png_ptr */
  720.    return ((png_charp) PNG_LIBPNG_VER_STRING);
  721. }
  723. png_charp PNGAPI
  724. png_get_header_ver(png_structp png_ptr)
  725. {
  726.    /* Version of *.h files used when building libpng */
  727.    png_ptr = png_ptr;  /* silence compiler warning about unused png_ptr */
  728.    return ((png_charp) PNG_LIBPNG_VER_STRING);
  729. }
  731. png_charp PNGAPI
  732. png_get_header_version(png_structp png_ptr)
  733. {
  734.    /* Returns longer string containing both version and date */
  735.    png_ptr = png_ptr;  /* silence compiler warning about unused png_ptr */
  736.    return ((png_charp) PNG_HEADER_VERSION_STRING
  737. #ifndef PNG_READ_SUPPORTED
  738.    "     (NO READ SUPPORT)"
  739. #endif
  740.    "n");
  741. }
  743. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  744. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  745. int PNGAPI
  746. png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
  747. {
  748.    /* check chunk_name and return "keep" value if it's on the list, else 0 */
  749.    int i;
  750.    png_bytep p;
  751.    if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
  752.       return 0;
  753.    p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
  754.    for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
  755.       if (!png_memcmp(chunk_name, p, 4))
  756.         return ((int)*(p + 4));
  757.    return 0;
  758. }
  759. #endif
  761. /* This function, added to libpng-1.0.6g, is untested. */
  762. int PNGAPI
  763. png_reset_zstream(png_structp png_ptr)
  764. {
  765.    if (png_ptr == NULL) return Z_STREAM_ERROR;
  766.    return (inflateReset(&png_ptr->zstream));
  767. }
  768. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  770. /* This function was added to libpng-1.0.7 */
  771. png_uint_32 PNGAPI
  772. png_access_version_number(void)
  773. {
  774.    /* Version of *.c files used when building libpng */
  775.    return((png_uint_32) PNG_LIBPNG_VER);
  776. }
  779. #if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)
  780. #if !defined(PNG_1_0_X)
  781. /* this function was added to libpng 1.2.0 */
  782. int PNGAPI
  783. png_mmx_support(void)
  784. {
  785.    /* obsolete, to be removed from libpng-1.4.0 */
  786.     return -1;
  787. }
  788. #endif /* PNG_1_0_X */
  789. #endif /* PNG_READ_SUPPORTED && PNG_ASSEMBLER_CODE_SUPPORTED */
  791. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  792. #ifdef PNG_SIZE_T
  793. /* Added at libpng version 1.2.6 */
  794.    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
  795. png_size_t PNGAPI
  796. png_convert_size(size_t size)
  797. {
  798.   if (size > (png_size_t)-1)
  799.      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
  800.   return ((png_size_t)size);
  801. }
  802. #endif /* PNG_SIZE_T */
  804. /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
  805. #if defined(PNG_cHRM_SUPPORTED)
  806. #if !defined(PNG_NO_CHECK_cHRM)
  807. /*
  808.  Multiply two 32-bit numbers, V1 and V2, using 32-bit
  809.  arithmetic, to produce a 64 bit result in the HI/LO words.
  811.           A B
  812.         x C D
  813.        ------
  814.       AD || BD
  815. AC || CB || 0
  817.  where A and B are the high and low 16-bit words of V1,
  818.  C and D are the 16-bit words of V2, AD is the product of
  819.  A and D, and X || Y is (X << 16) + Y.
  820. */
  822. void png_64bit_product (long v1, long v2, unsigned long *hi_product,
  823.    unsigned long *lo_product)
  824. {
  825.  int a, b, c, d;
  826.  long lo, hi, x, y;
  828.  a = (v1 >> 16) & 0xffff;
  829.  b = v1 & 0xffff;
  830.  c = (v2 >> 16) & 0xffff;
  831.  d = v2 & 0xffff;
  833.  lo = b * d;                   /* BD */
  834.  x = a * d + c * b;            /* AD + CB */
  835.  y = ((lo >> 16) & 0xffff) + x;
  837.  lo = (lo & 0xffff) | ((y & 0xffff) << 16);
  838.  hi = (y >> 16) & 0xffff;
  840.  hi += a * c;                  /* AC */
  842.  *hi_product = (unsigned long)hi;
  843.  *lo_product = (unsigned long)lo;
  844. }
  845. int /* private */
  846. png_check_cHRM_fixed(png_structp png_ptr,
  847.    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
  848.    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
  849.    png_fixed_point blue_x, png_fixed_point blue_y)
  850. {
  851.    int ret = 1;
  852.    unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
  854.    png_debug(1, "in function png_check_cHRM_fixed");
  855.    if (png_ptr == NULL)
  856.       return 0;
  858.    if (white_x < 0 || white_y <= 0 ||
  859.          red_x < 0 ||   red_y <  0 ||
  860.        green_x < 0 || green_y <  0 ||
  861.         blue_x < 0 ||  blue_y <  0)
  862.    {
  863.       png_warning(png_ptr,
  864.         "Ignoring attempt to set negative chromaticity value");
  865.       ret = 0;
  866.    }
  867.    if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
  868.        white_y > (png_fixed_point) PNG_UINT_31_MAX ||
  869.          red_x > (png_fixed_point) PNG_UINT_31_MAX ||
  870.          red_y > (png_fixed_point) PNG_UINT_31_MAX ||
  871.        green_x > (png_fixed_point) PNG_UINT_31_MAX ||
  872.        green_y > (png_fixed_point) PNG_UINT_31_MAX ||
  873.         blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
  874.         blue_y > (png_fixed_point) PNG_UINT_31_MAX )
  875.    {
  876.       png_warning(png_ptr,
  877.         "Ignoring attempt to set chromaticity value exceeding 21474.83");
  878.       ret = 0;
  879.    }
  880.    if (white_x > 100000L - white_y)
  881.    {
  882.       png_warning(png_ptr, "Invalid cHRM white point");
  883.       ret = 0;
  884.    }
  885.    if (red_x > 100000L - red_y)
  886.    {
  887.       png_warning(png_ptr, "Invalid cHRM red point");
  888.       ret = 0;
  889.    }
  890.    if (green_x > 100000L - green_y)
  891.    {
  892.       png_warning(png_ptr, "Invalid cHRM green point");
  893.       ret = 0;
  894.    }
  895.    if (blue_x > 100000L - blue_y)
  896.    {
  897.       png_warning(png_ptr, "Invalid cHRM blue point");
  898.       ret = 0;
  899.    }
  901.    png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
  902.    png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
  904.    if (xy_hi == yx_hi && xy_lo == yx_lo)
  905.    {
  906.       png_warning(png_ptr,
  907.          "Ignoring attempt to set cHRM RGB triangle with zero area");
  908.       ret = 0;
  909.    }
  911.    return ret;
  912. }
  913. #endif /* NO_PNG_CHECK_cHRM */
  914. #endif /* PNG_cHRM_SUPPORTED */
  915. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */