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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
png.c
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：25k
源码类别：

对话框与窗口

开发平台：

Visual C++

png.c：源码内容
  2. /* png.c - location for general purpose libpng functions
  3.  *
  4.  * Last changed in libpng 1.2.9 April 14, 2006
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2006 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. #define PNG_INTERNAL
  12. #define PNG_NO_EXTERN
  13. #include "png.h"
  15. /* Generate a compiler error if there is an old png.h in the search path. */
  16. typedef version_1_2_10 Your_png_h_is_not_version_1_2_10;
  18. /* Version information for C files.  This had better match the version
  19.  * string defined in png.h.  */
  21. #ifdef PNG_USE_GLOBAL_ARRAYS
  22. /* png_libpng_ver was changed to a function in version 1.0.5c */
  23. const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
  25. #ifdef PNG_READ_SUPPORTED
  27. /* png_sig was changed to a function in version 1.0.5c */
  28. /* Place to hold the signature string for a PNG file. */
  29. const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  30. #endif /* PNG_READ_SUPPORTED */
  32. /* Invoke global declarations for constant strings for known chunk types */
  33. PNG_IHDR;
  34. PNG_IDAT;
  35. PNG_IEND;
  36. PNG_PLTE;
  37. PNG_bKGD;
  38. PNG_cHRM;
  39. PNG_gAMA;
  40. PNG_hIST;
  41. PNG_iCCP;
  42. PNG_iTXt;
  43. PNG_oFFs;
  44. PNG_pCAL;
  45. PNG_sCAL;
  46. PNG_pHYs;
  47. PNG_sBIT;
  48. PNG_sPLT;
  49. PNG_sRGB;
  50. PNG_tEXt;
  51. PNG_tIME;
  52. PNG_tRNS;
  53. PNG_zTXt;
  55. #ifdef PNG_READ_SUPPORTED
  56. /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  58. /* start of interlace block */
  59. const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
  61. /* offset to next interlace block */
  62. const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
  64. /* start of interlace block in the y direction */
  65. const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
  67. /* offset to next interlace block in the y direction */
  68. const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
  70. /* width of interlace block (used in assembler routines only) */
  71. #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
  72. const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
  73. #endif
  75. /* Height of interlace block.  This is not currently used - if you need
  76.  * it, uncomment it here and in png.h
  77. const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
  78. */
  80. /* Mask to determine which pixels are valid in a pass */
  81. const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
  83. /* Mask to determine which pixels to overwrite while displaying */
  84. const int FARDATA png_pass_dsp_mask[]
  85.    = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
  87. #endif /* PNG_READ_SUPPORTED */
  88. #endif /* PNG_USE_GLOBAL_ARRAYS */
  90. /* Tells libpng that we have already handled the first "num_bytes" bytes
  91.  * of the PNG file signature.  If the PNG data is embedded into another
  92.  * stream we can set num_bytes = 8 so that libpng will not attempt to read
  93.  * or write any of the magic bytes before it starts on the IHDR.
  94.  */
  96. #ifdef PNG_READ_SUPPORTED
  97. void PNGAPI
  98. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
  99. {
  100.    png_debug(1, "in png_set_sig_bytesn");
  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 a 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_ptr;
  157.    png_uint_32 save_flags=p->flags;
  158.    png_uint_32 num_bytes;
  160.    if (items > PNG_UINT_32_MAX/size)
  161.    {
  162.      png_warning (png_ptr, "Potential overflow in png_zalloc()");
  163.      return (NULL);
  164.    }
  165.    num_bytes = (png_uint_32)items * size;
  167.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  168.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
  169.    p->flags=save_flags;
  171. #if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
  172.    if (ptr == NULL)
  173.        return ((voidpf)ptr);
  175.    if (num_bytes > (png_uint_32)0x8000L)
  176.    {
  177.       png_memset(ptr, 0, (png_size_t)0x8000L);
  178.       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
  179.          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
  180.    }
  181.    else
  182.    {
  183.       png_memset(ptr, 0, (png_size_t)num_bytes);
  184.    }
  185. #endif
  186.    return ((voidpf)ptr);
  187. }
  189. /* function to free memory for zlib */
  190. #ifdef PNG_1_0_X
  191. void PNGAPI
  192. #else
  193. void /* private */
  194. #endif
  195. png_zfree(voidpf png_ptr, voidpf ptr)
  196. {
  197.    png_free((png_structp)png_ptr, (png_voidp)ptr);
  198. }
  200. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
  201.  * in case CRC is > 32 bits to leave the top bits 0.
  202.  */
  203. void /* PRIVATE */
  204. png_reset_crc(png_structp png_ptr)
  205. {
  206.    png_ptr->crc = crc32(0, Z_NULL, 0);
  207. }
  209. /* Calculate the CRC over a section of data.  We can only pass as
  210.  * much data to this routine as the largest single buffer size.  We
  211.  * also check that this data will actually be used before going to the
  212.  * trouble of calculating it.
  213.  */
  214. void /* PRIVATE */
  215. png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
  216. {
  217.    int need_crc = 1;
  219.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
  220.    {
  221.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  222.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  223.          need_crc = 0;
  224.    }
  225.    else                                                    /* critical */
  226.    {
  227.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
  228.          need_crc = 0;
  229.    }
  231.    if (need_crc)
  232.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
  233. }
  235. /* Allocate the memory for an info_struct for the application.  We don't
  236.  * really need the png_ptr, but it could potentially be useful in the
  237.  * future.  This should be used in favour of malloc(png_sizeof(png_info))
  238.  * and png_info_init() so that applications that want to use a shared
  239.  * libpng don't have to be recompiled if png_info changes size.
  240.  */
  241. png_infop PNGAPI
  242. png_create_info_struct(png_structp png_ptr)
  243. {
  244.    png_infop info_ptr;
  246.    png_debug(1, "in png_create_info_structn");
  247.    if(png_ptr == NULL) return (NULL);
  248. #ifdef PNG_USER_MEM_SUPPORTED
  249.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
  250.       png_ptr->malloc_fn, png_ptr->mem_ptr);
  251. #else
  252.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  253. #endif
  254.    if (info_ptr != NULL)
  255.       png_info_init_3(&info_ptr, png_sizeof(png_info));
  257.    return (info_ptr);
  258. }
  260. /* This function frees the memory associated with a single info struct.
  261.  * Normally, one would use either png_destroy_read_struct() or
  262.  * png_destroy_write_struct() to free an info struct, but this may be
  263.  * useful for some applications.
  264.  */
  265. void PNGAPI
  266. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
  267. {
  268.    png_infop info_ptr = NULL;
  270.    png_debug(1, "in png_destroy_info_structn");
  271.    if (info_ptr_ptr != NULL)
  272.       info_ptr = *info_ptr_ptr;
  274.    if (info_ptr != NULL)
  275.    {
  276.       png_info_destroy(png_ptr, info_ptr);
  278. #ifdef PNG_USER_MEM_SUPPORTED
  279.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
  280.           png_ptr->mem_ptr);
  281. #else
  282.       png_destroy_struct((png_voidp)info_ptr);
  283. #endif
  284.       *info_ptr_ptr = NULL;
  285.    }
  286. }
  288. /* Initialize the info structure.  This is now an internal function (0.89)
  289.  * and applications using it are urged to use png_create_info_struct()
  290.  * instead.
  291.  */
  292. #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
  293. #undef png_info_init
  294. void PNGAPI
  295. png_info_init(png_infop info_ptr)
  296. {
  297.    /* We only come here via pre-1.0.12-compiled applications */
  298.    png_info_init_3(&info_ptr, 0);
  299. }
  300. #endif
  302. void PNGAPI
  303. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
  304. {
  305.    png_infop info_ptr = *ptr_ptr;
  307.    png_debug(1, "in png_info_init_3n");
  309.    if(png_sizeof(png_info) > png_info_struct_size)
  310.      {
  311.        png_destroy_struct(info_ptr);
  312.        info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  313.        *ptr_ptr = info_ptr;
  314.      }
  316.    /* set everything to 0 */
  317.    png_memset(info_ptr, 0, png_sizeof (png_info));
  318. }
  320. #ifdef PNG_FREE_ME_SUPPORTED
  321. void PNGAPI
  322. png_data_freer(png_structp png_ptr, png_infop info_ptr,
  323.    int freer, png_uint_32 mask)
  324. {
  325.    png_debug(1, "in png_data_freern");
  326.    if (png_ptr == NULL || info_ptr == NULL)
  327.       return;
  328.    if(freer == PNG_DESTROY_WILL_FREE_DATA)
  329.       info_ptr->free_me |= mask;
  330.    else if(freer == PNG_USER_WILL_FREE_DATA)
  331.       info_ptr->free_me &= ~mask;
  332.    else
  333.       png_warning(png_ptr,
  334.          "Unknown freer parameter in png_data_freer.");
  335. }
  336. #endif
  338. void PNGAPI
  339. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
  340.    int num)
  341. {
  342.    png_debug(1, "in png_free_datan");
  343.    if (png_ptr == NULL || info_ptr == NULL)
  344.       return;
  346. #if defined(PNG_TEXT_SUPPORTED)
  347. /* free text item num or (if num == -1) all text items */
  348. #ifdef PNG_FREE_ME_SUPPORTED
  349. if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
  350. #else
  351. if (mask & PNG_FREE_TEXT)
  352. #endif
  353. {
  354.    if (num != -1)
  355.    {
  356.      if (info_ptr->text && info_ptr->text[num].key)
  357.      {
  358.          png_free(png_ptr, info_ptr->text[num].key);
  359.          info_ptr->text[num].key = NULL;
  360.      }
  361.    }
  362.    else
  363.    {
  364.        int i;
  365.        for (i = 0; i < info_ptr->num_text; i++)
  366.            png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
  367.        png_free(png_ptr, info_ptr->text);
  368.        info_ptr->text = NULL;
  369.        info_ptr->num_text=0;
  370.    }
  371. }
  372. #endif
  374. #if defined(PNG_tRNS_SUPPORTED)
  375. /* free any tRNS entry */
  376. #ifdef PNG_FREE_ME_SUPPORTED
  377. if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
  378. #else
  379. if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
  380. #endif
  381. {
  382.     png_free(png_ptr, info_ptr->trans);
  383.     info_ptr->valid &= ~PNG_INFO_tRNS;
  384. #ifndef PNG_FREE_ME_SUPPORTED
  385.     png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
  386. #endif
  387.     info_ptr->trans = NULL;
  388. }
  389. #endif
  391. #if defined(PNG_sCAL_SUPPORTED)
  392. /* free any sCAL entry */
  393. #ifdef PNG_FREE_ME_SUPPORTED
  394. if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
  395. #else
  396. if (mask & PNG_FREE_SCAL)
  397. #endif
  398. {
  399. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
  400.     png_free(png_ptr, info_ptr->scal_s_width);
  401.     png_free(png_ptr, info_ptr->scal_s_height);
  402.     info_ptr->scal_s_width = NULL;
  403.     info_ptr->scal_s_height = NULL;
  404. #endif
  405.     info_ptr->valid &= ~PNG_INFO_sCAL;
  406. }
  407. #endif
  409. #if defined(PNG_pCAL_SUPPORTED)
  410. /* free any pCAL entry */
  411. #ifdef PNG_FREE_ME_SUPPORTED
  412. if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
  413. #else
  414. if (mask & PNG_FREE_PCAL)
  415. #endif
  416. {
  417.     png_free(png_ptr, info_ptr->pcal_purpose);
  418.     png_free(png_ptr, info_ptr->pcal_units);
  419.     info_ptr->pcal_purpose = NULL;
  420.     info_ptr->pcal_units = NULL;
  421.     if (info_ptr->pcal_params != NULL)
  422.     {
  423.         int i;
  424.         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
  425.         {
  426.           png_free(png_ptr, info_ptr->pcal_params[i]);
  427.           info_ptr->pcal_params[i]=NULL;
  428.         }
  429.         png_free(png_ptr, info_ptr->pcal_params);
  430.         info_ptr->pcal_params = NULL;
  431.     }
  432.     info_ptr->valid &= ~PNG_INFO_pCAL;
  433. }
  434. #endif
  436. #if defined(PNG_iCCP_SUPPORTED)
  437. /* free any iCCP entry */
  438. #ifdef PNG_FREE_ME_SUPPORTED
  439. if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
  440. #else
  441. if (mask & PNG_FREE_ICCP)
  442. #endif
  443. {
  444.     png_free(png_ptr, info_ptr->iccp_name);
  445.     png_free(png_ptr, info_ptr->iccp_profile);
  446.     info_ptr->iccp_name = NULL;
  447.     info_ptr->iccp_profile = NULL;
  448.     info_ptr->valid &= ~PNG_INFO_iCCP;
  449. }
  450. #endif
  452. #if defined(PNG_sPLT_SUPPORTED)
  453. /* free a given sPLT entry, or (if num == -1) all sPLT entries */
  454. #ifdef PNG_FREE_ME_SUPPORTED
  455. if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
  456. #else
  457. if (mask & PNG_FREE_SPLT)
  458. #endif
  459. {
  460.    if (num != -1)
  461.    {
  462.       if(info_ptr->splt_palettes)
  463.       {
  464.           png_free(png_ptr, info_ptr->splt_palettes[num].name);
  465.           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  466.           info_ptr->splt_palettes[num].name = NULL;
  467.           info_ptr->splt_palettes[num].entries = NULL;
  468.       }
  469.    }
  470.    else
  471.    {
  472.        if(info_ptr->splt_palettes_num)
  473.        {
  474.          int i;
  475.          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  476.             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
  478.          png_free(png_ptr, info_ptr->splt_palettes);
  479.          info_ptr->splt_palettes = NULL;
  480.          info_ptr->splt_palettes_num = 0;
  481.        }
  482.        info_ptr->valid &= ~PNG_INFO_sPLT;
  483.    }
  484. }
  485. #endif
  487. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  488. #ifdef PNG_FREE_ME_SUPPORTED
  489. if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
  490. #else
  491. if (mask & PNG_FREE_UNKN)
  492. #endif
  493. {
  494.    if (num != -1)
  495.    {
  496.        if(info_ptr->unknown_chunks)
  497.        {
  498.           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  499.           info_ptr->unknown_chunks[num].data = NULL;
  500.        }
  501.    }
  502.    else
  503.    {
  504.        int i;
  506.        if(info_ptr->unknown_chunks_num)
  507.        {
  508.          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
  509.             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
  511.          png_free(png_ptr, info_ptr->unknown_chunks);
  512.          info_ptr->unknown_chunks = NULL;
  513.          info_ptr->unknown_chunks_num = 0;
  514.        }
  515.    }
  516. }
  517. #endif
  519. #if defined(PNG_hIST_SUPPORTED)
  520. /* free any hIST entry */
  521. #ifdef PNG_FREE_ME_SUPPORTED
  522. if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
  523. #else
  524. if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
  525. #endif
  526. {
  527.     png_free(png_ptr, info_ptr->hist);
  528.     info_ptr->hist = NULL;
  529.     info_ptr->valid &= ~PNG_INFO_hIST;
  530. #ifndef PNG_FREE_ME_SUPPORTED
  531.     png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
  532. #endif
  533. }
  534. #endif
  536. /* free any PLTE entry that was internally allocated */
  537. #ifdef PNG_FREE_ME_SUPPORTED
  538. if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
  539. #else
  540. if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
  541. #endif
  542. {
  543.     png_zfree(png_ptr, info_ptr->palette);
  544.     info_ptr->palette = NULL;
  545.     info_ptr->valid &= ~PNG_INFO_PLTE;
  546. #ifndef PNG_FREE_ME_SUPPORTED
  547.     png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
  548. #endif
  549.     info_ptr->num_palette = 0;
  550. }
  552. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  553. /* free any image bits attached to the info structure */
  554. #ifdef PNG_FREE_ME_SUPPORTED
  555. if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
  556. #else
  557. if (mask & PNG_FREE_ROWS)
  558. #endif
  559. {
  560.     if(info_ptr->row_pointers)
  561.     {
  562.        int row;
  563.        for (row = 0; row < (int)info_ptr->height; row++)
  564.        {
  565.           png_free(png_ptr, info_ptr->row_pointers[row]);
  566.           info_ptr->row_pointers[row]=NULL;
  567.        }
  568.        png_free(png_ptr, info_ptr->row_pointers);
  569.        info_ptr->row_pointers=NULL;
  570.     }
  571.     info_ptr->valid &= ~PNG_INFO_IDAT;
  572. }
  573. #endif
  575. #ifdef PNG_FREE_ME_SUPPORTED
  576.    if(num == -1)
  577.      info_ptr->free_me &= ~mask;
  578.    else
  579.      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
  580. #endif
  581. }
  583. /* This is an internal routine to free any memory that the info struct is
  584.  * pointing to before re-using it or freeing the struct itself.  Recall
  585.  * that png_free() checks for NULL pointers for us.
  586.  */
  587. void /* PRIVATE */
  588. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
  589. {
  590.    png_debug(1, "in png_info_destroyn");
  592.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  594. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  595.    if (png_ptr->num_chunk_list)
  596.    {
  597.        png_free(png_ptr, png_ptr->chunk_list);
  598.        png_ptr->chunk_list=NULL;
  599.        png_ptr->num_chunk_list=0;
  600.    }
  601. #endif
  603.    png_info_init_3(&info_ptr, png_sizeof(png_info));
  604. }
  605. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  607. /* This function returns a pointer to the io_ptr associated with the user
  608.  * functions.  The application should free any memory associated with this
  609.  * pointer before png_write_destroy() or png_read_destroy() are called.
  610.  */
  611. png_voidp PNGAPI
  612. png_get_io_ptr(png_structp png_ptr)
  613. {
  614.    return (png_ptr->io_ptr);
  615. }
  617. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  618. #if !defined(PNG_NO_STDIO)
  619. /* Initialize the default input/output functions for the PNG file.  If you
  620.  * use your own read or write routines, you can call either png_set_read_fn()
  621.  * or png_set_write_fn() instead of png_init_io().  If you have defined
  622.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
  623.  * necessarily available.
  624.  */
  625. void PNGAPI
  626. png_init_io(png_structp png_ptr, png_FILE_p fp)
  627. {
  628.    png_debug(1, "in png_init_ion");
  629.    png_ptr->io_ptr = (png_voidp)fp;
  630. }
  631. #endif
  633. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  634. /* Convert the supplied time into an RFC 1123 string suitable for use in
  635.  * a "Creation Time" or other text-based time string.
  636.  */
  637. png_charp PNGAPI
  638. png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
  639. {
  640.    static PNG_CONST char short_months[12][4] =
  641.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  642.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  644.    if (png_ptr->time_buffer == NULL)
  645.    {
  646.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
  647.          png_sizeof(char)));
  648.    }
  650. #if defined(_WIN32_WCE)
  651.    {
  652.       wchar_t time_buf[29];
  653.       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
  654.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  655.         ptime->year, ptime->hour % 24, ptime->minute % 60,
  656.           ptime->second % 61);
  657.       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
  658.           NULL, NULL);
  659.    }
  660. #else
  661. #ifdef USE_FAR_KEYWORD
  662.    {
  663.       char near_time_buf[29];
  664.       sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
  665.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  666.           ptime->year, ptime->hour % 24, ptime->minute % 60,
  667.           ptime->second % 61);
  668.       png_memcpy(png_ptr->time_buffer, near_time_buf,
  669.           29*png_sizeof(char));
  670.    }
  671. #else
  672.    sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
  673.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
  674.        ptime->year, ptime->hour % 24, ptime->minute % 60,
  675.        ptime->second % 61);
  676. #endif
  677. #endif /* _WIN32_WCE */
  678.    return ((png_charp)png_ptr->time_buffer);
  679. }
  680. #endif /* PNG_TIME_RFC1123_SUPPORTED */
  682. #if 0
  683. /* Signature string for a PNG file. */
  684. png_bytep PNGAPI
  685. png_sig_bytes(void)
  686. {
  687.    return ((png_bytep)"21112011610715123212");
  688. }
  689. #endif
  690. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  692. png_charp PNGAPI
  693. png_get_copyright(png_structp png_ptr)
  694. {
  695.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
  696.    return ((png_charp) "n libpng version 1.2.10 - April 23, 2006n
  697.    Copyright (c) 1998-2006 Glenn Randers-Pehrsonn
  698.    Copyright (c) 1996-1997 Andreas Dilgern
  699.    Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.n");
  700.    return ((png_charp) "");
  701. }
  703. /* The following return the library version as a short string in the
  704.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files
  705.  * used with your application, print out PNG_LIBPNG_VER_STRING, which
  706.  * is defined in png.h.
  707.  * Note: now there is no difference between png_get_libpng_ver() and
  708.  * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,
  709.  * it is guaranteed that png.c uses the correct version of png.h.
  710.  */
  711. png_charp PNGAPI
  712. png_get_libpng_ver(png_structp png_ptr)
  713. {
  714.    /* Version of *.c files used when building libpng */
  715.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
  716.       return ((png_charp) PNG_LIBPNG_VER_STRING);
  717.    return ((png_charp) "");
  718. }
  720. png_charp PNGAPI
  721. png_get_header_ver(png_structp png_ptr)
  722. {
  723.    /* Version of *.h files used when building libpng */
  724.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
  725.       return ((png_charp) PNG_LIBPNG_VER_STRING);
  726.    return ((png_charp) "");
  727. }
  729. png_charp PNGAPI
  730. png_get_header_version(png_structp png_ptr)
  731. {
  732.    /* Returns longer string containing both version and date */
  733.    if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */
  734.       return ((png_charp) PNG_HEADER_VERSION_STRING);
  735.    return ((png_charp) "");
  736. }
  738. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  739. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  740. int PNGAPI
  741. png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
  742. {
  743.    /* check chunk_name and return "keep" value if it's on the list, else 0 */
  744.    int i;
  745.    png_bytep p;
  746.    if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
  747.       return 0;
  748.    p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
  749.    for (i = png_ptr->num_chunk_list; i; i--, p-=5)
  750.       if (!png_memcmp(chunk_name, p, 4))
  751.         return ((int)*(p+4));
  752.    return 0;
  753. }
  754. #endif
  756. /* This function, added to libpng-1.0.6g, is untested. */
  757. int PNGAPI
  758. png_reset_zstream(png_structp png_ptr)
  759. {
  760.    return (inflateReset(&png_ptr->zstream));
  761. }
  762. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
  764. /* This function was added to libpng-1.0.7 */
  765. png_uint_32 PNGAPI
  766. png_access_version_number(void)
  767. {
  768.    /* Version of *.c files used when building libpng */
  769.    return((png_uint_32) PNG_LIBPNG_VER);
  770. }
  773. #if defined(PNG_READ_SUPPORTED)
  774. #if !defined(PNG_1_0_X)
  775. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
  776.     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
  777. /* this INTERNAL function was added to libpng 1.2.0 */
  778. void /* PRIVATE */
  779. png_init_mmx_flags (png_structp png_ptr)
  780. {
  781.     png_ptr->mmx_rowbytes_threshold = 0;
  782.     png_ptr->mmx_bitdepth_threshold = 0;
  784. #  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
  786.     png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
  788.     if (png_mmx_support() > 0) {
  789.         png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
  790. #    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
  791.                               | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
  792. #    endif
  793. #    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
  794.                               | PNG_ASM_FLAG_MMX_READ_INTERLACE
  795. #    endif
  796. #    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
  797.                               ;
  798. #    else
  799.                               | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
  800.                               | PNG_ASM_FLAG_MMX_READ_FILTER_UP
  801.                               | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
  802.                               | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
  804.         png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
  805.         png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
  806. #    endif
  807.     } else {
  808.         png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
  809.                                | PNG_MMX_READ_FLAGS
  810.                                | PNG_MMX_WRITE_FLAGS );
  811.     }
  813. #  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
  815.     /* clear all MMX flags; no support is compiled in */
  816.     png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
  818. #  endif /* ?(PNGVCRD || PNGGCCRD) */
  819. }
  821. #endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */
  823. /* this function was added to libpng 1.2.0 */
  824. #if !defined(PNG_USE_PNGGCCRD) && 
  825.     !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
  826. int PNGAPI
  827. png_mmx_support(void)
  828. {
  829.     return -1;
  830. }
  831. #endif
  832. #endif /* PNG_1_0_X */
  833. #endif /* PNG_READ_SUPPORTED */
  835. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  836. #ifdef PNG_SIZE_T
  837. /* Added at libpng version 1.2.6 */
  838.    PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));
  839. png_size_t PNGAPI
  840. png_convert_size(size_t size)
  841. {
  842.   if (size > (png_size_t)-1)
  843.      PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
  844.   return ((png_size_t)size);
  845. }
  846. #endif /* PNG_SIZE_T */
  847. #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */