home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / libpng / png_.c next >
C/C++ Source or Header  |  2001-04-27  |  21KB  |  713 lines
  1.  
  2. /* png.c - location for general purpose libpng functions
  3.  *
  4.  * libpng version 1.0.11 - April 27, 2001
  5.  * Copyright (c) 1998-2001 Glenn Randers-Pehrson
  6.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  7.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  8.  *
  9.  */
  10.  
  11. #define PNG_INTERNAL
  12. #define PNG_NO_EXTERN
  13. #include "png.h"
  14.  
  15. /* Generate a compiler error if there is an old png.h in the search path. */
  16. typedef version_1_0_11 Your_png_h_is_not_version_1_0_11;
  17.  
  18. /* Version information for C files.  This had better match the version
  19.  * string defined in png.h.  */
  20.  
  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] = "1.0.11";
  24.  
  25. /* png_sig was changed to a function in version 1.0.5c */
  26. /* Place to hold the signature string for a PNG file. */
  27. const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  28.  
  29. /* Invoke global declarations for constant strings for known chunk types */
  30. PNG_IHDR;
  31. PNG_IDAT;
  32. PNG_IEND;
  33. PNG_PLTE;
  34. PNG_bKGD;
  35. PNG_cHRM;
  36. PNG_gAMA;
  37. PNG_hIST;
  38. PNG_iCCP;
  39. PNG_iTXt;
  40. PNG_oFFs;
  41. PNG_pCAL;
  42. PNG_sCAL;
  43. PNG_pHYs;
  44. PNG_sBIT;
  45. PNG_sPLT;
  46. PNG_sRGB;
  47. PNG_tEXt;
  48. PNG_tIME;
  49. PNG_tRNS;
  50. PNG_zTXt;
  51.  
  52. /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  53.  
  54. /* start of interlace block */
  55. const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
  56.  
  57. /* offset to next interlace block */
  58. const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
  59.  
  60. /* start of interlace block in the y direction */
  61. const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
  62.  
  63. /* offset to next interlace block in the y direction */
  64. const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
  65.  
  66. /* width of interlace block (used in assembler routines only) */
  67. #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
  68. const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
  69. #endif
  70.  
  71. /* Height of interlace block.  This is not currently used - if you need
  72.  * it, uncomment it here and in png.h
  73. const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
  74. */
  75.  
  76. /* Mask to determine which pixels are valid in a pass */
  77. const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
  78.  
  79. /* Mask to determine which pixels to overwrite while displaying */
  80. const int FARDATA png_pass_dsp_mask[]
  81.    = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
  82.  
  83. #endif
  84.  
  85. /* Tells libpng that we have already handled the first "num_bytes" bytes
  86.  * of the PNG file signature.  If the PNG data is embedded into another
  87.  * stream we can set num_bytes = 8 so that libpng will not attempt to read
  88.  * or write any of the magic bytes before it starts on the IHDR.
  89.  */
  90.  
  91. void PNGAPI
  92. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
  93. {
  94.    png_debug(1, "in png_set_sig_bytes\n");
  95.    if (num_bytes > 8)
  96.       png_error(png_ptr, "Too many bytes for PNG signature.");
  97.  
  98.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
  99. }
  100.  
  101. /* Checks whether the supplied bytes match the PNG signature.  We allow
  102.  * checking less than the full 8-byte signature so that those apps that
  103.  * already read the first few bytes of a file to determine the file type
  104.  * can simply check the remaining bytes for extra assurance.  Returns
  105.  * an integer less than, equal to, or greater than zero if sig is found,
  106.  * respectively, to be less than, to match, or be greater than the correct
  107.  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
  108.  */
  109. int PNGAPI
  110. png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
  111. {
  112.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  113.    if (num_to_check > 8)
  114.       num_to_check = 8;
  115.    else if (num_to_check < 1)
  116.       return (0);
  117.  
  118.    if (start > 7)
  119.       return (0);
  120.  
  121.    if (start + num_to_check > 8)
  122.       num_to_check = 8 - start;
  123.  
  124.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
  125. }
  126.  
  127. /* (Obsolete) function to check signature bytes.  It does not allow one
  128.  * to check a partial signature.  This function might be removed in the
  129.  * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
  130.  */
  131. int PNGAPI
  132. png_check_sig(png_bytep sig, int num)
  133. {
  134.   return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
  135. }
  136.  
  137. /* Function to allocate memory for zlib and clear it to 0. */
  138. voidpf /* PRIVATE */
  139. png_zalloc(voidpf png_ptr, uInt items, uInt size)
  140. {
  141.    png_uint_32 num_bytes = (png_uint_32)items * size;
  142.    png_voidp ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
  143.  
  144. #ifndef PNG_NO_ZALLOC_ZERO
  145.    if (num_bytes > (png_uint_32)0x8000L)
  146.    {
  147.       png_memset(ptr, 0, (png_size_t)0x8000L);
  148.       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
  149.          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
  150.    }
  151.    else
  152.    {
  153.       png_memset(ptr, 0, (png_size_t)num_bytes);
  154.    }
  155. #endif
  156.    return ((voidpf)ptr);
  157. }
  158.  
  159. /* function to free memory for zlib */
  160. void /* PRIVATE */
  161. png_zfree(voidpf png_ptr, voidpf ptr)
  162. {
  163.    png_free((png_structp)png_ptr, (png_voidp)ptr);
  164. }
  165.  
  166. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
  167.  * in case CRC is > 32 bits to leave the top bits 0.
  168.  */
  169. void /* PRIVATE */
  170. png_reset_crc(png_structp png_ptr)
  171. {
  172.    png_ptr->crc = crc32(0, Z_NULL, 0);
  173. }
  174.  
  175. /* Calculate the CRC over a section of data.  We can only pass as
  176.  * much data to this routine as the largest single buffer size.  We
  177.  * also check that this data will actually be used before going to the
  178.  * trouble of calculating it.
  179.  */
  180. void /* PRIVATE */
  181. png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
  182. {
  183.    int need_crc = 1;
  184.  
  185.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
  186.    {
  187.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  188.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  189.          need_crc = 0;
  190.    }
  191.    else                                                    /* critical */
  192.    {
  193.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
  194.          need_crc = 0;
  195.    }
  196.  
  197.    if (need_crc)
  198.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
  199. }
  200.  
  201. /* Allocate the memory for an info_struct for the application.  We don't
  202.  * really need the png_ptr, but it could potentially be useful in the
  203.  * future.  This should be used in favour of malloc(sizeof(png_info))
  204.  * and png_info_init() so that applications that want to use a shared
  205.  * libpng don't have to be recompiled if png_info changes size.
  206.  */
  207. png_infop PNGAPI
  208. png_create_info_struct(png_structp png_ptr)
  209. {
  210.    png_infop info_ptr;
  211.  
  212.    png_debug(1, "in png_create_info_struct\n");
  213.    if(png_ptr == NULL) return (NULL);
  214. #ifdef PNG_USER_MEM_SUPPORTED
  215.    if ((info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
  216.       png_ptr->malloc_fn)) != NULL)
  217. #else
  218.    if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
  219. #endif
  220.    {
  221.       png_info_init(info_ptr);
  222.    }
  223.  
  224.    return (info_ptr);
  225. }
  226.  
  227. /* This function frees the memory associated with a single info struct.
  228.  * Normally, one would use either png_destroy_read_struct() or
  229.  * png_destroy_write_struct() to free an info struct, but this may be
  230.  * useful for some applications.
  231.  */
  232. void PNGAPI
  233. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
  234. {
  235.    png_infop info_ptr = NULL;
  236.  
  237.    png_debug(1, "in png_destroy_info_struct\n");
  238.    if (info_ptr_ptr != NULL)
  239.       info_ptr = *info_ptr_ptr;
  240.  
  241.    if (info_ptr != NULL)
  242.    {
  243.       png_info_destroy(png_ptr, info_ptr);
  244.  
  245. #ifdef PNG_USER_MEM_SUPPORTED
  246.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn);
  247. #else
  248.       png_destroy_struct((png_voidp)info_ptr);
  249. #endif
  250.       *info_ptr_ptr = (png_infop)NULL;
  251.    }
  252. }
  253.  
  254. /* Initialize the info structure.  This is now an internal function (0.89)
  255.  * and applications using it are urged to use png_create_info_struct()
  256.  * instead.
  257.  */
  258. void /* PRIVATE */
  259. png_info_init(png_infop info_ptr)
  260. {
  261.    png_debug(1, "in png_info_init\n");
  262.    /* set everything to 0 */
  263.    png_memset(info_ptr, 0, sizeof (png_info));
  264. }
  265.  
  266. #ifdef PNG_FREE_ME_SUPPORTED
  267. void PNGAPI
  268. png_data_freer(png_structp png_ptr, png_infop info_ptr,
  269.    int freer, png_uint_32 mask)
  270. {
  271.    png_debug(1, "in png_data_freer\n");
  272.    if (png_ptr == NULL || info_ptr == NULL)
  273.       return;
  274.    if(freer == PNG_DESTROY_WILL_FREE_DATA)
  275.       info_ptr->free_me |= mask;
  276.    else if(freer == PNG_USER_WILL_FREE_DATA)
  277.       info_ptr->free_me &= ~mask;
  278.    else
  279.       png_warning(png_ptr,
  280.          "Unknown freer parameter in png_data_freer.");
  281. }
  282. #endif
  283.  
  284. void PNGAPI
  285. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
  286.    int num)
  287. {
  288.    png_debug(1, "in png_free_data\n");
  289.    if (png_ptr == NULL || info_ptr == NULL)
  290.       return;
  291.  
  292. #if defined(PNG_TEXT_SUPPORTED)
  293. /* free text item num or (if num == -1) all text items */
  294. #ifdef PNG_FREE_ME_SUPPORTED
  295. if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
  296. #else
  297. if (mask & PNG_FREE_TEXT)
  298. #endif
  299. {
  300.    if (num != -1)
  301.    {
  302.      if (info_ptr->text && info_ptr->text[num].key)
  303.      {
  304.          png_free(png_ptr, info_ptr->text[num].key);
  305.          info_ptr->text[num].key = NULL;
  306.      }
  307.    }
  308.    else
  309.    {
  310.        int i;
  311.        for (i = 0; i < info_ptr->num_text; i++)
  312.            png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
  313.        png_free(png_ptr, info_ptr->text);
  314.        info_ptr->text = NULL;
  315.        info_ptr->num_text=0;
  316.    }
  317. }
  318. #endif
  319.  
  320. #if defined(PNG_tRNS_SUPPORTED)
  321. /* free any tRNS entry */
  322. #ifdef PNG_FREE_ME_SUPPORTED
  323. if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
  324. #else
  325. if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
  326. #endif
  327. {
  328.     png_free(png_ptr, info_ptr->trans);
  329.     info_ptr->valid &= ~PNG_INFO_tRNS;
  330.     info_ptr->trans = NULL;
  331. }
  332. #endif
  333.  
  334. #if defined(PNG_sCAL_SUPPORTED)
  335. /* free any sCAL entry */
  336. #ifdef PNG_FREE_ME_SUPPORTED
  337. if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
  338. #else
  339. if (mask & PNG_FREE_SCAL)
  340. #endif
  341. {
  342. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
  343.     png_free(png_ptr, info_ptr->scal_s_width);
  344.     png_free(png_ptr, info_ptr->scal_s_height);
  345.     info_ptr->scal_s_width = NULL;
  346.     info_ptr->scal_s_height = NULL;
  347. #endif
  348.     info_ptr->valid &= ~PNG_INFO_sCAL;
  349. }
  350. #endif
  351.  
  352. #if defined(PNG_pCAL_SUPPORTED)
  353. /* free any pCAL entry */
  354. #ifdef PNG_FREE_ME_SUPPORTED
  355. if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
  356. #else
  357. if (mask & PNG_FREE_PCAL)
  358. #endif
  359. {
  360.     png_free(png_ptr, info_ptr->pcal_purpose);
  361.     png_free(png_ptr, info_ptr->pcal_units);
  362.     info_ptr->pcal_purpose = NULL;
  363.     info_ptr->pcal_units = NULL;
  364.     if (info_ptr->pcal_params != NULL)
  365.     {
  366.         int i;
  367.         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
  368.         {
  369.           png_free(png_ptr, info_ptr->pcal_params[i]);
  370.           info_ptr->pcal_params[i]=NULL;
  371.         }
  372.         png_free(png_ptr, info_ptr->pcal_params);
  373.         info_ptr->pcal_params = NULL;
  374.     }
  375.     info_ptr->valid &= ~PNG_INFO_pCAL;
  376. }
  377. #endif
  378.  
  379. #if defined(PNG_iCCP_SUPPORTED)
  380. /* free any iCCP entry */
  381. #ifdef PNG_FREE_ME_SUPPORTED
  382. if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
  383. #else
  384. if (mask & PNG_FREE_ICCP)
  385. #endif
  386. {
  387.     png_free(png_ptr, info_ptr->iccp_name);
  388.     png_free(png_ptr, info_ptr->iccp_profile);
  389.     info_ptr->iccp_name = NULL;
  390.     info_ptr->iccp_profile = NULL;
  391.     info_ptr->valid &= ~PNG_INFO_iCCP;
  392. }
  393. #endif
  394.  
  395. #if defined(PNG_sPLT_SUPPORTED)
  396. /* free a given sPLT entry, or (if num == -1) all sPLT entries */
  397. #ifdef PNG_FREE_ME_SUPPORTED
  398. if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
  399. #else
  400. if (mask & PNG_FREE_SPLT)
  401. #endif
  402. {
  403.    if (num != -1)
  404.    {
  405.       if(info_ptr->splt_palettes)
  406.       {
  407.           png_free(png_ptr, info_ptr->splt_palettes[num].name);
  408.           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  409.           info_ptr->splt_palettes[num].name = NULL;
  410.           info_ptr->splt_palettes[num].entries = NULL;
  411.       }
  412.    }
  413.    else
  414.    {
  415.        if(info_ptr->splt_palettes_num)
  416.        {
  417.          int i;
  418.          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  419.             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
  420.  
  421.          png_free(png_ptr, info_ptr->splt_palettes);
  422.          info_ptr->splt_palettes = NULL;
  423.          info_ptr->splt_palettes_num = 0;
  424.        }
  425.        info_ptr->valid &= ~PNG_INFO_sPLT;
  426.    }
  427. }
  428. #endif
  429.  
  430. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  431. #ifdef PNG_FREE_ME_SUPPORTED
  432. if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
  433. #else
  434. if (mask & PNG_FREE_UNKN)
  435. #endif
  436. {
  437.    if (num != -1)
  438.    {
  439.        if(info_ptr->unknown_chunks)
  440.        {
  441.           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  442.           info_ptr->unknown_chunks[num].data = NULL;
  443.        }
  444.    }
  445.    else
  446.    {
  447.        int i;
  448.  
  449.        if(info_ptr->unknown_chunks_num)
  450.        {
  451.          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
  452.             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
  453.  
  454.          png_free(png_ptr, info_ptr->unknown_chunks);
  455.          info_ptr->unknown_chunks = NULL;
  456.          info_ptr->unknown_chunks_num = 0;
  457.        }
  458.    }
  459. }
  460. #endif
  461.  
  462. #if defined(PNG_hIST_SUPPORTED)
  463. /* free any hIST entry */
  464. #ifdef PNG_FREE_ME_SUPPORTED
  465. if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
  466. #else
  467. if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
  468. #endif
  469. {
  470.     png_free(png_ptr, info_ptr->hist);
  471.     info_ptr->hist = NULL;
  472.     info_ptr->valid &= ~PNG_INFO_hIST;
  473. }
  474. #endif
  475.  
  476. /* free any PLTE entry that was internally allocated */
  477. #ifdef PNG_FREE_ME_SUPPORTED
  478. if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
  479. #else
  480. if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
  481. #endif
  482. {
  483.     png_zfree(png_ptr, info_ptr->palette);
  484.     info_ptr->palette = NULL;
  485.     info_ptr->valid &= ~PNG_INFO_PLTE;
  486.     info_ptr->num_palette = 0;
  487. }
  488.  
  489. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  490. /* free any image bits attached to the info structure */
  491. #ifdef PNG_FREE_ME_SUPPORTED
  492. if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
  493. #else
  494. if (mask & PNG_FREE_ROWS)
  495. #endif
  496. {
  497.     if(info_ptr->row_pointers)
  498.     {
  499.        int row;
  500.        for (row = 0; row < (int)info_ptr->height; row++)
  501.        {
  502.           png_free(png_ptr, info_ptr->row_pointers[row]);
  503.           info_ptr->row_pointers[row]=NULL;
  504.        }
  505.        png_free(png_ptr, info_ptr->row_pointers);
  506.        info_ptr->row_pointers=NULL;
  507.     }
  508.     info_ptr->valid &= ~PNG_INFO_IDAT;
  509. }
  510. #endif
  511.  
  512. #ifdef PNG_FREE_ME_SUPPORTED
  513.    if(num == -1)
  514.      info_ptr->free_me &= ~mask;
  515.    else
  516.      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
  517. #endif
  518. }
  519.  
  520. /* This is an internal routine to free any memory that the info struct is
  521.  * pointing to before re-using it or freeing the struct itself.  Recall
  522.  * that png_free() checks for NULL pointers for us.
  523.  */
  524. void /* PRIVATE */
  525. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
  526. {
  527.    png_debug(1, "in png_info_destroy\n");
  528.  
  529.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  530.  
  531. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  532.    if (png_ptr->num_chunk_list)
  533.    {
  534.        png_free(png_ptr, png_ptr->chunk_list);
  535.        png_ptr->chunk_list=NULL;
  536.        png_ptr->num_chunk_list=0;
  537.    }
  538. #endif
  539.  
  540.    png_info_init(info_ptr);
  541. }
  542.  
  543. /* This function returns a pointer to the io_ptr associated with the user
  544.  * functions.  The application should free any memory associated with this
  545.  * pointer before png_write_destroy() or png_read_destroy() are called.
  546.  */
  547. png_voidp PNGAPI
  548. png_get_io_ptr(png_structp png_ptr)
  549. {
  550.    return (png_ptr->io_ptr);
  551. }
  552.  
  553. #if !defined(PNG_NO_STDIO)
  554. /* Initialize the default input/output functions for the PNG file.  If you
  555.  * use your own read or write routines, you can call either png_set_read_fn()
  556.  * or png_set_write_fn() instead of png_init_io().  If you have defined
  557.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
  558.  * necessarily available.
  559.  */
  560. void PNGAPI
  561. png_init_io(png_structp png_ptr, png_FILE_p fp)
  562. {
  563.    png_debug(1, "in png_init_io\n");
  564.    png_ptr->io_ptr = (png_voidp)fp;
  565. }
  566. #endif
  567.  
  568. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  569. /* Convert the supplied time into an RFC 1123 string suitable for use in
  570.  * a "Creation Time" or other text-based time string.
  571.  */
  572. png_charp PNGAPI
  573. png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
  574. {
  575.    static PNG_CONST char short_months[12][4] =
  576.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  577.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  578.  
  579.    if (png_ptr->time_buffer == NULL)
  580.    {
  581.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
  582.          sizeof(char)));
  583.    }
  584.  
  585. #if defined(_WIN32_WCE)
  586.    {
  587.       wchar_t time_buf[29];
  588.       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
  589.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  590.         ptime->year, ptime->hour % 24, ptime->minute % 60,
  591.           ptime->second % 61);
  592.       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
  593.           NULL, NULL);
  594.    }
  595. #else
  596. #ifdef USE_FAR_KEYWORD
  597.    {
  598.       char near_time_buf[29];
  599.       sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
  600.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  601.           ptime->year, ptime->hour % 24, ptime->minute % 60,
  602.           ptime->second % 61);
  603.       png_memcpy(png_ptr->time_buffer, near_time_buf,
  604.           29*sizeof(char));
  605.    }
  606. #else
  607.    sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
  608.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
  609.        ptime->year, ptime->hour % 24, ptime->minute % 60,
  610.        ptime->second % 61);
  611. #endif
  612. #endif /* _WIN32_WCE */
  613.    return ((png_charp)png_ptr->time_buffer);
  614. }
  615. #endif /* PNG_TIME_RFC1123_SUPPORTED */
  616.  
  617. #if 0
  618. /* Signature string for a PNG file. */
  619. png_bytep PNGAPI
  620. png_sig_bytes(void)
  621. {
  622.    return ((png_bytep)"\211\120\116\107\015\012\032\012");
  623. }
  624. #endif
  625.  
  626. png_charp PNGAPI
  627. png_get_copyright(png_structp png_ptr)
  628. {
  629.    if (png_ptr != NULL || png_ptr == NULL)  /* silence compiler warning */
  630.    return ((png_charp) "\n libpng version 1.0.11 - April 27, 2001\n\
  631.    Copyright (c) 1998-2001 Glenn Randers-Pehrson\n\
  632.    Copyright (c) 1996, 1997 Andreas Dilger\n\
  633.    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n");
  634.    return ((png_charp) "");
  635. }
  636.  
  637. /* The following return the library version as a short string in the
  638.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files used
  639.  * with your application, print out PNG_LIBPNG_VER_STRING, which is defined
  640.  * in png.h.
  641.  */
  642.  
  643. png_charp PNGAPI
  644. png_get_libpng_ver(png_structp png_ptr)
  645. {
  646.    /* Version of *.c files used when building libpng */
  647.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  648.       return((png_charp) "1.0.11");
  649.    return((png_charp) "1.0.11");
  650. }
  651.  
  652. png_charp PNGAPI
  653. png_get_header_ver(png_structp png_ptr)
  654. {
  655.    /* Version of *.h files used when building libpng */
  656.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  657.       return((png_charp) PNG_LIBPNG_VER_STRING);
  658.    return((png_charp) PNG_LIBPNG_VER_STRING);
  659. }
  660.  
  661. png_charp PNGAPI
  662. png_get_header_version(png_structp png_ptr)
  663. {
  664.    /* Returns longer string containing both version and date */
  665.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  666.       return((png_charp) PNG_HEADER_VERSION_STRING);
  667.    return((png_charp) PNG_HEADER_VERSION_STRING);
  668. }
  669.  
  670. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  671. int /* PRIVATE */
  672. png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
  673. {
  674.    /* check chunk_name and return "keep" value if it's on the list, else 0 */
  675.    int i;
  676.    png_bytep p;
  677.    if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
  678.       return 0;
  679.    p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
  680.    for (i = png_ptr->num_chunk_list; i; i--, p-=5)
  681.       if (!png_memcmp(chunk_name, p, 4))
  682.         return ((int)*(p+4));
  683.    return 0;
  684. }
  685. #endif
  686.  
  687. /* This function, added to libpng-1.0.6g, is untested. */
  688. int PNGAPI
  689. png_reset_zstream(png_structp png_ptr)
  690. {
  691.    return (inflateReset(&png_ptr->zstream));
  692. }
  693.  
  694. /* This function was added to libpng-1.0.7 */
  695. png_uint_32 PNGAPI
  696. png_access_version_number(void)
  697. {
  698.    /* Version of *.c files used when building libpng */
  699.    return((png_uint_32) 10011L);
  700. }
  701.  
  702.  
  703. #if 0 /* delay this until version 1.2.0 */
  704. /* this function was added to libpng 1.0.9 (porting aid to libpng-1.2.0) */
  705. #ifndef PNG_ASSEMBLER_CODE_SUPPORTED
  706. int PNGAPI
  707. png_mmx_support(void)
  708. {
  709.     return -1;
  710. }
  711. #endif
  712. #endif /* 0 */
  713.