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