home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / png / png.c < prev    next >
C/C++ Source or Header  |  2002-07-09  |  24KB  |  810 lines
  1.  
  2. /* png.c - location for general purpose libpng functions
  3.  *
  4.  * libpng version 1.2.4 - July 8, 2002
  5.  * Copyright (c) 1998-2002 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_2_4 Your_png_h_is_not_version_1_2_4;
  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.2.4";
  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. #ifdef __VISAGECPP__
  86. const char png_libpng_ver[18] = "1.2.4";
  87. #endif
  88.  
  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.  */
  94.  
  95. void PNGAPI
  96. png_set_sig_bytes(png_structp png_ptr, int num_bytes)
  97. {
  98.    png_debug(1, "in png_set_sig_bytes\n");
  99.    if (num_bytes > 8)
  100.       png_error(png_ptr, "Too many bytes for PNG signature.");
  101.  
  102.    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
  103. }
  104.  
  105. /* Checks whether the supplied bytes match the PNG signature.  We allow
  106.  * checking less than the full 8-byte signature so that those apps that
  107.  * already read the first few bytes of a file to determine the file type
  108.  * can simply check the remaining bytes for extra assurance.  Returns
  109.  * an integer less than, equal to, or greater than zero if sig is found,
  110.  * respectively, to be less than, to match, or be greater than the correct
  111.  * PNG signature (this is the same behaviour as strcmp, memcmp, etc).
  112.  */
  113. int PNGAPI
  114. png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
  115. {
  116.    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  117.    if (num_to_check > 8)
  118.       num_to_check = 8;
  119.    else if (num_to_check < 1)
  120.       return (0);
  121.  
  122.    if (start > 7)
  123.       return (0);
  124.  
  125.    if (start + num_to_check > 8)
  126.       num_to_check = 8 - start;
  127.  
  128.    return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
  129. }
  130.  
  131. /* (Obsolete) function to check signature bytes.  It does not allow one
  132.  * to check a partial signature.  This function might be removed in the
  133.  * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.
  134.  */
  135. int PNGAPI
  136. png_check_sig(png_bytep sig, int num)
  137. {
  138.   return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
  139. }
  140.  
  141. /* Function to allocate memory for zlib and clear it to 0. */
  142. #ifdef PNG_1_0_X
  143. void PNGAPI
  144. #else
  145. voidpf /* private */
  146. #endif
  147. png_zalloc(voidpf png_ptr, uInt items, uInt size)
  148. {
  149.    png_uint_32 num_bytes = (png_uint_32)items * size;
  150.    png_voidp ptr;
  151.    png_structp p=(png_structp)png_ptr;
  152.    png_uint_32 save_flags=p->flags;
  153.  
  154.    p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  155.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
  156.    p->flags=save_flags;
  157.  
  158. #ifndef PNG_NO_ZALLOC_ZERO
  159.    if (ptr == NULL)
  160.        return ((voidpf)ptr);
  161.  
  162.    if (num_bytes > (png_uint_32)0x8000L)
  163.    {
  164.       png_memset(ptr, 0, (png_size_t)0x8000L);
  165.       png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,
  166.          (png_size_t)(num_bytes - (png_uint_32)0x8000L));
  167.    }
  168.    else
  169.    {
  170.       png_memset(ptr, 0, (png_size_t)num_bytes);
  171.    }
  172. #endif
  173.    return ((voidpf)ptr);
  174. }
  175.  
  176. /* function to free memory for zlib */
  177. #ifdef PNG_1_0_X
  178. void PNGAPI
  179. #else
  180. void /* private */
  181. #endif
  182. png_zfree(voidpf png_ptr, voidpf ptr)
  183. {
  184.    png_free((png_structp)png_ptr, (png_voidp)ptr);
  185. }
  186.  
  187. /* Reset the CRC variable to 32 bits of 1's.  Care must be taken
  188.  * in case CRC is > 32 bits to leave the top bits 0.
  189.  */
  190. void /* PRIVATE */
  191. png_reset_crc(png_structp png_ptr)
  192. {
  193.    png_ptr->crc = crc32(0, Z_NULL, 0);
  194. }
  195.  
  196. /* Calculate the CRC over a section of data.  We can only pass as
  197.  * much data to this routine as the largest single buffer size.  We
  198.  * also check that this data will actually be used before going to the
  199.  * trouble of calculating it.
  200.  */
  201. void /* PRIVATE */
  202. png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
  203. {
  204.    int need_crc = 1;
  205.  
  206.    if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
  207.    {
  208.       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  209.           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  210.          need_crc = 0;
  211.    }
  212.    else                                                    /* critical */
  213.    {
  214.       if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
  215.          need_crc = 0;
  216.    }
  217.  
  218.    if (need_crc)
  219.       png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
  220. }
  221.  
  222. /* Allocate the memory for an info_struct for the application.  We don't
  223.  * really need the png_ptr, but it could potentially be useful in the
  224.  * future.  This should be used in favour of malloc(sizeof(png_info))
  225.  * and png_info_init() so that applications that want to use a shared
  226.  * libpng don't have to be recompiled if png_info changes size.
  227.  */
  228. png_infop PNGAPI
  229. png_create_info_struct(png_structp png_ptr)
  230. {
  231.    png_infop info_ptr;
  232.  
  233.    png_debug(1, "in png_create_info_struct\n");
  234.    if(png_ptr == NULL) return (NULL);
  235. #ifdef PNG_USER_MEM_SUPPORTED
  236.    info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
  237.       png_ptr->malloc_fn, png_ptr->mem_ptr);
  238. #else
  239.    info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  240. #endif
  241.    if (info_ptr != NULL)
  242.       png_info_init_3(&info_ptr, sizeof(png_info));
  243.  
  244.    return (info_ptr);
  245. }
  246.  
  247. /* This function frees the memory associated with a single info struct.
  248.  * Normally, one would use either png_destroy_read_struct() or
  249.  * png_destroy_write_struct() to free an info struct, but this may be
  250.  * useful for some applications.
  251.  */
  252. void PNGAPI
  253. png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
  254. {
  255.    png_infop info_ptr = NULL;
  256.  
  257.    png_debug(1, "in png_destroy_info_struct\n");
  258.    if (info_ptr_ptr != NULL)
  259.       info_ptr = *info_ptr_ptr;
  260.  
  261.    if (info_ptr != NULL)
  262.    {
  263.       png_info_destroy(png_ptr, info_ptr);
  264.  
  265. #ifdef PNG_USER_MEM_SUPPORTED
  266.       png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
  267.           png_ptr->mem_ptr);
  268. #else
  269.       png_destroy_struct((png_voidp)info_ptr);
  270. #endif
  271.       *info_ptr_ptr = NULL;
  272.    }
  273. }
  274.  
  275. /* Initialize the info structure.  This is now an internal function (0.89)
  276.  * and applications using it are urged to use png_create_info_struct()
  277.  * instead.
  278.  */
  279. #undef png_info_init
  280. void PNGAPI
  281. png_info_init(png_infop info_ptr)
  282. {
  283.    /* We only come here via pre-1.0.12-compiled applications */
  284.    png_info_init_3(&info_ptr, 0);
  285. }
  286.  
  287. void PNGAPI
  288. png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
  289. {
  290.    png_infop info_ptr = *ptr_ptr;
  291.  
  292.    png_debug(1, "in png_info_init_3\n");
  293.  
  294.    if(sizeof(png_info) > png_info_struct_size)
  295.      {
  296.        png_destroy_struct(info_ptr);
  297.        info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
  298.        *ptr_ptr = info_ptr;
  299.      }
  300.  
  301.    /* set everything to 0 */
  302.    png_memset(info_ptr, 0, sizeof (png_info));
  303. }
  304.  
  305. #ifdef PNG_FREE_ME_SUPPORTED
  306. void PNGAPI
  307. png_data_freer(png_structp png_ptr, png_infop info_ptr,
  308.    int freer, png_uint_32 mask)
  309. {
  310.    png_debug(1, "in png_data_freer\n");
  311.    if (png_ptr == NULL || info_ptr == NULL)
  312.       return;
  313.    if(freer == PNG_DESTROY_WILL_FREE_DATA)
  314.       info_ptr->free_me |= mask;
  315.    else if(freer == PNG_USER_WILL_FREE_DATA)
  316.       info_ptr->free_me &= ~mask;
  317.    else
  318.       png_warning(png_ptr,
  319.          "Unknown freer parameter in png_data_freer.");
  320. }
  321. #endif
  322.  
  323. void PNGAPI
  324. png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
  325.    int num)
  326. {
  327.    png_debug(1, "in png_free_data\n");
  328.    if (png_ptr == NULL || info_ptr == NULL)
  329.       return;
  330.  
  331. #if defined(PNG_TEXT_SUPPORTED)
  332. /* free text item num or (if num == -1) all text items */
  333. #ifdef PNG_FREE_ME_SUPPORTED
  334. if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
  335. #else
  336. if (mask & PNG_FREE_TEXT)
  337. #endif
  338. {
  339.    if (num != -1)
  340.    {
  341.      if (info_ptr->text && info_ptr->text[num].key)
  342.      {
  343.          png_free(png_ptr, info_ptr->text[num].key);
  344.          info_ptr->text[num].key = NULL;
  345.      }
  346.    }
  347.    else
  348.    {
  349.        int i;
  350.        for (i = 0; i < info_ptr->num_text; i++)
  351.            png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
  352.        png_free(png_ptr, info_ptr->text);
  353.        info_ptr->text = NULL;
  354.        info_ptr->num_text=0;
  355.    }
  356. }
  357. #endif
  358.  
  359. #if defined(PNG_tRNS_SUPPORTED)
  360. /* free any tRNS entry */
  361. #ifdef PNG_FREE_ME_SUPPORTED
  362. if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
  363. #else
  364. if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
  365. #endif
  366. {
  367.     png_free(png_ptr, info_ptr->trans);
  368.     info_ptr->valid &= ~PNG_INFO_tRNS;
  369. #ifndef PNG_FREE_ME_SUPPORTED
  370.     png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
  371. #endif
  372.     info_ptr->trans = NULL;
  373. }
  374. #endif
  375.  
  376. #if defined(PNG_sCAL_SUPPORTED)
  377. /* free any sCAL entry */
  378. #ifdef PNG_FREE_ME_SUPPORTED
  379. if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
  380. #else
  381. if (mask & PNG_FREE_SCAL)
  382. #endif
  383. {
  384. #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
  385.     png_free(png_ptr, info_ptr->scal_s_width);
  386.     png_free(png_ptr, info_ptr->scal_s_height);
  387.     info_ptr->scal_s_width = NULL;
  388.     info_ptr->scal_s_height = NULL;
  389. #endif
  390.     info_ptr->valid &= ~PNG_INFO_sCAL;
  391. }
  392. #endif
  393.  
  394. #if defined(PNG_pCAL_SUPPORTED)
  395. /* free any pCAL entry */
  396. #ifdef PNG_FREE_ME_SUPPORTED
  397. if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
  398. #else
  399. if (mask & PNG_FREE_PCAL)
  400. #endif
  401. {
  402.     png_free(png_ptr, info_ptr->pcal_purpose);
  403.     png_free(png_ptr, info_ptr->pcal_units);
  404.     info_ptr->pcal_purpose = NULL;
  405.     info_ptr->pcal_units = NULL;
  406.     if (info_ptr->pcal_params != NULL)
  407.     {
  408.         int i;
  409.         for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
  410.         {
  411.           png_free(png_ptr, info_ptr->pcal_params[i]);
  412.           info_ptr->pcal_params[i]=NULL;
  413.         }
  414.         png_free(png_ptr, info_ptr->pcal_params);
  415.         info_ptr->pcal_params = NULL;
  416.     }
  417.     info_ptr->valid &= ~PNG_INFO_pCAL;
  418. }
  419. #endif
  420.  
  421. #if defined(PNG_iCCP_SUPPORTED)
  422. /* free any iCCP entry */
  423. #ifdef PNG_FREE_ME_SUPPORTED
  424. if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
  425. #else
  426. if (mask & PNG_FREE_ICCP)
  427. #endif
  428. {
  429.     png_free(png_ptr, info_ptr->iccp_name);
  430.     png_free(png_ptr, info_ptr->iccp_profile);
  431.     info_ptr->iccp_name = NULL;
  432.     info_ptr->iccp_profile = NULL;
  433.     info_ptr->valid &= ~PNG_INFO_iCCP;
  434. }
  435. #endif
  436.  
  437. #if defined(PNG_sPLT_SUPPORTED)
  438. /* free a given sPLT entry, or (if num == -1) all sPLT entries */
  439. #ifdef PNG_FREE_ME_SUPPORTED
  440. if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
  441. #else
  442. if (mask & PNG_FREE_SPLT)
  443. #endif
  444. {
  445.    if (num != -1)
  446.    {
  447.       if(info_ptr->splt_palettes)
  448.       {
  449.           png_free(png_ptr, info_ptr->splt_palettes[num].name);
  450.           png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  451.           info_ptr->splt_palettes[num].name = NULL;
  452.           info_ptr->splt_palettes[num].entries = NULL;
  453.       }
  454.    }
  455.    else
  456.    {
  457.        if(info_ptr->splt_palettes_num)
  458.        {
  459.          int i;
  460.          for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  461.             png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
  462.  
  463.          png_free(png_ptr, info_ptr->splt_palettes);
  464.          info_ptr->splt_palettes = NULL;
  465.          info_ptr->splt_palettes_num = 0;
  466.        }
  467.        info_ptr->valid &= ~PNG_INFO_sPLT;
  468.    }
  469. }
  470. #endif
  471.  
  472. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  473. #ifdef PNG_FREE_ME_SUPPORTED
  474. if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
  475. #else
  476. if (mask & PNG_FREE_UNKN)
  477. #endif
  478. {
  479.    if (num != -1)
  480.    {
  481.        if(info_ptr->unknown_chunks)
  482.        {
  483.           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  484.           info_ptr->unknown_chunks[num].data = NULL;
  485.        }
  486.    }
  487.    else
  488.    {
  489.        int i;
  490.  
  491.        if(info_ptr->unknown_chunks_num)
  492.        {
  493.          for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
  494.             png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
  495.  
  496.          png_free(png_ptr, info_ptr->unknown_chunks);
  497.          info_ptr->unknown_chunks = NULL;
  498.          info_ptr->unknown_chunks_num = 0;
  499.        }
  500.    }
  501. }
  502. #endif
  503.  
  504. #if defined(PNG_hIST_SUPPORTED)
  505. /* free any hIST entry */
  506. #ifdef PNG_FREE_ME_SUPPORTED
  507. if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)
  508. #else
  509. if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
  510. #endif
  511. {
  512.     png_free(png_ptr, info_ptr->hist);
  513.     info_ptr->hist = NULL;
  514.     info_ptr->valid &= ~PNG_INFO_hIST;
  515. #ifndef PNG_FREE_ME_SUPPORTED
  516.     png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
  517. #endif
  518. }
  519. #endif
  520.  
  521. /* free any PLTE entry that was internally allocated */
  522. #ifdef PNG_FREE_ME_SUPPORTED
  523. if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
  524. #else
  525. if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
  526. #endif
  527. {
  528.     png_zfree(png_ptr, info_ptr->palette);
  529.     info_ptr->palette = NULL;
  530.     info_ptr->valid &= ~PNG_INFO_PLTE;
  531. #ifndef PNG_FREE_ME_SUPPORTED
  532.     png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
  533. #endif
  534.     info_ptr->num_palette = 0;
  535. }
  536.  
  537. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  538. /* free any image bits attached to the info structure */
  539. #ifdef PNG_FREE_ME_SUPPORTED
  540. if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
  541. #else
  542. if (mask & PNG_FREE_ROWS)
  543. #endif
  544. {
  545.     if(info_ptr->row_pointers)
  546.     {
  547.        int row;
  548.        for (row = 0; row < (int)info_ptr->height; row++)
  549.        {
  550.           png_free(png_ptr, info_ptr->row_pointers[row]);
  551.           info_ptr->row_pointers[row]=NULL;
  552.        }
  553.        png_free(png_ptr, info_ptr->row_pointers);
  554.        info_ptr->row_pointers=NULL;
  555.     }
  556.     info_ptr->valid &= ~PNG_INFO_IDAT;
  557. }
  558. #endif
  559.  
  560. #ifdef PNG_FREE_ME_SUPPORTED
  561.    if(num == -1)
  562.      info_ptr->free_me &= ~mask;
  563.    else
  564.      info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
  565. #endif
  566. }
  567.  
  568. /* This is an internal routine to free any memory that the info struct is
  569.  * pointing to before re-using it or freeing the struct itself.  Recall
  570.  * that png_free() checks for NULL pointers for us.
  571.  */
  572. void /* PRIVATE */
  573. png_info_destroy(png_structp png_ptr, png_infop info_ptr)
  574. {
  575.    png_debug(1, "in png_info_destroy\n");
  576.  
  577.    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  578.  
  579. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  580.    if (png_ptr->num_chunk_list)
  581.    {
  582.        png_free(png_ptr, png_ptr->chunk_list);
  583.        png_ptr->chunk_list=NULL;
  584.        png_ptr->num_chunk_list=0;
  585.    }
  586. #endif
  587.  
  588.    png_info_init_3(&info_ptr, sizeof(png_info));
  589. }
  590.  
  591. /* This function returns a pointer to the io_ptr associated with the user
  592.  * functions.  The application should free any memory associated with this
  593.  * pointer before png_write_destroy() or png_read_destroy() are called.
  594.  */
  595. png_voidp PNGAPI
  596. png_get_io_ptr(png_structp png_ptr)
  597. {
  598.    return (png_ptr->io_ptr);
  599. }
  600.  
  601. #if !defined(PNG_NO_STDIO)
  602. /* Initialize the default input/output functions for the PNG file.  If you
  603.  * use your own read or write routines, you can call either png_set_read_fn()
  604.  * or png_set_write_fn() instead of png_init_io().  If you have defined
  605.  * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
  606.  * necessarily available.
  607.  */
  608. void PNGAPI
  609. png_init_io(png_structp png_ptr, png_FILE_p fp)
  610. {
  611.    png_debug(1, "in png_init_io\n");
  612.    png_ptr->io_ptr = (png_voidp)fp;
  613. }
  614. #endif
  615.  
  616. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  617. /* Convert the supplied time into an RFC 1123 string suitable for use in
  618.  * a "Creation Time" or other text-based time string.
  619.  */
  620. png_charp PNGAPI
  621. png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
  622. {
  623.    static PNG_CONST char short_months[12][4] =
  624.         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  625.          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  626.  
  627.    if (png_ptr->time_buffer == NULL)
  628.    {
  629.       png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
  630.          sizeof(char)));
  631.    }
  632.  
  633. #if defined(_WIN32_WCE)
  634.    {
  635.       wchar_t time_buf[29];
  636.       wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),
  637.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  638.         ptime->year, ptime->hour % 24, ptime->minute % 60,
  639.           ptime->second % 61);
  640.       WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
  641.           NULL, NULL);
  642.    }
  643. #else
  644. #ifdef USE_FAR_KEYWORD
  645.    {
  646.       char near_time_buf[29];
  647.       sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
  648.           ptime->day % 32, short_months[(ptime->month - 1) % 12],
  649.           ptime->year, ptime->hour % 24, ptime->minute % 60,
  650.           ptime->second % 61);
  651.       png_memcpy(png_ptr->time_buffer, near_time_buf,
  652.           29*sizeof(char));
  653.    }
  654. #else
  655.    sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
  656.        ptime->day % 32, short_months[(ptime->month - 1) % 12],
  657.        ptime->year, ptime->hour % 24, ptime->minute % 60,
  658.        ptime->second % 61);
  659. #endif
  660. #endif /* _WIN32_WCE */
  661.    return ((png_charp)png_ptr->time_buffer);
  662. }
  663. #endif /* PNG_TIME_RFC1123_SUPPORTED */
  664.  
  665. #if 0
  666. /* Signature string for a PNG file. */
  667. png_bytep PNGAPI
  668. png_sig_bytes(void)
  669. {
  670.    return ((png_bytep)"\211\120\116\107\015\012\032\012");
  671. }
  672. #endif
  673.  
  674. png_charp PNGAPI
  675. png_get_copyright(png_structp png_ptr)
  676. {
  677.    if (png_ptr != NULL || png_ptr == NULL)  /* silence compiler warning */
  678.    return ((png_charp) "\n libpng version 1.2.4 - July 8, 2002\n\
  679.    Copyright (c) 1998-2002 Glenn Randers-Pehrson\n\
  680.    Copyright (c) 1996-1997 Andreas Dilger\n\
  681.    Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
  682.    return ((png_charp) "");
  683. }
  684.  
  685. /* The following return the library version as a short string in the
  686.  * format 1.0.0 through 99.99.99zz.  To get the version of *.h files used
  687.  * with your application, print out PNG_LIBPNG_VER_STRING, which is defined
  688.  * in png.h.
  689.  */
  690.  
  691. png_charp PNGAPI
  692. png_get_libpng_ver(png_structp png_ptr)
  693. {
  694.    /* Version of *.c files used when building libpng */
  695.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  696.       return((png_charp) "1.2.4");
  697.    return((png_charp) "1.2.4");
  698. }
  699.  
  700. png_charp PNGAPI
  701. png_get_header_ver(png_structp png_ptr)
  702. {
  703.    /* Version of *.h files used when building libpng */
  704.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  705.       return((png_charp) PNG_LIBPNG_VER_STRING);
  706.    return((png_charp) PNG_LIBPNG_VER_STRING);
  707. }
  708.  
  709. png_charp PNGAPI
  710. png_get_header_version(png_structp png_ptr)
  711. {
  712.    /* Returns longer string containing both version and date */
  713.    if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
  714.       return((png_charp) PNG_HEADER_VERSION_STRING);
  715.    return((png_charp) PNG_HEADER_VERSION_STRING);
  716. }
  717.  
  718. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  719. int PNGAPI
  720. png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
  721. {
  722.    /* check chunk_name and return "keep" value if it's on the list, else 0 */
  723.    int i;
  724.    png_bytep p;
  725.    if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)
  726.       return 0;
  727.    p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;
  728.    for (i = png_ptr->num_chunk_list; i; i--, p-=5)
  729.       if (!png_memcmp(chunk_name, p, 4))
  730.         return ((int)*(p+4));
  731.    return 0;
  732. }
  733. #endif
  734.  
  735. /* This function, added to libpng-1.0.6g, is untested. */
  736. int PNGAPI
  737. png_reset_zstream(png_structp png_ptr)
  738. {
  739.    return (inflateReset(&png_ptr->zstream));
  740. }
  741.  
  742. /* This function was added to libpng-1.0.7 */
  743. png_uint_32 PNGAPI
  744. png_access_version_number(void)
  745. {
  746.    /* Version of *.c files used when building libpng */
  747.    return((png_uint_32) 10204L);
  748. }
  749.  
  750.  
  751. #if !defined(PNG_1_0_X)
  752. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
  753.     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
  754. /* this INTERNAL function was added to libpng 1.2.0 */
  755. void /* PRIVATE */
  756. png_init_mmx_flags (png_structp png_ptr)
  757. {
  758.     png_ptr->mmx_rowbytes_threshold = 0;
  759.     png_ptr->mmx_bitdepth_threshold = 0;
  760.  
  761. #  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
  762.  
  763.     png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
  764.  
  765.     if (png_mmx_support()) {
  766.         png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
  767. #    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
  768.                               | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
  769. #    endif
  770. #    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
  771.                               | PNG_ASM_FLAG_MMX_READ_INTERLACE
  772. #    endif
  773. #    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
  774.                               ;
  775. #    else
  776.                               | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
  777.                               | PNG_ASM_FLAG_MMX_READ_FILTER_UP
  778.                               | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
  779.                               | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
  780.  
  781.         png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
  782.         png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
  783. #    endif
  784.     } else {
  785.         png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
  786.                                | PNG_MMX_READ_FLAGS
  787.                                | PNG_MMX_WRITE_FLAGS );
  788.     }
  789.  
  790. #  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
  791.  
  792.     /* clear all MMX flags; no support is compiled in */
  793.     png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
  794.  
  795. #  endif /* ?(PNGVCRD || PNGGCCRD) */
  796. }
  797.  
  798. #endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */
  799.  
  800. /* this function was added to libpng 1.2.0 */
  801. #if !defined(PNG_USE_PNGGCCRD) && \
  802.     !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
  803. int PNGAPI
  804. png_mmx_support(void)
  805. {
  806.     return -1;
  807. }
  808. #endif
  809. #endif /* PNG_1_0_X */
  810.