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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Windows Mobile > 查看源码
pngread.c
资源名称：TextViewNG.rar　[点击查看]
上传用户：hmc_gdtv
上传日期：2013-08-04
资源大小：798k
文件大小：47k
源码类别：

Windows Mobile

开发平台：

Visual C++

pngread.c：源码内容
  2. /* pngread.c - read a PNG file
  3.  *
  4.  * libpng 1.2.8 - December 3, 2004
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2004 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.  *
  10.  * This file contains routines that an application calls directly to
  11.  * read a PNG file or stream.
  12.  */
  14. #define PNG_INTERNAL
  15. #include "png.h"
  17. /* Create a PNG structure for reading, and allocate any memory needed. */
  18. png_structp PNGAPI
  19. png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
  20.    png_error_ptr error_fn, png_error_ptr warn_fn)
  21. {
  23. #ifdef PNG_USER_MEM_SUPPORTED
  24.    return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
  25.       warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
  26. }
  28. /* Alternate create PNG structure for reading, and allocate any memory needed. */
  29. png_structp PNGAPI
  30. png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
  31.    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
  32.    png_malloc_ptr malloc_fn, png_free_ptr free_fn)
  33. {
  34. #endif /* PNG_USER_MEM_SUPPORTED */
  36.    png_structp png_ptr;
  38. #ifdef PNG_SETJMP_SUPPORTED
  39. #ifdef USE_FAR_KEYWORD
  40.    jmp_buf jmpbuf;
  41. #endif
  42. #endif
  44.    int i;
  46.    png_debug(1, "in png_create_read_structn");
  47. #ifdef PNG_USER_MEM_SUPPORTED
  48.    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
  49.       (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
  50. #else
  51.    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
  52. #endif
  53.    if (png_ptr == NULL)
  54.       return (NULL);
  56. #if !defined(PNG_1_0_X)
  57. #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
  58.    png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
  59. #endif
  60. #endif /* PNG_1_0_X */
  62.    /* added at libpng-1.2.6 */
  63. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  64.    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
  65.    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
  66. #endif
  68. #ifdef PNG_SETJMP_SUPPORTED
  69. #ifdef USE_FAR_KEYWORD
  70.    if (setjmp(jmpbuf))
  71. #else
  72.    if (setjmp(png_ptr->jmpbuf))
  73. #endif
  74.    {
  75.       png_free(png_ptr, png_ptr->zbuf);
  76.       png_ptr->zbuf=NULL;
  77. #ifdef PNG_USER_MEM_SUPPORTED
  78.       png_destroy_struct_2((png_voidp)png_ptr, 
  79.          (png_free_ptr)free_fn, (png_voidp)mem_ptr);
  80. #else
  81.       png_destroy_struct((png_voidp)png_ptr);
  82. #endif
  83.       return (NULL);
  84.    }
  85. #ifdef USE_FAR_KEYWORD
  86.    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
  87. #endif
  88. #endif
  90. #ifdef PNG_USER_MEM_SUPPORTED
  91.    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
  92. #endif
  94.    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
  96.    i=0;
  97.    do
  98.    {
  99.      if(user_png_ver[i] != png_libpng_ver[i])
  100.         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  101.    } while (png_libpng_ver[i++]);
  103.    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
  104.    {
  105.      /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
  106.       * we must recompile any applications that use any older library version.
  107.       * For versions after libpng 1.0, we will be compatible, so we need
  108.       * only check the first digit.
  109.       */
  110.      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
  111.          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
  112.          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
  113.      {
  114. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  115.         char msg[80];
  116.         if (user_png_ver)
  117.         {
  118.           sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
  119.              user_png_ver);
  120.           png_warning(png_ptr, msg);
  121.         }
  122.         sprintf(msg, "Application  is  running with png.c from libpng-%.20s",
  123.            png_libpng_ver);
  124.         png_warning(png_ptr, msg);
  125. #endif
  126. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  127.         png_ptr->flags=0;
  128. #endif
  129.         png_error(png_ptr,
  130.            "Incompatible libpng version in application and library");
  131.      }
  132.    }
  134.    /* initialize zbuf - compression buffer */
  135.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
  136.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
  137.      (png_uint_32)png_ptr->zbuf_size);
  138.    png_ptr->zstream.zalloc = png_zalloc;
  139.    png_ptr->zstream.zfree = png_zfree;
  140.    png_ptr->zstream.opaque = (voidpf)png_ptr;
  142.    switch (inflateInit(&png_ptr->zstream))
  143.    {
  144.      case Z_OK: /* Do nothing */ break;
  145.      case Z_MEM_ERROR:
  146.      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
  147.      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
  148.      default: png_error(png_ptr, "Unknown zlib error");
  149.    }
  151.    png_ptr->zstream.next_out = png_ptr->zbuf;
  152.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  154.    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
  156. #ifdef PNG_SETJMP_SUPPORTED
  157. /* Applications that neglect to set up their own setjmp() and then encounter
  158.    a png_error() will longjmp here.  Since the jmpbuf is then meaningless we
  159.    abort instead of returning. */
  160. #ifdef USE_FAR_KEYWORD
  161.    if (setjmp(jmpbuf))
  162.       PNG_ABORT();
  163.    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));
  164. #else
  165. #if 0
  166.    if (setjmp(png_ptr->jmpbuf))
  167.       PNG_ABORT();
  168. #endif
  169. #endif
  170. #endif
  171.    return (png_ptr);
  172. }
  174. /* Initialize PNG structure for reading, and allocate any memory needed.
  175.    This interface is deprecated in favour of the png_create_read_struct(),
  176.    and it will eventually disappear. */
  177. #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
  178. #undef png_read_init
  179. void PNGAPI
  180. png_read_init(png_structp png_ptr)
  181. {
  182.    /* We only come here via pre-1.0.7-compiled applications */
  183.    png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
  184. }
  185. #endif
  187. void PNGAPI
  188. png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
  189.    png_size_t png_struct_size, png_size_t png_info_size)
  190. {
  191.    /* We only come here via pre-1.0.12-compiled applications */
  192. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  193.    if(png_sizeof(png_struct) > png_struct_size || 
  194.       png_sizeof(png_info) > png_info_size)
  195.    {
  196.       char msg[80];
  197.       png_ptr->warning_fn=NULL;
  198.       if (user_png_ver)
  199.       {
  200.         sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
  201.            user_png_ver);
  202.         png_warning(png_ptr, msg);
  203.       }
  204.       sprintf(msg, "Application  is  running with png.c from libpng-%.20s",
  205.          png_libpng_ver);
  206.       png_warning(png_ptr, msg);
  207.    }
  208. #endif
  209.    if(png_sizeof(png_struct) > png_struct_size)
  210.      {
  211.        png_ptr->error_fn=NULL;
  212. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  213.        png_ptr->flags=0;
  214. #endif
  215.        png_error(png_ptr,
  216.        "The png struct allocated by the application for reading is too small.");
  217.      }
  218.    if(png_sizeof(png_info) > png_info_size)
  219.      {
  220.        png_ptr->error_fn=NULL;
  221. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  222.        png_ptr->flags=0;
  223. #endif
  224.        png_error(png_ptr,
  225.          "The info struct allocated by application for reading is too small.");
  226.      }
  227.    png_read_init_3(&png_ptr, user_png_ver, png_struct_size);
  228. }
  230. void PNGAPI
  231. png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
  232.    png_size_t png_struct_size)
  233. {
  234. #ifdef PNG_SETJMP_SUPPORTED
  235.    jmp_buf tmp_jmp;  /* to save current jump buffer */
  236. #endif
  238.    int i=0;
  240.    png_structp png_ptr=*ptr_ptr;
  242.    do
  243.    {
  244.      if(user_png_ver[i] != png_libpng_ver[i])
  245.      {
  246. #ifdef PNG_LEGACY_SUPPORTED
  247.        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  248. #else
  249.        png_ptr->warning_fn=NULL;
  250.        png_warning(png_ptr,
  251.         "Application uses deprecated png_read_init() and should be recompiled.");
  252.        break;
  253. #endif
  254.      }
  255.    } while (png_libpng_ver[i++]);
  257.    png_debug(1, "in png_read_init_3n");
  259. #ifdef PNG_SETJMP_SUPPORTED
  260.    /* save jump buffer and error functions */
  261.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));
  262. #endif
  264.    if(png_sizeof(png_struct) > png_struct_size)
  265.      {
  266.        png_destroy_struct(png_ptr);
  267.        *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
  268.        png_ptr = *ptr_ptr;
  269.      }
  271.    /* reset all variables to 0 */
  272.    png_memset(png_ptr, 0, png_sizeof (png_struct));
  274. #ifdef PNG_SETJMP_SUPPORTED
  275.    /* restore jump buffer */
  276.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));
  277. #endif
  279.    /* added at libpng-1.2.6 */
  280. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  281.    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
  282.    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
  283. #endif
  285.    /* initialize zbuf - compression buffer */
  286.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
  287.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
  288.      (png_uint_32)png_ptr->zbuf_size);
  289.    png_ptr->zstream.zalloc = png_zalloc;
  290.    png_ptr->zstream.zfree = png_zfree;
  291.    png_ptr->zstream.opaque = (voidpf)png_ptr;
  293.    switch (inflateInit(&png_ptr->zstream))
  294.    {
  295.      case Z_OK: /* Do nothing */ break;
  296.      case Z_MEM_ERROR:
  297.      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
  298.      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
  299.      default: png_error(png_ptr, "Unknown zlib error");
  300.    }
  302.    png_ptr->zstream.next_out = png_ptr->zbuf;
  303.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  305.    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);
  306. }
  308. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  309. /* Read the information before the actual image data.  This has been
  310.  * changed in v0.90 to allow reading a file that already has the magic
  311.  * bytes read from the stream.  You can tell libpng how many bytes have
  312.  * been read from the beginning of the stream (up to the maximum of 8)
  313.  * via png_set_sig_bytes(), and we will only check the remaining bytes
  314.  * here.  The application can then have access to the signature bytes we
  315.  * read if it is determined that this isn't a valid PNG file.
  316.  */
  317. void PNGAPI
  318. png_read_info(png_structp png_ptr, png_infop info_ptr)
  319. {
  320.    png_debug(1, "in png_read_infon");
  321.    /* If we haven't checked all of the PNG signature bytes, do so now. */
  322.    if (png_ptr->sig_bytes < 8)
  323.    {
  324.       png_size_t num_checked = png_ptr->sig_bytes,
  325.                  num_to_check = 8 - num_checked;
  327.       png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
  328.       png_ptr->sig_bytes = 8;
  330.       if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
  331.       {
  332.          if (num_checked < 4 &&
  333.              png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
  334.             png_error(png_ptr, "Not a PNG file");
  335.          else
  336.             png_error(png_ptr, "PNG file corrupted by ASCII conversion");
  337.       }
  338.       if (num_checked < 3)
  339.          png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
  340.    }
  342.    for(;;)
  343.    {
  344. #ifdef PNG_USE_LOCAL_ARRAYS
  345.       PNG_IHDR;
  346.       PNG_IDAT;
  347.       PNG_IEND;
  348.       PNG_PLTE;
  349. #if defined(PNG_READ_bKGD_SUPPORTED)
  350.       PNG_bKGD;
  351. #endif
  352. #if defined(PNG_READ_cHRM_SUPPORTED)
  353.       PNG_cHRM;
  354. #endif
  355. #if defined(PNG_READ_gAMA_SUPPORTED)
  356.       PNG_gAMA;
  357. #endif
  358. #if defined(PNG_READ_hIST_SUPPORTED)
  359.       PNG_hIST;
  360. #endif
  361. #if defined(PNG_READ_iCCP_SUPPORTED)
  362.       PNG_iCCP;
  363. #endif
  364. #if defined(PNG_READ_iTXt_SUPPORTED)
  365.       PNG_iTXt;
  366. #endif
  367. #if defined(PNG_READ_oFFs_SUPPORTED)
  368.       PNG_oFFs;
  369. #endif
  370. #if defined(PNG_READ_pCAL_SUPPORTED)
  371.       PNG_pCAL;
  372. #endif
  373. #if defined(PNG_READ_pHYs_SUPPORTED)
  374.       PNG_pHYs;
  375. #endif
  376. #if defined(PNG_READ_sBIT_SUPPORTED)
  377.       PNG_sBIT;
  378. #endif
  379. #if defined(PNG_READ_sCAL_SUPPORTED)
  380.       PNG_sCAL;
  381. #endif
  382. #if defined(PNG_READ_sPLT_SUPPORTED)
  383.       PNG_sPLT;
  384. #endif
  385. #if defined(PNG_READ_sRGB_SUPPORTED)
  386.       PNG_sRGB;
  387. #endif
  388. #if defined(PNG_READ_tEXt_SUPPORTED)
  389.       PNG_tEXt;
  390. #endif
  391. #if defined(PNG_READ_tIME_SUPPORTED)
  392.       PNG_tIME;
  393. #endif
  394. #if defined(PNG_READ_tRNS_SUPPORTED)
  395.       PNG_tRNS;
  396. #endif
  397. #if defined(PNG_READ_zTXt_SUPPORTED)
  398.       PNG_zTXt;
  399. #endif
  400. #endif /* PNG_USE_LOCAL_ARRAYS */
  401.       png_byte chunk_length[4];
  402.       png_uint_32 length;
  404.       png_read_data(png_ptr, chunk_length, 4);
  405.       length = png_get_uint_31(png_ptr,chunk_length);
  407.       png_reset_crc(png_ptr);
  408.       png_crc_read(png_ptr, png_ptr->chunk_name, 4);
  410.       png_debug2(0, "Reading %s chunk, length=%lu.n", png_ptr->chunk_name,
  411.          length);
  413.       /* This should be a binary subdivision search or a hash for
  414.        * matching the chunk name rather than a linear search.
  415.        */
  416.       if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
  417.          png_handle_IHDR(png_ptr, info_ptr, length);
  418.       else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
  419.          png_handle_IEND(png_ptr, info_ptr, length);
  420. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  421.       else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
  422.       {
  423.          if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  424.             png_ptr->mode |= PNG_HAVE_IDAT;
  425.          png_handle_unknown(png_ptr, info_ptr, length);
  426.          if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  427.             png_ptr->mode |= PNG_HAVE_PLTE;
  428.          else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  429.          {
  430.             if (!(png_ptr->mode & PNG_HAVE_IHDR))
  431.                png_error(png_ptr, "Missing IHDR before IDAT");
  432.             else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  433.                      !(png_ptr->mode & PNG_HAVE_PLTE))
  434.                png_error(png_ptr, "Missing PLTE before IDAT");
  435.             break;
  436.          }
  437.       }
  438. #endif
  439.       else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  440.          png_handle_PLTE(png_ptr, info_ptr, length);
  441.       else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  442.       {
  443.          if (!(png_ptr->mode & PNG_HAVE_IHDR))
  444.             png_error(png_ptr, "Missing IHDR before IDAT");
  445.          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  446.                   !(png_ptr->mode & PNG_HAVE_PLTE))
  447.             png_error(png_ptr, "Missing PLTE before IDAT");
  449.          png_ptr->idat_size = length;
  450.          png_ptr->mode |= PNG_HAVE_IDAT;
  451.          break;
  452.       }
  453. #if defined(PNG_READ_bKGD_SUPPORTED)
  454.       else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
  455.          png_handle_bKGD(png_ptr, info_ptr, length);
  456. #endif
  457. #if defined(PNG_READ_cHRM_SUPPORTED)
  458.       else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
  459.          png_handle_cHRM(png_ptr, info_ptr, length);
  460. #endif
  461. #if defined(PNG_READ_gAMA_SUPPORTED)
  462.       else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
  463.          png_handle_gAMA(png_ptr, info_ptr, length);
  464. #endif
  465. #if defined(PNG_READ_hIST_SUPPORTED)
  466.       else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
  467.          png_handle_hIST(png_ptr, info_ptr, length);
  468. #endif
  469. #if defined(PNG_READ_oFFs_SUPPORTED)
  470.       else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
  471.          png_handle_oFFs(png_ptr, info_ptr, length);
  472. #endif
  473. #if defined(PNG_READ_pCAL_SUPPORTED)
  474.       else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
  475.          png_handle_pCAL(png_ptr, info_ptr, length);
  476. #endif
  477. #if defined(PNG_READ_sCAL_SUPPORTED)
  478.       else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
  479.          png_handle_sCAL(png_ptr, info_ptr, length);
  480. #endif
  481. #if defined(PNG_READ_pHYs_SUPPORTED)
  482.       else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
  483.          png_handle_pHYs(png_ptr, info_ptr, length);
  484. #endif
  485. #if defined(PNG_READ_sBIT_SUPPORTED)
  486.       else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
  487.          png_handle_sBIT(png_ptr, info_ptr, length);
  488. #endif
  489. #if defined(PNG_READ_sRGB_SUPPORTED)
  490.       else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
  491.          png_handle_sRGB(png_ptr, info_ptr, length);
  492. #endif
  493. #if defined(PNG_READ_iCCP_SUPPORTED)
  494.       else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
  495.          png_handle_iCCP(png_ptr, info_ptr, length);
  496. #endif
  497. #if defined(PNG_READ_sPLT_SUPPORTED)
  498.       else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
  499.          png_handle_sPLT(png_ptr, info_ptr, length);
  500. #endif
  501. #if defined(PNG_READ_tEXt_SUPPORTED)
  502.       else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
  503.          png_handle_tEXt(png_ptr, info_ptr, length);
  504. #endif
  505. #if defined(PNG_READ_tIME_SUPPORTED)
  506.       else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
  507.          png_handle_tIME(png_ptr, info_ptr, length);
  508. #endif
  509. #if defined(PNG_READ_tRNS_SUPPORTED)
  510.       else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
  511.          png_handle_tRNS(png_ptr, info_ptr, length);
  512. #endif
  513. #if defined(PNG_READ_zTXt_SUPPORTED)
  514.       else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
  515.          png_handle_zTXt(png_ptr, info_ptr, length);
  516. #endif
  517. #if defined(PNG_READ_iTXt_SUPPORTED)
  518.       else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
  519.          png_handle_iTXt(png_ptr, info_ptr, length);
  520. #endif
  521.       else
  522.          png_handle_unknown(png_ptr, info_ptr, length);
  523.    }
  524. }
  525. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  527. /* optional call to update the users info_ptr structure */
  528. void PNGAPI
  529. png_read_update_info(png_structp png_ptr, png_infop info_ptr)
  530. {
  531.    png_debug(1, "in png_read_update_infon");
  532.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
  533.       png_read_start_row(png_ptr);
  534.    else
  535.       png_warning(png_ptr,
  536.       "Ignoring extra png_read_update_info() call; row buffer not reallocated");
  537.    png_read_transform_info(png_ptr, info_ptr);
  538. }
  540. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  541. /* Initialize palette, background, etc, after transformations
  542.  * are set, but before any reading takes place.  This allows
  543.  * the user to obtain a gamma-corrected palette, for example.
  544.  * If the user doesn't call this, we will do it ourselves.
  545.  */
  546. void PNGAPI
  547. png_start_read_image(png_structp png_ptr)
  548. {
  549.    png_debug(1, "in png_start_read_imagen");
  550.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
  551.       png_read_start_row(png_ptr);
  552. }
  553. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  555. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  556. void PNGAPI
  557. png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
  558. {
  559. #ifdef PNG_USE_LOCAL_ARRAYS
  560.    PNG_IDAT;
  561.    const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
  562.    const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
  563. #endif
  564.    int ret;
  565.    png_debug2(1, "in png_read_row (row %lu, pass %d)n",
  566.       png_ptr->row_number, png_ptr->pass);
  567.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
  568.       png_read_start_row(png_ptr);
  569.    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
  570.    {
  571.    /* check for transforms that have been set but were defined out */
  572. #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
  573.    if (png_ptr->transformations & PNG_INVERT_MONO)
  574.       png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
  575. #endif
  576. #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
  577.    if (png_ptr->transformations & PNG_FILLER)
  578.       png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
  579. #endif
  580. #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
  581.    if (png_ptr->transformations & PNG_PACKSWAP)
  582.       png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
  583. #endif
  584. #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
  585.    if (png_ptr->transformations & PNG_PACK)
  586.       png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
  587. #endif
  588. #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
  589.    if (png_ptr->transformations & PNG_SHIFT)
  590.       png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
  591. #endif
  592. #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
  593.    if (png_ptr->transformations & PNG_BGR)
  594.       png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
  595. #endif
  596. #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
  597.    if (png_ptr->transformations & PNG_SWAP_BYTES)
  598.       png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
  599. #endif
  600.    }
  602. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  603.    /* if interlaced and we do not need a new row, combine row and return */
  604.    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
  605.    {
  606.       switch (png_ptr->pass)
  607.       {
  608.          case 0:
  609.             if (png_ptr->row_number & 0x07)
  610.             {
  611.                if (dsp_row != NULL)
  612.                   png_combine_row(png_ptr, dsp_row,
  613.                      png_pass_dsp_mask[png_ptr->pass]);
  614.                png_read_finish_row(png_ptr);
  615.                return;
  616.             }
  617.             break;
  618.          case 1:
  619.             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
  620.             {
  621.                if (dsp_row != NULL)
  622.                   png_combine_row(png_ptr, dsp_row,
  623.                      png_pass_dsp_mask[png_ptr->pass]);
  624.                png_read_finish_row(png_ptr);
  625.                return;
  626.             }
  627.             break;
  628.          case 2:
  629.             if ((png_ptr->row_number & 0x07) != 4)
  630.             {
  631.                if (dsp_row != NULL && (png_ptr->row_number & 4))
  632.                   png_combine_row(png_ptr, dsp_row,
  633.                      png_pass_dsp_mask[png_ptr->pass]);
  634.                png_read_finish_row(png_ptr);
  635.                return;
  636.             }
  637.             break;
  638.          case 3:
  639.             if ((png_ptr->row_number & 3) || png_ptr->width < 3)
  640.             {
  641.                if (dsp_row != NULL)
  642.                   png_combine_row(png_ptr, dsp_row,
  643.                      png_pass_dsp_mask[png_ptr->pass]);
  644.                png_read_finish_row(png_ptr);
  645.                return;
  646.             }
  647.             break;
  648.          case 4:
  649.             if ((png_ptr->row_number & 3) != 2)
  650.             {
  651.                if (dsp_row != NULL && (png_ptr->row_number & 2))
  652.                   png_combine_row(png_ptr, dsp_row,
  653.                      png_pass_dsp_mask[png_ptr->pass]);
  654.                png_read_finish_row(png_ptr);
  655.                return;
  656.             }
  657.             break;
  658.          case 5:
  659.             if ((png_ptr->row_number & 1) || png_ptr->width < 2)
  660.             {
  661.                if (dsp_row != NULL)
  662.                   png_combine_row(png_ptr, dsp_row,
  663.                      png_pass_dsp_mask[png_ptr->pass]);
  664.                png_read_finish_row(png_ptr);
  665.                return;
  666.             }
  667.             break;
  668.          case 6:
  669.             if (!(png_ptr->row_number & 1))
  670.             {
  671.                png_read_finish_row(png_ptr);
  672.                return;
  673.             }
  674.             break;
  675.       }
  676.    }
  677. #endif
  679.    if (!(png_ptr->mode & PNG_HAVE_IDAT))
  680.       png_error(png_ptr, "Invalid attempt to read row data");
  682.    png_ptr->zstream.next_out = png_ptr->row_buf;
  683.    png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
  684.    do
  685.    {
  686.       if (!(png_ptr->zstream.avail_in))
  687.       {
  688.          while (!png_ptr->idat_size)
  689.          {
  690.             png_byte chunk_length[4];
  692.             png_crc_finish(png_ptr, 0);
  694.             png_read_data(png_ptr, chunk_length, 4);
  695.             png_ptr->idat_size = png_get_uint_31(png_ptr,chunk_length);
  697.             png_reset_crc(png_ptr);
  698.             png_crc_read(png_ptr, png_ptr->chunk_name, 4);
  699.             if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  700.                png_error(png_ptr, "Not enough image data");
  701.          }
  702.          png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
  703.          png_ptr->zstream.next_in = png_ptr->zbuf;
  704.          if (png_ptr->zbuf_size > png_ptr->idat_size)
  705.             png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
  706.          png_crc_read(png_ptr, png_ptr->zbuf,
  707.             (png_size_t)png_ptr->zstream.avail_in);
  708.          png_ptr->idat_size -= png_ptr->zstream.avail_in;
  709.       }
  710.       ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
  711.       if (ret == Z_STREAM_END)
  712.       {
  713.          if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
  714.             png_ptr->idat_size)
  715.             png_error(png_ptr, "Extra compressed data");
  716.          png_ptr->mode |= PNG_AFTER_IDAT;
  717.          png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
  718.          break;
  719.       }
  720.       if (ret != Z_OK)
  721.          png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
  722.                    "Decompression error");
  724.    } while (png_ptr->zstream.avail_out);
  726.    png_ptr->row_info.color_type = png_ptr->color_type;
  727.    png_ptr->row_info.width = png_ptr->iwidth;
  728.    png_ptr->row_info.channels = png_ptr->channels;
  729.    png_ptr->row_info.bit_depth = png_ptr->bit_depth;
  730.    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
  731.    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
  732.        png_ptr->row_info.width);
  734.    if(png_ptr->row_buf[0])
  735.    png_read_filter_row(png_ptr, &(png_ptr->row_info),
  736.       png_ptr->row_buf + 1, png_ptr->prev_row + 1,
  737.       (int)(png_ptr->row_buf[0]));
  739.    png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
  740.       png_ptr->rowbytes + 1);
  741.    
  742. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  743.    if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  744.       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
  745.    {
  746.       /* Intrapixel differencing */
  747.       png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
  748.    }
  749. #endif
  752.    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
  753.       png_do_read_transformations(png_ptr);
  755. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  756.    /* blow up interlaced rows to full size */
  757.    if (png_ptr->interlaced &&
  758.       (png_ptr->transformations & PNG_INTERLACE))
  759.    {
  760.       if (png_ptr->pass < 6)
  761. /*       old interface (pre-1.0.9):
  762.          png_do_read_interlace(&(png_ptr->row_info),
  763.             png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
  764.  */
  765.          png_do_read_interlace(png_ptr);
  767.       if (dsp_row != NULL)
  768.          png_combine_row(png_ptr, dsp_row,
  769.             png_pass_dsp_mask[png_ptr->pass]);
  770.       if (row != NULL)
  771.          png_combine_row(png_ptr, row,
  772.             png_pass_mask[png_ptr->pass]);
  773.    }
  774.    else
  775. #endif
  776.    {
  777.       if (row != NULL)
  778.          png_combine_row(png_ptr, row, 0xff);
  779.       if (dsp_row != NULL)
  780.          png_combine_row(png_ptr, dsp_row, 0xff);
  781.    }
  782.    png_read_finish_row(png_ptr);
  784.    if (png_ptr->read_row_fn != NULL)
  785.       (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
  786. }
  787. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  789. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  790. /* Read one or more rows of image data.  If the image is interlaced,
  791.  * and png_set_interlace_handling() has been called, the rows need to
  792.  * contain the contents of the rows from the previous pass.  If the
  793.  * image has alpha or transparency, and png_handle_alpha()[*] has been
  794.  * called, the rows contents must be initialized to the contents of the
  795.  * screen.
  796.  *
  797.  * "row" holds the actual image, and pixels are placed in it
  798.  * as they arrive.  If the image is displayed after each pass, it will
  799.  * appear to "sparkle" in.  "display_row" can be used to display a
  800.  * "chunky" progressive image, with finer detail added as it becomes
  801.  * available.  If you do not want this "chunky" display, you may pass
  802.  * NULL for display_row.  If you do not want the sparkle display, and
  803.  * you have not called png_handle_alpha(), you may pass NULL for rows.
  804.  * If you have called png_handle_alpha(), and the image has either an
  805.  * alpha channel or a transparency chunk, you must provide a buffer for
  806.  * rows.  In this case, you do not have to provide a display_row buffer
  807.  * also, but you may.  If the image is not interlaced, or if you have
  808.  * not called png_set_interlace_handling(), the display_row buffer will
  809.  * be ignored, so pass NULL to it.
  810.  *
  811.  * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.8
  812.  */
  814. void PNGAPI
  815. png_read_rows(png_structp png_ptr, png_bytepp row,
  816.    png_bytepp display_row, png_uint_32 num_rows)
  817. {
  818.    png_uint_32 i;
  819.    png_bytepp rp;
  820.    png_bytepp dp;
  822.    png_debug(1, "in png_read_rowsn");
  823.    rp = row;
  824.    dp = display_row;
  825.    if (rp != NULL && dp != NULL)
  826.       for (i = 0; i < num_rows; i++)
  827.       {
  828.          png_bytep rptr = *rp++;
  829.          png_bytep dptr = *dp++;
  831.          png_read_row(png_ptr, rptr, dptr);
  832.       }
  833.    else if(rp != NULL)
  834.       for (i = 0; i < num_rows; i++)
  835.       {
  836.          png_bytep rptr = *rp;
  837.          png_read_row(png_ptr, rptr, png_bytep_NULL);
  838.          rp++;
  839.       }
  840.    else if(dp != NULL)
  841.       for (i = 0; i < num_rows; i++)
  842.       {
  843.          png_bytep dptr = *dp;
  844.          png_read_row(png_ptr, png_bytep_NULL, dptr);
  845.          dp++;
  846.       }
  847. }
  848. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  850. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  851. /* Read the entire image.  If the image has an alpha channel or a tRNS
  852.  * chunk, and you have called png_handle_alpha()[*], you will need to
  853.  * initialize the image to the current image that PNG will be overlaying.
  854.  * We set the num_rows again here, in case it was incorrectly set in
  855.  * png_read_start_row() by a call to png_read_update_info() or
  856.  * png_start_read_image() if png_set_interlace_handling() wasn't called
  857.  * prior to either of these functions like it should have been.  You can
  858.  * only call this function once.  If you desire to have an image for
  859.  * each pass of a interlaced image, use png_read_rows() instead.
  860.  *
  861.  * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.8
  862.  */
  863. void PNGAPI
  864. png_read_image(png_structp png_ptr, png_bytepp image)
  865. {
  866.    png_uint_32 i,image_height;
  867.    int pass, j;
  868.    png_bytepp rp;
  870.    png_debug(1, "in png_read_imagen");
  872. #ifdef PNG_READ_INTERLACING_SUPPORTED
  873.    pass = png_set_interlace_handling(png_ptr);
  874. #else
  875.    if (png_ptr->interlaced)
  876.       png_error(png_ptr,
  877.         "Cannot read interlaced image -- interlace handler disabled.");
  878.    pass = 1;
  879. #endif
  882.    image_height=png_ptr->height;
  883.    png_ptr->num_rows = image_height; /* Make sure this is set correctly */
  885.    for (j = 0; j < pass; j++)
  886.    {
  887.       rp = image;
  888.       for (i = 0; i < image_height; i++)
  889.       {
  890.          png_read_row(png_ptr, *rp, png_bytep_NULL);
  891.          rp++;
  892.       }
  893.    }
  894. }
  895. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  897. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  898. /* Read the end of the PNG file.  Will not read past the end of the
  899.  * file, will verify the end is accurate, and will read any comments
  900.  * or time information at the end of the file, if info is not NULL.
  901.  */
  902. void PNGAPI
  903. png_read_end(png_structp png_ptr, png_infop info_ptr)
  904. {
  905.    png_byte chunk_length[4];
  906.    png_uint_32 length;
  908.    png_debug(1, "in png_read_endn");
  909.    png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
  911.    do
  912.    {
  913. #ifdef PNG_USE_LOCAL_ARRAYS
  914.       PNG_IHDR;
  915.       PNG_IDAT;
  916.       PNG_IEND;
  917.       PNG_PLTE;
  918. #if defined(PNG_READ_bKGD_SUPPORTED)
  919.       PNG_bKGD;
  920. #endif
  921. #if defined(PNG_READ_cHRM_SUPPORTED)
  922.       PNG_cHRM;
  923. #endif
  924. #if defined(PNG_READ_gAMA_SUPPORTED)
  925.       PNG_gAMA;
  926. #endif
  927. #if defined(PNG_READ_hIST_SUPPORTED)
  928.       PNG_hIST;
  929. #endif
  930. #if defined(PNG_READ_iCCP_SUPPORTED)
  931.       PNG_iCCP;
  932. #endif
  933. #if defined(PNG_READ_iTXt_SUPPORTED)
  934.       PNG_iTXt;
  935. #endif
  936. #if defined(PNG_READ_oFFs_SUPPORTED)
  937.       PNG_oFFs;
  938. #endif
  939. #if defined(PNG_READ_pCAL_SUPPORTED)
  940.       PNG_pCAL;
  941. #endif
  942. #if defined(PNG_READ_pHYs_SUPPORTED)
  943.       PNG_pHYs;
  944. #endif
  945. #if defined(PNG_READ_sBIT_SUPPORTED)
  946.       PNG_sBIT;
  947. #endif
  948. #if defined(PNG_READ_sCAL_SUPPORTED)
  949.       PNG_sCAL;
  950. #endif
  951. #if defined(PNG_READ_sPLT_SUPPORTED)
  952.       PNG_sPLT;
  953. #endif
  954. #if defined(PNG_READ_sRGB_SUPPORTED)
  955.       PNG_sRGB;
  956. #endif
  957. #if defined(PNG_READ_tEXt_SUPPORTED)
  958.       PNG_tEXt;
  959. #endif
  960. #if defined(PNG_READ_tIME_SUPPORTED)
  961.       PNG_tIME;
  962. #endif
  963. #if defined(PNG_READ_tRNS_SUPPORTED)
  964.       PNG_tRNS;
  965. #endif
  966. #if defined(PNG_READ_zTXt_SUPPORTED)
  967.       PNG_zTXt;
  968. #endif
  969. #endif /* PNG_USE_LOCAL_ARRAYS */
  971.       png_read_data(png_ptr, chunk_length, 4);
  972.       length = png_get_uint_31(png_ptr,chunk_length);
  974.       png_reset_crc(png_ptr);
  975.       png_crc_read(png_ptr, png_ptr->chunk_name, 4);
  977.       png_debug1(0, "Reading %s chunk.n", png_ptr->chunk_name);
  979.       if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
  980.          png_handle_IHDR(png_ptr, info_ptr, length);
  981.       else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
  982.          png_handle_IEND(png_ptr, info_ptr, length);
  983. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  984.       else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
  985.       {
  986.          if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  987.          {
  988.             if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
  989.                png_error(png_ptr, "Too many IDAT's found");
  990.          }
  991.          else
  992.             png_ptr->mode |= PNG_AFTER_IDAT;
  993.          png_handle_unknown(png_ptr, info_ptr, length);
  994.          if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  995.             png_ptr->mode |= PNG_HAVE_PLTE;
  996.       }
  997. #endif
  998.       else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  999.       {
  1000.          /* Zero length IDATs are legal after the last IDAT has been
  1001.           * read, but not after other chunks have been read.
  1002.           */
  1003.          if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
  1004.             png_error(png_ptr, "Too many IDAT's found");
  1005.          png_crc_finish(png_ptr, length);
  1006.       }
  1007.       else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  1008.          png_handle_PLTE(png_ptr, info_ptr, length);
  1009. #if defined(PNG_READ_bKGD_SUPPORTED)
  1010.       else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
  1011.          png_handle_bKGD(png_ptr, info_ptr, length);
  1012. #endif
  1013. #if defined(PNG_READ_cHRM_SUPPORTED)
  1014.       else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
  1015.          png_handle_cHRM(png_ptr, info_ptr, length);
  1016. #endif
  1017. #if defined(PNG_READ_gAMA_SUPPORTED)
  1018.       else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
  1019.          png_handle_gAMA(png_ptr, info_ptr, length);
  1020. #endif
  1021. #if defined(PNG_READ_hIST_SUPPORTED)
  1022.       else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
  1023.          png_handle_hIST(png_ptr, info_ptr, length);
  1024. #endif
  1025. #if defined(PNG_READ_oFFs_SUPPORTED)
  1026.       else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
  1027.          png_handle_oFFs(png_ptr, info_ptr, length);
  1028. #endif
  1029. #if defined(PNG_READ_pCAL_SUPPORTED)
  1030.       else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
  1031.          png_handle_pCAL(png_ptr, info_ptr, length);
  1032. #endif
  1033. #if defined(PNG_READ_sCAL_SUPPORTED)
  1034.       else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
  1035.          png_handle_sCAL(png_ptr, info_ptr, length);
  1036. #endif
  1037. #if defined(PNG_READ_pHYs_SUPPORTED)
  1038.       else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
  1039.          png_handle_pHYs(png_ptr, info_ptr, length);
  1040. #endif
  1041. #if defined(PNG_READ_sBIT_SUPPORTED)
  1042.       else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
  1043.          png_handle_sBIT(png_ptr, info_ptr, length);
  1044. #endif
  1045. #if defined(PNG_READ_sRGB_SUPPORTED)
  1046.       else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
  1047.          png_handle_sRGB(png_ptr, info_ptr, length);
  1048. #endif
  1049. #if defined(PNG_READ_iCCP_SUPPORTED)
  1050.       else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
  1051.          png_handle_iCCP(png_ptr, info_ptr, length);
  1052. #endif
  1053. #if defined(PNG_READ_sPLT_SUPPORTED)
  1054.       else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
  1055.          png_handle_sPLT(png_ptr, info_ptr, length);
  1056. #endif
  1057. #if defined(PNG_READ_tEXt_SUPPORTED)
  1058.       else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
  1059.          png_handle_tEXt(png_ptr, info_ptr, length);
  1060. #endif
  1061. #if defined(PNG_READ_tIME_SUPPORTED)
  1062.       else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
  1063.          png_handle_tIME(png_ptr, info_ptr, length);
  1064. #endif
  1065. #if defined(PNG_READ_tRNS_SUPPORTED)
  1066.       else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
  1067.          png_handle_tRNS(png_ptr, info_ptr, length);
  1068. #endif
  1069. #if defined(PNG_READ_zTXt_SUPPORTED)
  1070.       else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
  1071.          png_handle_zTXt(png_ptr, info_ptr, length);
  1072. #endif
  1073. #if defined(PNG_READ_iTXt_SUPPORTED)
  1074.       else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
  1075.          png_handle_iTXt(png_ptr, info_ptr, length);
  1076. #endif
  1077.       else
  1078.          png_handle_unknown(png_ptr, info_ptr, length);
  1079.    } while (!(png_ptr->mode & PNG_HAVE_IEND));
  1080. }
  1081. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
  1083. /* free all memory used by the read */
  1084. void PNGAPI
  1085. png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
  1086.    png_infopp end_info_ptr_ptr)
  1087. {
  1088.    png_structp png_ptr = NULL;
  1089.    png_infop info_ptr = NULL, end_info_ptr = NULL;
  1090. #ifdef PNG_USER_MEM_SUPPORTED
  1091.    png_free_ptr free_fn;
  1092.    png_voidp mem_ptr;
  1093. #endif
  1095.    png_debug(1, "in png_destroy_read_structn");
  1096.    if (png_ptr_ptr != NULL)
  1097.       png_ptr = *png_ptr_ptr;
  1099.    if (info_ptr_ptr != NULL)
  1100.       info_ptr = *info_ptr_ptr;
  1102.    if (end_info_ptr_ptr != NULL)
  1103.       end_info_ptr = *end_info_ptr_ptr;
  1105. #ifdef PNG_USER_MEM_SUPPORTED
  1106.    free_fn = png_ptr->free_fn;
  1107.    mem_ptr = png_ptr->mem_ptr;
  1108. #endif
  1110.    png_read_destroy(png_ptr, info_ptr, end_info_ptr);
  1112.    if (info_ptr != NULL)
  1113.    {
  1114. #if defined(PNG_TEXT_SUPPORTED)
  1115.       png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
  1116. #endif
  1118. #ifdef PNG_USER_MEM_SUPPORTED
  1119.       png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
  1120.           (png_voidp)mem_ptr);
  1121. #else
  1122.       png_destroy_struct((png_voidp)info_ptr);
  1123. #endif
  1124.       *info_ptr_ptr = NULL;
  1125.    }
  1127.    if (end_info_ptr != NULL)
  1128.    {
  1129. #if defined(PNG_READ_TEXT_SUPPORTED)
  1130.       png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
  1131. #endif
  1132. #ifdef PNG_USER_MEM_SUPPORTED
  1133.       png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
  1134.          (png_voidp)mem_ptr);
  1135. #else
  1136.       png_destroy_struct((png_voidp)end_info_ptr);
  1137. #endif
  1138.       *end_info_ptr_ptr = NULL;
  1139.    }
  1141.    if (png_ptr != NULL)
  1142.    {
  1143. #ifdef PNG_USER_MEM_SUPPORTED
  1144.       png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
  1145.           (png_voidp)mem_ptr);
  1146. #else
  1147.       png_destroy_struct((png_voidp)png_ptr);
  1148. #endif
  1149.       *png_ptr_ptr = NULL;
  1150.    }
  1151. }
  1153. /* free all memory used by the read (old method) */
  1154. void /* PRIVATE */
  1155. png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
  1156. {
  1157. #ifdef PNG_SETJMP_SUPPORTED
  1158.    jmp_buf tmp_jmp;
  1159. #endif
  1160.    png_error_ptr error_fn;
  1161.    png_error_ptr warning_fn;
  1162.    png_voidp error_ptr;
  1163. #ifdef PNG_USER_MEM_SUPPORTED
  1164.    png_free_ptr free_fn;
  1165. #endif
  1167.    png_debug(1, "in png_read_destroyn");
  1168.    if (info_ptr != NULL)
  1169.       png_info_destroy(png_ptr, info_ptr);
  1171.    if (end_info_ptr != NULL)
  1172.       png_info_destroy(png_ptr, end_info_ptr);
  1174.    png_free(png_ptr, png_ptr->zbuf);
  1175.    png_free(png_ptr, png_ptr->big_row_buf);
  1176.    png_free(png_ptr, png_ptr->prev_row);
  1177. #if defined(PNG_READ_DITHER_SUPPORTED)
  1178.    png_free(png_ptr, png_ptr->palette_lookup);
  1179.    png_free(png_ptr, png_ptr->dither_index);
  1180. #endif
  1181. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1182.    png_free(png_ptr, png_ptr->gamma_table);
  1183. #endif
  1184. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1185.    png_free(png_ptr, png_ptr->gamma_from_1);
  1186.    png_free(png_ptr, png_ptr->gamma_to_1);
  1187. #endif
  1188. #ifdef PNG_FREE_ME_SUPPORTED
  1189.    if (png_ptr->free_me & PNG_FREE_PLTE)
  1190.       png_zfree(png_ptr, png_ptr->palette);
  1191.    png_ptr->free_me &= ~PNG_FREE_PLTE;
  1192. #else
  1193.    if (png_ptr->flags & PNG_FLAG_FREE_PLTE)
  1194.       png_zfree(png_ptr, png_ptr->palette);
  1195.    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
  1196. #endif
  1197. #if defined(PNG_tRNS_SUPPORTED) || 
  1198.     defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
  1199. #ifdef PNG_FREE_ME_SUPPORTED
  1200.    if (png_ptr->free_me & PNG_FREE_TRNS)
  1201.       png_free(png_ptr, png_ptr->trans);
  1202.    png_ptr->free_me &= ~PNG_FREE_TRNS;
  1203. #else
  1204.    if (png_ptr->flags & PNG_FLAG_FREE_TRNS)
  1205.       png_free(png_ptr, png_ptr->trans);
  1206.    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
  1207. #endif
  1208. #endif
  1209. #if defined(PNG_READ_hIST_SUPPORTED)
  1210. #ifdef PNG_FREE_ME_SUPPORTED
  1211.    if (png_ptr->free_me & PNG_FREE_HIST)
  1212.       png_free(png_ptr, png_ptr->hist);
  1213.    png_ptr->free_me &= ~PNG_FREE_HIST;
  1214. #else
  1215.    if (png_ptr->flags & PNG_FLAG_FREE_HIST)
  1216.       png_free(png_ptr, png_ptr->hist);
  1217.    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
  1218. #endif
  1219. #endif
  1220. #if defined(PNG_READ_GAMMA_SUPPORTED)
  1221.    if (png_ptr->gamma_16_table != NULL)
  1222.    {
  1223.       int i;
  1224.       int istop = (1 << (8 - png_ptr->gamma_shift));
  1225.       for (i = 0; i < istop; i++)
  1226.       {
  1227.          png_free(png_ptr, png_ptr->gamma_16_table[i]);
  1228.       }
  1229.    png_free(png_ptr, png_ptr->gamma_16_table);
  1230.    }
  1231. #if defined(PNG_READ_BACKGROUND_SUPPORTED)
  1232.    if (png_ptr->gamma_16_from_1 != NULL)
  1233.    {
  1234.       int i;
  1235.       int istop = (1 << (8 - png_ptr->gamma_shift));
  1236.       for (i = 0; i < istop; i++)
  1237.       {
  1238.          png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
  1239.       }
  1240.    png_free(png_ptr, png_ptr->gamma_16_from_1);
  1241.    }
  1242.    if (png_ptr->gamma_16_to_1 != NULL)
  1243.    {
  1244.       int i;
  1245.       int istop = (1 << (8 - png_ptr->gamma_shift));
  1246.       for (i = 0; i < istop; i++)
  1247.       {
  1248.          png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
  1249.       }
  1250.    png_free(png_ptr, png_ptr->gamma_16_to_1);
  1251.    }
  1252. #endif
  1253. #endif
  1254. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  1255.    png_free(png_ptr, png_ptr->time_buffer);
  1256. #endif
  1258.    inflateEnd(&png_ptr->zstream);
  1259. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  1260.    png_free(png_ptr, png_ptr->save_buffer);
  1261. #endif
  1263. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  1264. #ifdef PNG_TEXT_SUPPORTED
  1265.    png_free(png_ptr, png_ptr->current_text);
  1266. #endif /* PNG_TEXT_SUPPORTED */
  1267. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
  1269.    /* Save the important info out of the png_struct, in case it is
  1270.     * being used again.
  1271.     */
  1272. #ifdef PNG_SETJMP_SUPPORTED
  1273.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));
  1274. #endif
  1276.    error_fn = png_ptr->error_fn;
  1277.    warning_fn = png_ptr->warning_fn;
  1278.    error_ptr = png_ptr->error_ptr;
  1279. #ifdef PNG_USER_MEM_SUPPORTED
  1280.    free_fn = png_ptr->free_fn;
  1281. #endif
  1283.    png_memset(png_ptr, 0, png_sizeof (png_struct));
  1285.    png_ptr->error_fn = error_fn;
  1286.    png_ptr->warning_fn = warning_fn;
  1287.    png_ptr->error_ptr = error_ptr;
  1288. #ifdef PNG_USER_MEM_SUPPORTED
  1289.    png_ptr->free_fn = free_fn;
  1290. #endif
  1292. #ifdef PNG_SETJMP_SUPPORTED
  1293.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));
  1294. #endif
  1296. }
  1298. void PNGAPI
  1299. png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
  1300. {
  1301.    png_ptr->read_row_fn = read_row_fn;
  1302. }
  1305. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
  1306. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  1307. void PNGAPI
  1308. png_read_png(png_structp png_ptr, png_infop info_ptr,
  1309.                            int transforms,
  1310.                            voidp params)
  1311. {
  1312.    int row;
  1314. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
  1315.    /* invert the alpha channel from opacity to transparency
  1316.     */
  1317.    if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
  1318.        png_set_invert_alpha(png_ptr);
  1319. #endif
  1321.    /* png_read_info() gives us all of the information from the
  1322.     * PNG file before the first IDAT (image data chunk).
  1323.     */
  1324.    png_read_info(png_ptr, info_ptr);
  1325.    if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
  1326.       png_error(png_ptr,"Image is too high to process with png_read_png()");
  1328.    /* -------------- image transformations start here ------------------- */
  1330. #if defined(PNG_READ_16_TO_8_SUPPORTED)
  1331.    /* tell libpng to strip 16 bit/color files down to 8 bits per color
  1332.     */
  1333.    if (transforms & PNG_TRANSFORM_STRIP_16)
  1334.        png_set_strip_16(png_ptr);
  1335. #endif
  1337. #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  1338.    /* Strip alpha bytes from the input data without combining with
  1339.     * the background (not recommended).
  1340.     */
  1341.    if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
  1342.        png_set_strip_alpha(png_ptr);
  1343. #endif
  1345. #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
  1346.    /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
  1347.     * byte into separate bytes (useful for paletted and grayscale images).
  1348.     */
  1349.    if (transforms & PNG_TRANSFORM_PACKING)
  1350.        png_set_packing(png_ptr);
  1351. #endif
  1353. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  1354.    /* Change the order of packed pixels to least significant bit first
  1355.     * (not useful if you are using png_set_packing).
  1356.     */
  1357.    if (transforms & PNG_TRANSFORM_PACKSWAP)
  1358.        png_set_packswap(png_ptr);
  1359. #endif
  1361. #if defined(PNG_READ_EXPAND_SUPPORTED)
  1362.    /* Expand paletted colors into true RGB triplets
  1363.     * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
  1364.     * Expand paletted or RGB images with transparency to full alpha
  1365.     * channels so the data will be available as RGBA quartets.
  1366.     */
  1367.    if (transforms & PNG_TRANSFORM_EXPAND)
  1368.        if ((png_ptr->bit_depth < 8) ||
  1369.            (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
  1370.            (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
  1371.          png_set_expand(png_ptr);
  1372. #endif
  1374.    /* We don't handle background color or gamma transformation or dithering.
  1375.     */
  1377. #if defined(PNG_READ_INVERT_SUPPORTED)
  1378.    /* invert monochrome files to have 0 as white and 1 as black
  1379.     */
  1380.    if (transforms & PNG_TRANSFORM_INVERT_MONO)
  1381.        png_set_invert_mono(png_ptr);
  1382. #endif
  1384. #if defined(PNG_READ_SHIFT_SUPPORTED)
  1385.    /* If you want to shift the pixel values from the range [0,255] or
  1386.     * [0,65535] to the original [0,7] or [0,31], or whatever range the
  1387.     * colors were originally in:
  1388.     */
  1389.    if ((transforms & PNG_TRANSFORM_SHIFT)
  1390.        && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
  1391.    {
  1392.       png_color_8p sig_bit;
  1394.       png_get_sBIT(png_ptr, info_ptr, &sig_bit);
  1395.       png_set_shift(png_ptr, sig_bit);
  1396.    }
  1397. #endif
  1399. #if defined(PNG_READ_BGR_SUPPORTED)
  1400.    /* flip the RGB pixels to BGR (or RGBA to BGRA)
  1401.     */
  1402.    if (transforms & PNG_TRANSFORM_BGR)
  1403.        png_set_bgr(png_ptr);
  1404. #endif
  1406. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
  1407.    /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
  1408.     */
  1409.    if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
  1410.        png_set_swap_alpha(png_ptr);
  1411. #endif
  1413. #if defined(PNG_READ_SWAP_SUPPORTED)
  1414.    /* swap bytes of 16 bit files to least significant byte first
  1415.     */
  1416.    if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
  1417.        png_set_swap(png_ptr);
  1418. #endif
  1420.    /* We don't handle adding filler bytes */
  1422.    /* Optional call to gamma correct and add the background to the palette
  1423.     * and update info structure.  REQUIRED if you are expecting libpng to
  1424.     * update the palette for you (i.e., you selected such a transform above).
  1425.     */
  1426.    png_read_update_info(png_ptr, info_ptr);
  1428.    /* -------------- image transformations end here ------------------- */
  1430. #ifdef PNG_FREE_ME_SUPPORTED
  1431.    png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
  1432. #endif
  1433.    if(info_ptr->row_pointers == NULL)
  1434.    {
  1435.       info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
  1436.          info_ptr->height * png_sizeof(png_bytep));
  1437. #ifdef PNG_FREE_ME_SUPPORTED
  1438.       info_ptr->free_me |= PNG_FREE_ROWS;
  1439. #endif
  1440.       for (row = 0; row < (int)info_ptr->height; row++)
  1441.       {
  1442.          info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
  1443.             png_get_rowbytes(png_ptr, info_ptr));
  1444.       }
  1445.    }
  1447.    png_read_image(png_ptr, info_ptr->row_pointers);
  1448.    info_ptr->valid |= PNG_INFO_IDAT;
  1450.    /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
  1451.    png_read_end(png_ptr, info_ptr);
  1453.    if(transforms == 0 || params == NULL)
  1454.       /* quiet compiler warnings */ return;
  1456. }
  1457. #endif
  1458. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */