DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2241 Commits
9 Branches
3.0GB
Tree: cd5893d6e8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cd5893d6e8'
${ noResults }
JUCE/modules/juce_graphics/image_formats/pnglib/pngread.c

1473 lines
48KB
Raw Blame History 

  1. 

  2. /* pngread.c - read a PNG file

  3.  *

  4.  * Last changed in libpng 1.2.20 September 7, 2007

  5.  * For conditions of distribution and use, see copyright notice in png.h

  6.  * Copyright (c) 1998-2007 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.  */

  13. 

  14. #define PNG_INTERNAL

  15. #include "png.h"

  16. 

  17. #if defined(PNG_READ_SUPPORTED)

  18. 

  19. /* Create a PNG structure for reading, and allocate any memory needed. */

  20. png_structp PNGAPI

  21. png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,

  22.    png_error_ptr error_fn, png_error_ptr warn_fn)

  23. {

  24. 

  25. #ifdef PNG_USER_MEM_SUPPORTED

  26.    return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

  27.       warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));

  28. }

  29. 

  30. /* Alternate create PNG structure for reading, and allocate any memory needed. */

  31. png_structp PNGAPI

  32. png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

  33.    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

  34.    png_malloc_ptr malloc_fn, png_free_ptr free_fn)

  35. {

  36. #endif /* PNG_USER_MEM_SUPPORTED */

  37. 

  38.    png_structp png_ptr;

  39. 

  40. #ifdef PNG_SETJMP_SUPPORTED

  41. #ifdef USE_FAR_KEYWORD

  42.    jmp_buf jmpbuf;

  43. #endif

  44. #endif

  45. 

  46.    int i;

  47. 

  48.    png_debug(1, "in png_create_read_struct\n");

  49. #ifdef PNG_USER_MEM_SUPPORTED

  50.    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

  51.       (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

  52. #else

  53.    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

  54. #endif

  55.    if (png_ptr == NULL)

  56.       return (NULL);

  57. 

  58.    /* added at libpng-1.2.6 */

  59. #ifdef PNG_SET_USER_LIMITS_SUPPORTED

  60.    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

  61.    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

  62. #endif

  63. 

  64. #ifdef PNG_SETJMP_SUPPORTED

  65. #ifdef USE_FAR_KEYWORD

  66.    if (setjmp(jmpbuf))

  67. #else

  68.    if (setjmp(png_ptr->jmpbuf))

  69. #endif

  70.    {

  71.       png_free(png_ptr, png_ptr->zbuf);

  72.       png_ptr->zbuf=NULL;

  73. #ifdef PNG_USER_MEM_SUPPORTED

  74.       png_destroy_struct_2((png_voidp)png_ptr,

  75.          (png_free_ptr)free_fn, (png_voidp)mem_ptr);

  76. #else

  77.       png_destroy_struct((png_voidp)png_ptr);

  78. #endif

  79.       return (NULL);

  80.    }

  81. #ifdef USE_FAR_KEYWORD

  82.    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

  83. #endif

  84. #endif

  85. 

  86. #ifdef PNG_USER_MEM_SUPPORTED

  87.    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

  88. #endif

  89. 

  90.    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

  91. 

  92.    i=0;

  93.    do

  94.    {

  95.      if(user_png_ver[i] != png_libpng_ver[i])

  96.         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

  97.    } while (png_libpng_ver[i++]);

  98. 

  99.    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)

  100.    {

  101.      /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

  102.       * we must recompile any applications that use any older library version.

  103.       * For versions after libpng 1.0, we will be compatible, so we need

  104.       * only check the first digit.

  105.       */

  106.      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

  107.          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||

  108.          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

  109.      {

  110. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

  111.         char msg[80];

  112.         if (user_png_ver)

  113.         {

  114.           png_snprintf(msg, 80,

  115.              "Application was compiled with png.h from libpng-%.20s",

  116.              user_png_ver);

  117.           png_warning(png_ptr, msg);

  118.         }

  119.         png_snprintf(msg, 80,

  120.              "Application  is  running with png.c from libpng-%.20s",

  121.            png_libpng_ver);

  122.         png_warning(png_ptr, msg);

  123. #endif

  124. #ifdef PNG_ERROR_NUMBERS_SUPPORTED

  125.         png_ptr->flags=0;

  126. #endif

  127.         png_error(png_ptr,

  128.            "Incompatible libpng version in application and library");

  129.      }

  130.    }

  131. 

  132.    /* initialize zbuf - compression buffer */

  133.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;

  134.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

  135.      (png_uint_32)png_ptr->zbuf_size);

  136.    png_ptr->zstream.zalloc = png_zalloc;

  137.    png_ptr->zstream.zfree = png_zfree;

  138.    png_ptr->zstream.opaque = (voidpf)png_ptr;

  139. 

  140.    switch (inflateInit(&png_ptr->zstream))

  141.    {

  142.      case Z_OK: /* Do nothing */ break;

  143.      case Z_MEM_ERROR:

  144.      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;

  145.      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;

  146.      default: png_error(png_ptr, "Unknown zlib error");

  147.    }

  148. 

  149.    png_ptr->zstream.next_out = png_ptr->zbuf;

  150.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

  151. 

  152.    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

  153. 

  154. #ifdef PNG_SETJMP_SUPPORTED

  155. /* Applications that neglect to set up their own setjmp() and then encounter

  156.    a png_error() will longjmp here.  Since the jmpbuf is then meaningless we

  157.    abort instead of returning. */

  158. #ifdef USE_FAR_KEYWORD

  159.    if (setjmp(jmpbuf))

  160.       PNG_ABORT();

  161.    png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

  162. #else

  163.    if (setjmp(png_ptr->jmpbuf))

  164.       PNG_ABORT();

  165. #endif

  166. #endif

  167.    return (png_ptr);

  168. }

  169. 

  170. #if defined(PNG_1_0_X) || defined(PNG_1_2_X)

  171. /* Initialize PNG structure for reading, and allocate any memory needed.

  172.    This interface is deprecated in favour of the png_create_read_struct(),

  173.    and it will disappear as of libpng-1.3.0. */

  174. #undef png_read_init

  175. void PNGAPI

  176. png_read_init(png_structp png_ptr)

  177. {

  178.    /* We only come here via pre-1.0.7-compiled applications */

  179.    png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);

  180. }

  181. 

  182. void PNGAPI

  183. png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,

  184.    png_size_t png_struct_size, png_size_t png_info_size)

  185. {

  186.    /* We only come here via pre-1.0.12-compiled applications */

  187.    if(png_ptr == NULL) return;

  188. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

  189.    if(png_sizeof(png_struct) > png_struct_size ||

  190.       png_sizeof(png_info) > png_info_size)

  191.    {

  192.       char msg[80];

  193.       png_ptr->warning_fn=NULL;

  194.       if (user_png_ver)

  195.       {

  196.         png_snprintf(msg, 80,

  197.            "Application was compiled with png.h from libpng-%.20s",

  198.            user_png_ver);

  199.         png_warning(png_ptr, msg);

  200.       }

  201.       png_snprintf(msg, 80,

  202.          "Application  is  running with png.c from libpng-%.20s",

  203.          png_libpng_ver);

  204.       png_warning(png_ptr, msg);

  205.    }

  206. #endif

  207.    if(png_sizeof(png_struct) > png_struct_size)

  208.      {

  209.        png_ptr->error_fn=NULL;

  210. #ifdef PNG_ERROR_NUMBERS_SUPPORTED

  211.        png_ptr->flags=0;

  212. #endif

  213.        png_error(png_ptr,

  214.        "The png struct allocated by the application for reading is too small.");

  215.      }

  216.    if(png_sizeof(png_info) > png_info_size)

  217.      {

  218.        png_ptr->error_fn=NULL;

  219. #ifdef PNG_ERROR_NUMBERS_SUPPORTED

  220.        png_ptr->flags=0;

  221. #endif

  222.        png_error(png_ptr,

  223.          "The info struct allocated by application for reading is too small.");

  224.      }

  225.    png_read_init_3(&png_ptr, user_png_ver, png_struct_size);

  226. }

  227. #endif /* PNG_1_0_X || PNG_1_2_X */

  228. 

  229. void PNGAPI

  230. png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,

  231.    png_size_t png_struct_size)

  232. {

  233. #ifdef PNG_SETJMP_SUPPORTED

  234.    jmp_buf tmp_jmp;  /* to save current jump buffer */

  235. #endif

  236. 

  237.    int i=0;

  238. 

  239.    png_structp png_ptr=*ptr_ptr;

  240. 

  241.    if(png_ptr == NULL) return;

  242. 

  243.    do

  244.    {

  245.      if(user_png_ver[i] != png_libpng_ver[i])

  246.      {

  247. #ifdef PNG_LEGACY_SUPPORTED

  248.        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

  249. #else

  250.        png_ptr->warning_fn=NULL;

  251.        png_warning(png_ptr,

  252.         "Application uses deprecated png_read_init() and should be recompiled.");

  253.        break;

  254. #endif

  255.      }

  256.    } while (png_libpng_ver[i++]);

  257. 

  258.    png_debug(1, "in png_read_init_3\n");

  259. 

  260. #ifdef PNG_SETJMP_SUPPORTED

  261.    /* save jump buffer and error functions */

  262.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

  263. #endif

  264. 

  265.    if(png_sizeof(png_struct) > png_struct_size)

  266.      {

  267.        png_destroy_struct(png_ptr);

  268.        *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

  269.        png_ptr = *ptr_ptr;

  270.      }

  271. 

  272.    /* reset all variables to 0 */

  273.    png_memset(png_ptr, 0, png_sizeof (png_struct));

  274. 

  275. #ifdef PNG_SETJMP_SUPPORTED

  276.    /* restore jump buffer */

  277.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

  278. #endif

  279. 

  280.    /* added at libpng-1.2.6 */

  281. #ifdef PNG_SET_USER_LIMITS_SUPPORTED

  282.    png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

  283.    png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

  284. #endif

  285. 

  286.    /* initialize zbuf - compression buffer */

  287.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;

  288.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

  289.      (png_uint_32)png_ptr->zbuf_size);

  290.    png_ptr->zstream.zalloc = png_zalloc;

  291.    png_ptr->zstream.zfree = png_zfree;

  292.    png_ptr->zstream.opaque = (voidpf)png_ptr;

  293. 

  294.    switch (inflateInit(&png_ptr->zstream))

  295.    {

  296.      case Z_OK: /* Do nothing */ break;

  297.      case Z_MEM_ERROR:

  298.      case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;

  299.      case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;

  300.      default: png_error(png_ptr, "Unknown zlib error");

  301.    }

  302. 

  303.    png_ptr->zstream.next_out = png_ptr->zbuf;

  304.    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

  305. 

  306.    png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

  307. }

  308. 

  309. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  310. /* Read the information before the actual image data.  This has been

  311.  * changed in v0.90 to allow reading a file that already has the magic

  312.  * bytes read from the stream.  You can tell libpng how many bytes have

  313.  * been read from the beginning of the stream (up to the maximum of 8)

  314.  * via png_set_sig_bytes(), and we will only check the remaining bytes

  315.  * here.  The application can then have access to the signature bytes we

  316.  * read if it is determined that this isn't a valid PNG file.

  317.  */

  318. void PNGAPI

  319. png_read_info(png_structp png_ptr, png_infop info_ptr)

  320. {

  321.    if(png_ptr == NULL) return;

  322.    png_debug(1, "in png_read_info\n");

  323.    /* If we haven't checked all of the PNG signature bytes, do so now. */

  324.    if (png_ptr->sig_bytes < 8)

  325.    {

  326.       png_size_t num_checked = png_ptr->sig_bytes,

  327.                  num_to_check = 8 - num_checked;

  328. 

  329.       png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

  330.       png_ptr->sig_bytes = 8;

  331. 

  332.       if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

  333.       {

  334.          if (num_checked < 4 &&

  335.              png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

  336.             png_error(png_ptr, "Not a PNG file");

  337.          else

  338.             png_error(png_ptr, "PNG file corrupted by ASCII conversion");

  339.       }

  340.       if (num_checked < 3)

  341.          png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

  342.    }

  343. 

  344.    for(;;)

  345.    {

  346. #ifdef PNG_USE_LOCAL_ARRAYS

  347.       PNG_CONST PNG_IHDR;

  348.       PNG_CONST PNG_IDAT;

  349.       PNG_CONST PNG_IEND;

  350.       PNG_CONST PNG_PLTE;

  351. #if defined(PNG_READ_bKGD_SUPPORTED)

  352.       PNG_CONST PNG_bKGD;

  353. #endif

  354. #if defined(PNG_READ_cHRM_SUPPORTED)

  355.       PNG_CONST PNG_cHRM;

  356. #endif

  357. #if defined(PNG_READ_gAMA_SUPPORTED)

  358.       PNG_CONST PNG_gAMA;

  359. #endif

  360. #if defined(PNG_READ_hIST_SUPPORTED)

  361.       PNG_CONST PNG_hIST;

  362. #endif

  363. #if defined(PNG_READ_iCCP_SUPPORTED)

  364.       PNG_CONST PNG_iCCP;

  365. #endif

  366. #if defined(PNG_READ_iTXt_SUPPORTED)

  367.       PNG_CONST PNG_iTXt;

  368. #endif

  369. #if defined(PNG_READ_oFFs_SUPPORTED)

  370.       PNG_CONST PNG_oFFs;

  371. #endif

  372. #if defined(PNG_READ_pCAL_SUPPORTED)

  373.       PNG_CONST PNG_pCAL;

  374. #endif

  375. #if defined(PNG_READ_pHYs_SUPPORTED)

  376.       PNG_CONST PNG_pHYs;

  377. #endif

  378. #if defined(PNG_READ_sBIT_SUPPORTED)

  379.       PNG_CONST PNG_sBIT;

  380. #endif

  381. #if defined(PNG_READ_sCAL_SUPPORTED)

  382.       PNG_CONST PNG_sCAL;

  383. #endif

  384. #if defined(PNG_READ_sPLT_SUPPORTED)

  385.       PNG_CONST PNG_sPLT;

  386. #endif

  387. #if defined(PNG_READ_sRGB_SUPPORTED)

  388.       PNG_CONST PNG_sRGB;

  389. #endif

  390. #if defined(PNG_READ_tEXt_SUPPORTED)

  391.       PNG_CONST PNG_tEXt;

  392. #endif

  393. #if defined(PNG_READ_tIME_SUPPORTED)

  394.       PNG_CONST PNG_tIME;

  395. #endif

  396. #if defined(PNG_READ_tRNS_SUPPORTED)

  397.       PNG_CONST PNG_tRNS;

  398. #endif

  399. #if defined(PNG_READ_zTXt_SUPPORTED)

  400.       PNG_CONST PNG_zTXt;

  401. #endif

  402. #endif /* PNG_USE_LOCAL_ARRAYS */

  403.       png_byte chunk_length[4];

  404.       png_uint_32 length;

  405. 

  406.       png_read_data(png_ptr, chunk_length, 4);

  407.       length = png_get_uint_31(png_ptr,chunk_length);

  408. 

  409.       png_reset_crc(png_ptr);

  410.       png_crc_read(png_ptr, png_ptr->chunk_name, 4);

  411. 

  412.       png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name,

  413.          length);

  414. 

  415.       /* This should be a binary subdivision search or a hash for

  416.        * matching the chunk name rather than a linear search.

  417.        */

  418.       if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  419.         if(png_ptr->mode & PNG_AFTER_IDAT)

  420.           png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

  421. 

  422.       if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

  423.          png_handle_IHDR(png_ptr, info_ptr, length);

  424.       else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

  425.          png_handle_IEND(png_ptr, info_ptr, length);

  426. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

  427.       else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

  428.       {

  429.          if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  430.             png_ptr->mode |= PNG_HAVE_IDAT;

  431.          png_handle_unknown(png_ptr, info_ptr, length);

  432.          if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

  433.             png_ptr->mode |= PNG_HAVE_PLTE;

  434.          else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  435.          {

  436.             if (!(png_ptr->mode & PNG_HAVE_IHDR))

  437.                png_error(png_ptr, "Missing IHDR before IDAT");

  438.             else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

  439.                      !(png_ptr->mode & PNG_HAVE_PLTE))

  440.                png_error(png_ptr, "Missing PLTE before IDAT");

  441.             break;

  442.          }

  443.       }

  444. #endif

  445.       else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

  446.          png_handle_PLTE(png_ptr, info_ptr, length);

  447.       else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  448.       {

  449.          if (!(png_ptr->mode & PNG_HAVE_IHDR))

  450.             png_error(png_ptr, "Missing IHDR before IDAT");

  451.          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

  452.                   !(png_ptr->mode & PNG_HAVE_PLTE))

  453.             png_error(png_ptr, "Missing PLTE before IDAT");

  454. 

  455.          png_ptr->idat_size = length;

  456.          png_ptr->mode |= PNG_HAVE_IDAT;

  457.          break;

  458.       }

  459. #if defined(PNG_READ_bKGD_SUPPORTED)

  460.       else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

  461.          png_handle_bKGD(png_ptr, info_ptr, length);

  462. #endif

  463. #if defined(PNG_READ_cHRM_SUPPORTED)

  464.       else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

  465.          png_handle_cHRM(png_ptr, info_ptr, length);

  466. #endif

  467. #if defined(PNG_READ_gAMA_SUPPORTED)

  468.       else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

  469.          png_handle_gAMA(png_ptr, info_ptr, length);

  470. #endif

  471. #if defined(PNG_READ_hIST_SUPPORTED)

  472.       else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

  473.          png_handle_hIST(png_ptr, info_ptr, length);

  474. #endif

  475. #if defined(PNG_READ_oFFs_SUPPORTED)

  476.       else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

  477.          png_handle_oFFs(png_ptr, info_ptr, length);

  478. #endif

  479. #if defined(PNG_READ_pCAL_SUPPORTED)

  480.       else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

  481.          png_handle_pCAL(png_ptr, info_ptr, length);

  482. #endif

  483. #if defined(PNG_READ_sCAL_SUPPORTED)

  484.       else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

  485.          png_handle_sCAL(png_ptr, info_ptr, length);

  486. #endif

  487. #if defined(PNG_READ_pHYs_SUPPORTED)

  488.       else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

  489.          png_handle_pHYs(png_ptr, info_ptr, length);

  490. #endif

  491. #if defined(PNG_READ_sBIT_SUPPORTED)

  492.       else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

  493.          png_handle_sBIT(png_ptr, info_ptr, length);

  494. #endif

  495. #if defined(PNG_READ_sRGB_SUPPORTED)

  496.       else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

  497.          png_handle_sRGB(png_ptr, info_ptr, length);

  498. #endif

  499. #if defined(PNG_READ_iCCP_SUPPORTED)

  500.       else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

  501.          png_handle_iCCP(png_ptr, info_ptr, length);

  502. #endif

  503. #if defined(PNG_READ_sPLT_SUPPORTED)

  504.       else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

  505.          png_handle_sPLT(png_ptr, info_ptr, length);

  506. #endif

  507. #if defined(PNG_READ_tEXt_SUPPORTED)

  508.       else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

  509.          png_handle_tEXt(png_ptr, info_ptr, length);

  510. #endif

  511. #if defined(PNG_READ_tIME_SUPPORTED)

  512.       else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

  513.          png_handle_tIME(png_ptr, info_ptr, length);

  514. #endif

  515. #if defined(PNG_READ_tRNS_SUPPORTED)

  516.       else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

  517.          png_handle_tRNS(png_ptr, info_ptr, length);

  518. #endif

  519. #if defined(PNG_READ_zTXt_SUPPORTED)

  520.       else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

  521.          png_handle_zTXt(png_ptr, info_ptr, length);

  522. #endif

  523. #if defined(PNG_READ_iTXt_SUPPORTED)

  524.       else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

  525.          png_handle_iTXt(png_ptr, info_ptr, length);

  526. #endif

  527.       else

  528.          png_handle_unknown(png_ptr, info_ptr, length);

  529.    }

  530. }

  531. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  532. 

  533. /* optional call to update the users info_ptr structure */

  534. void PNGAPI

  535. png_read_update_info(png_structp png_ptr, png_infop info_ptr)

  536. {

  537.    png_debug(1, "in png_read_update_info\n");

  538.    if(png_ptr == NULL) return;

  539.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

  540.       png_read_start_row(png_ptr);

  541.    else

  542.       png_warning(png_ptr,

  543.       "Ignoring extra png_read_update_info() call; row buffer not reallocated");

  544.    png_read_transform_info(png_ptr, info_ptr);

  545. }

  546. 

  547. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  548. /* Initialize palette, background, etc, after transformations

  549.  * are set, but before any reading takes place.  This allows

  550.  * the user to obtain a gamma-corrected palette, for example.

  551.  * If the user doesn't call this, we will do it ourselves.

  552.  */

  553. void PNGAPI

  554. png_start_read_image(png_structp png_ptr)

  555. {

  556.    png_debug(1, "in png_start_read_image\n");

  557.    if(png_ptr == NULL) return;

  558.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

  559.       png_read_start_row(png_ptr);

  560. }

  561. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  562. 

  563. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  564. void PNGAPI

  565. png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)

  566. {

  567. #ifdef PNG_USE_LOCAL_ARRAYS

  568.    PNG_CONST PNG_IDAT;

  569.    PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,

  570.      0xff};

  571.    PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

  572. #endif

  573.    int ret;

  574.    if(png_ptr == NULL) return;

  575.    png_debug2(1, "in png_read_row (row %lu, pass %d)\n",

  576.       png_ptr->row_number, png_ptr->pass);

  577.    if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

  578.       png_read_start_row(png_ptr);

  579.    if (png_ptr->row_number == 0 && png_ptr->pass == 0)

  580.    {

  581.    /* check for transforms that have been set but were defined out */

  582. #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)

  583.    if (png_ptr->transformations & PNG_INVERT_MONO)

  584.       png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");

  585. #endif

  586. #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)

  587.    if (png_ptr->transformations & PNG_FILLER)

  588.       png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");

  589. #endif

  590. #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)

  591.    if (png_ptr->transformations & PNG_PACKSWAP)

  592.       png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");

  593. #endif

  594. #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)

  595.    if (png_ptr->transformations & PNG_PACK)

  596.       png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");

  597. #endif

  598. #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)

  599.    if (png_ptr->transformations & PNG_SHIFT)

  600.       png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");

  601. #endif

  602. #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)

  603.    if (png_ptr->transformations & PNG_BGR)

  604.       png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");

  605. #endif

  606. #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)

  607.    if (png_ptr->transformations & PNG_SWAP_BYTES)

  608.       png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");

  609. #endif

  610.    }

  611. 

  612. #if defined(PNG_READ_INTERLACING_SUPPORTED)

  613.    /* if interlaced and we do not need a new row, combine row and return */

  614.    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

  615.    {

  616.       switch (png_ptr->pass)

  617.       {

  618.          case 0:

  619.             if (png_ptr->row_number & 0x07)

  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 1:

  629.             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

  630.             {

  631.                if (dsp_row != NULL)

  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 2:

  639.             if ((png_ptr->row_number & 0x07) != 4)

  640.             {

  641.                if (dsp_row != NULL && (png_ptr->row_number & 4))

  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 3:

  649.             if ((png_ptr->row_number & 3) || png_ptr->width < 3)

  650.             {

  651.                if (dsp_row != NULL)

  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 4:

  659.             if ((png_ptr->row_number & 3) != 2)

  660.             {

  661.                if (dsp_row != NULL && (png_ptr->row_number & 2))

  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 5:

  669.             if ((png_ptr->row_number & 1) || png_ptr->width < 2)

  670.             {

  671.                if (dsp_row != NULL)

  672.                   png_combine_row(png_ptr, dsp_row,

  673.                      png_pass_dsp_mask[png_ptr->pass]);

  674.                png_read_finish_row(png_ptr);

  675.                return;

  676.             }

  677.             break;

  678.          case 6:

  679.             if (!(png_ptr->row_number & 1))

  680.             {

  681.                png_read_finish_row(png_ptr);

  682.                return;

  683.             }

  684.             break;

  685.       }

  686.    }

  687. #endif

  688. 

  689.    if (!(png_ptr->mode & PNG_HAVE_IDAT))

  690.       png_error(png_ptr, "Invalid attempt to read row data");

  691. 

  692.    png_ptr->zstream.next_out = png_ptr->row_buf;

  693.    png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

  694.    do

  695.    {

  696.       if (!(png_ptr->zstream.avail_in))

  697.       {

  698.          while (!png_ptr->idat_size)

  699.          {

  700.             png_byte chunk_length[4];

  701. 

  702.             png_crc_finish(png_ptr, 0);

  703. 

  704.             png_read_data(png_ptr, chunk_length, 4);

  705.             png_ptr->idat_size = png_get_uint_31(png_ptr,chunk_length);

  706. 

  707.             png_reset_crc(png_ptr);

  708.             png_crc_read(png_ptr, png_ptr->chunk_name, 4);

  709.             if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  710.                png_error(png_ptr, "Not enough image data");

  711.          }

  712.          png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

  713.          png_ptr->zstream.next_in = png_ptr->zbuf;

  714.          if (png_ptr->zbuf_size > png_ptr->idat_size)

  715.             png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

  716.          png_crc_read(png_ptr, png_ptr->zbuf,

  717.             (png_size_t)png_ptr->zstream.avail_in);

  718.          png_ptr->idat_size -= png_ptr->zstream.avail_in;

  719.       }

  720.       ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

  721.       if (ret == Z_STREAM_END)

  722.       {

  723.          if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||

  724.             png_ptr->idat_size)

  725.             png_error(png_ptr, "Extra compressed data");

  726.          png_ptr->mode |= PNG_AFTER_IDAT;

  727.          png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

  728.          break;

  729.       }

  730.       if (ret != Z_OK)

  731.          png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

  732.                    "Decompression error");

  733. 

  734.    } while (png_ptr->zstream.avail_out);

  735. 

  736.    png_ptr->row_info.color_type = png_ptr->color_type;

  737.    png_ptr->row_info.width = png_ptr->iwidth;

  738.    png_ptr->row_info.channels = png_ptr->channels;

  739.    png_ptr->row_info.bit_depth = png_ptr->bit_depth;

  740.    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

  741.    png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

  742.        png_ptr->row_info.width);

  743. 

  744.    if(png_ptr->row_buf[0])

  745.    png_read_filter_row(png_ptr, &(png_ptr->row_info),

  746.       png_ptr->row_buf + 1, png_ptr->prev_row + 1,

  747.       (int)(png_ptr->row_buf[0]));

  748. 

  749.    png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,

  750.       png_ptr->rowbytes + 1);

  751. 

  752. #if defined(PNG_MNG_FEATURES_SUPPORTED)

  753.    if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

  754.       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

  755.    {

  756.       /* Intrapixel differencing */

  757.       png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

  758.    }

  759. #endif

  760. 

  761. 

  762.    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

  763.       png_do_read_transformations(png_ptr);

  764. 

  765. #if defined(PNG_READ_INTERLACING_SUPPORTED)

  766.    /* blow up interlaced rows to full size */

  767.    if (png_ptr->interlaced &&

  768.       (png_ptr->transformations & PNG_INTERLACE))

  769.    {

  770.       if (png_ptr->pass < 6)

  771. /*       old interface (pre-1.0.9):

  772.          png_do_read_interlace(&(png_ptr->row_info),

  773.             png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);

  774.  */

  775.          png_do_read_interlace(png_ptr);

  776. 

  777.       if (dsp_row != NULL)

  778.          png_combine_row(png_ptr, dsp_row,

  779.             png_pass_dsp_mask[png_ptr->pass]);

  780.       if (row != NULL)

  781.          png_combine_row(png_ptr, row,

  782.             png_pass_mask[png_ptr->pass]);

  783.    }

  784.    else

  785. #endif

  786.    {

  787.       if (row != NULL)

  788.          png_combine_row(png_ptr, row, 0xff);

  789.       if (dsp_row != NULL)

  790.          png_combine_row(png_ptr, dsp_row, 0xff);

  791.    }

  792.    png_read_finish_row(png_ptr);

  793. 

  794.    if (png_ptr->read_row_fn != NULL)

  795.       (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

  796. }

  797. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  798. 

  799. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  800. /* Read one or more rows of image data.  If the image is interlaced,

  801.  * and png_set_interlace_handling() has been called, the rows need to

  802.  * contain the contents of the rows from the previous pass.  If the

  803.  * image has alpha or transparency, and png_handle_alpha()[*] has been

  804.  * called, the rows contents must be initialized to the contents of the

  805.  * screen.

  806.  *

  807.  * "row" holds the actual image, and pixels are placed in it

  808.  * as they arrive.  If the image is displayed after each pass, it will

  809.  * appear to "sparkle" in.  "display_row" can be used to display a

  810.  * "chunky" progressive image, with finer detail added as it becomes

  811.  * available.  If you do not want this "chunky" display, you may pass

  812.  * NULL for display_row.  If you do not want the sparkle display, and

  813.  * you have not called png_handle_alpha(), you may pass NULL for rows.

  814.  * If you have called png_handle_alpha(), and the image has either an

  815.  * alpha channel or a transparency chunk, you must provide a buffer for

  816.  * rows.  In this case, you do not have to provide a display_row buffer

  817.  * also, but you may.  If the image is not interlaced, or if you have

  818.  * not called png_set_interlace_handling(), the display_row buffer will

  819.  * be ignored, so pass NULL to it.

  820.  *

  821.  * [*] png_handle_alpha() does not exist yet, as of this version of libpng

  822.  */

  823. 

  824. void PNGAPI

  825. png_read_rows(png_structp png_ptr, png_bytepp row,

  826.    png_bytepp display_row, png_uint_32 num_rows)

  827. {

  828.    png_uint_32 i;

  829.    png_bytepp rp;

  830.    png_bytepp dp;

  831. 

  832.    png_debug(1, "in png_read_rows\n");

  833.    if(png_ptr == NULL) return;

  834.    rp = row;

  835.    dp = display_row;

  836.    if (rp != NULL && dp != NULL)

  837.       for (i = 0; i < num_rows; i++)

  838.       {

  839.          png_bytep rptr = *rp++;

  840.          png_bytep dptr = *dp++;

  841. 

  842.          png_read_row(png_ptr, rptr, dptr);

  843.       }

  844.    else if(rp != NULL)

  845.       for (i = 0; i < num_rows; i++)

  846.       {

  847.          png_bytep rptr = *rp;

  848.          png_read_row(png_ptr, rptr, png_bytep_NULL);

  849.          rp++;

  850.       }

  851.    else if(dp != NULL)

  852.       for (i = 0; i < num_rows; i++)

  853.       {

  854.          png_bytep dptr = *dp;

  855.          png_read_row(png_ptr, png_bytep_NULL, dptr);

  856.          dp++;

  857.       }

  858. }

  859. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  860. 

  861. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  862. /* Read the entire image.  If the image has an alpha channel or a tRNS

  863.  * chunk, and you have called png_handle_alpha()[*], you will need to

  864.  * initialize the image to the current image that PNG will be overlaying.

  865.  * We set the num_rows again here, in case it was incorrectly set in

  866.  * png_read_start_row() by a call to png_read_update_info() or

  867.  * png_start_read_image() if png_set_interlace_handling() wasn't called

  868.  * prior to either of these functions like it should have been.  You can

  869.  * only call this function once.  If you desire to have an image for

  870.  * each pass of a interlaced image, use png_read_rows() instead.

  871.  *

  872.  * [*] png_handle_alpha() does not exist yet, as of this version of libpng

  873.  */

  874. void PNGAPI

  875. png_read_image(png_structp png_ptr, png_bytepp image)

  876. {

  877.    png_uint_32 i,image_height;

  878.    int pass, j;

  879.    png_bytepp rp;

  880. 

  881.    png_debug(1, "in png_read_image\n");

  882.    if(png_ptr == NULL) return;

  883. 

  884. #ifdef PNG_READ_INTERLACING_SUPPORTED

  885.    pass = png_set_interlace_handling(png_ptr);

  886. #else

  887.    if (png_ptr->interlaced)

  888.       png_error(png_ptr,

  889.         "Cannot read interlaced image -- interlace handler disabled.");

  890.    pass = 1;

  891. #endif

  892. 

  893. 

  894.    image_height=png_ptr->height;

  895.    png_ptr->num_rows = image_height; /* Make sure this is set correctly */

  896. 

  897.    for (j = 0; j < pass; j++)

  898.    {

  899.       rp = image;

  900.       for (i = 0; i < image_height; i++)

  901.       {

  902.          png_read_row(png_ptr, *rp, png_bytep_NULL);

  903.          rp++;

  904.       }

  905.    }

  906. }

  907. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  908. 

  909. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  910. /* Read the end of the PNG file.  Will not read past the end of the

  911.  * file, will verify the end is accurate, and will read any comments

  912.  * or time information at the end of the file, if info is not NULL.

  913.  */

  914. void PNGAPI

  915. png_read_end(png_structp png_ptr, png_infop info_ptr)

  916. {

  917.    png_byte chunk_length[4];

  918.    png_uint_32 length;

  919. 

  920.    png_debug(1, "in png_read_end\n");

  921.    if(png_ptr == NULL) return;

  922.    png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */

  923. 

  924.    do

  925.    {

  926. #ifdef PNG_USE_LOCAL_ARRAYS

  927.       PNG_CONST PNG_IHDR;

  928.       PNG_CONST PNG_IDAT;

  929.       PNG_CONST PNG_IEND;

  930.       PNG_CONST PNG_PLTE;

  931. #if defined(PNG_READ_bKGD_SUPPORTED)

  932.       PNG_CONST PNG_bKGD;

  933. #endif

  934. #if defined(PNG_READ_cHRM_SUPPORTED)

  935.       PNG_CONST PNG_cHRM;

  936. #endif

  937. #if defined(PNG_READ_gAMA_SUPPORTED)

  938.       PNG_CONST PNG_gAMA;

  939. #endif

  940. #if defined(PNG_READ_hIST_SUPPORTED)

  941.       PNG_CONST PNG_hIST;

  942. #endif

  943. #if defined(PNG_READ_iCCP_SUPPORTED)

  944.       PNG_CONST PNG_iCCP;

  945. #endif

  946. #if defined(PNG_READ_iTXt_SUPPORTED)

  947.       PNG_CONST PNG_iTXt;

  948. #endif

  949. #if defined(PNG_READ_oFFs_SUPPORTED)

  950.       PNG_CONST PNG_oFFs;

  951. #endif

  952. #if defined(PNG_READ_pCAL_SUPPORTED)

  953.       PNG_CONST PNG_pCAL;

  954. #endif

  955. #if defined(PNG_READ_pHYs_SUPPORTED)

  956.       PNG_CONST PNG_pHYs;

  957. #endif

  958. #if defined(PNG_READ_sBIT_SUPPORTED)

  959.       PNG_CONST PNG_sBIT;

  960. #endif

  961. #if defined(PNG_READ_sCAL_SUPPORTED)

  962.       PNG_CONST PNG_sCAL;

  963. #endif

  964. #if defined(PNG_READ_sPLT_SUPPORTED)

  965.       PNG_CONST PNG_sPLT;

  966. #endif

  967. #if defined(PNG_READ_sRGB_SUPPORTED)

  968.       PNG_CONST PNG_sRGB;

  969. #endif

  970. #if defined(PNG_READ_tEXt_SUPPORTED)

  971.       PNG_CONST PNG_tEXt;

  972. #endif

  973. #if defined(PNG_READ_tIME_SUPPORTED)

  974.       PNG_CONST PNG_tIME;

  975. #endif

  976. #if defined(PNG_READ_tRNS_SUPPORTED)

  977.       PNG_CONST PNG_tRNS;

  978. #endif

  979. #if defined(PNG_READ_zTXt_SUPPORTED)

  980.       PNG_CONST PNG_zTXt;

  981. #endif

  982. #endif /* PNG_USE_LOCAL_ARRAYS */

  983. 

  984.       png_read_data(png_ptr, chunk_length, 4);

  985.       length = png_get_uint_31(png_ptr,chunk_length);

  986. 

  987.       png_reset_crc(png_ptr);

  988.       png_crc_read(png_ptr, png_ptr->chunk_name, 4);

  989. 

  990.       png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);

  991. 

  992.       if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

  993.          png_handle_IHDR(png_ptr, info_ptr, length);

  994.       else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

  995.          png_handle_IEND(png_ptr, info_ptr, length);

  996. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

  997.       else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

  998.       {

  999.          if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  1000.          {

  1001.             if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

  1002.                png_error(png_ptr, "Too many IDAT's found");

  1003.          }

  1004.          png_handle_unknown(png_ptr, info_ptr, length);

  1005.          if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

  1006.             png_ptr->mode |= PNG_HAVE_PLTE;

  1007.       }

  1008. #endif

  1009.       else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

  1010.       {

  1011.          /* Zero length IDATs are legal after the last IDAT has been

  1012.           * read, but not after other chunks have been read.

  1013.           */

  1014.          if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))

  1015.             png_error(png_ptr, "Too many IDAT's found");

  1016.          png_crc_finish(png_ptr, length);

  1017.       }

  1018.       else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

  1019.          png_handle_PLTE(png_ptr, info_ptr, length);

  1020. #if defined(PNG_READ_bKGD_SUPPORTED)

  1021.       else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

  1022.          png_handle_bKGD(png_ptr, info_ptr, length);

  1023. #endif

  1024. #if defined(PNG_READ_cHRM_SUPPORTED)

  1025.       else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

  1026.          png_handle_cHRM(png_ptr, info_ptr, length);

  1027. #endif

  1028. #if defined(PNG_READ_gAMA_SUPPORTED)

  1029.       else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

  1030.          png_handle_gAMA(png_ptr, info_ptr, length);

  1031. #endif

  1032. #if defined(PNG_READ_hIST_SUPPORTED)

  1033.       else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

  1034.          png_handle_hIST(png_ptr, info_ptr, length);

  1035. #endif

  1036. #if defined(PNG_READ_oFFs_SUPPORTED)

  1037.       else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

  1038.          png_handle_oFFs(png_ptr, info_ptr, length);

  1039. #endif

  1040. #if defined(PNG_READ_pCAL_SUPPORTED)

  1041.       else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

  1042.          png_handle_pCAL(png_ptr, info_ptr, length);

  1043. #endif

  1044. #if defined(PNG_READ_sCAL_SUPPORTED)

  1045.       else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

  1046.          png_handle_sCAL(png_ptr, info_ptr, length);

  1047. #endif

  1048. #if defined(PNG_READ_pHYs_SUPPORTED)

  1049.       else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

  1050.          png_handle_pHYs(png_ptr, info_ptr, length);

  1051. #endif

  1052. #if defined(PNG_READ_sBIT_SUPPORTED)

  1053.       else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

  1054.          png_handle_sBIT(png_ptr, info_ptr, length);

  1055. #endif

  1056. #if defined(PNG_READ_sRGB_SUPPORTED)

  1057.       else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

  1058.          png_handle_sRGB(png_ptr, info_ptr, length);

  1059. #endif

  1060. #if defined(PNG_READ_iCCP_SUPPORTED)

  1061.       else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

  1062.          png_handle_iCCP(png_ptr, info_ptr, length);

  1063. #endif

  1064. #if defined(PNG_READ_sPLT_SUPPORTED)

  1065.       else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

  1066.          png_handle_sPLT(png_ptr, info_ptr, length);

  1067. #endif

  1068. #if defined(PNG_READ_tEXt_SUPPORTED)

  1069.       else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

  1070.          png_handle_tEXt(png_ptr, info_ptr, length);

  1071. #endif

  1072. #if defined(PNG_READ_tIME_SUPPORTED)

  1073.       else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

  1074.          png_handle_tIME(png_ptr, info_ptr, length);

  1075. #endif

  1076. #if defined(PNG_READ_tRNS_SUPPORTED)

  1077.       else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

  1078.          png_handle_tRNS(png_ptr, info_ptr, length);

  1079. #endif

  1080. #if defined(PNG_READ_zTXt_SUPPORTED)

  1081.       else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

  1082.          png_handle_zTXt(png_ptr, info_ptr, length);

  1083. #endif

  1084. #if defined(PNG_READ_iTXt_SUPPORTED)

  1085.       else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

  1086.          png_handle_iTXt(png_ptr, info_ptr, length);

  1087. #endif

  1088.       else

  1089.          png_handle_unknown(png_ptr, info_ptr, length);

  1090.    } while (!(png_ptr->mode & PNG_HAVE_IEND));

  1091. }

  1092. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  1093. 

  1094. /* free all memory used by the read */

  1095. void PNGAPI

  1096. png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,

  1097.    png_infopp end_info_ptr_ptr)

  1098. {

  1099.    png_structp png_ptr = NULL;

  1100.    png_infop info_ptr = NULL, end_info_ptr = NULL;

  1101. #ifdef PNG_USER_MEM_SUPPORTED

  1102.    png_free_ptr free_fn;

  1103.    png_voidp mem_ptr;

  1104. #endif

  1105. 

  1106.    png_debug(1, "in png_destroy_read_struct\n");

  1107.    if (png_ptr_ptr != NULL)

  1108.       png_ptr = *png_ptr_ptr;

  1109. 

  1110.    if (info_ptr_ptr != NULL)

  1111.       info_ptr = *info_ptr_ptr;

  1112. 

  1113.    if (end_info_ptr_ptr != NULL)

  1114.       end_info_ptr = *end_info_ptr_ptr;

  1115. 

  1116. #ifdef PNG_USER_MEM_SUPPORTED

  1117.    free_fn = png_ptr->free_fn;

  1118.    mem_ptr = png_ptr->mem_ptr;

  1119. #endif

  1120. 

  1121.    png_read_destroy(png_ptr, info_ptr, end_info_ptr);

  1122. 

  1123.    if (info_ptr != NULL)

  1124.    {

  1125. #if defined(PNG_TEXT_SUPPORTED)

  1126.       png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);

  1127. #endif

  1128. 

  1129. #ifdef PNG_USER_MEM_SUPPORTED

  1130.       png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

  1131.           (png_voidp)mem_ptr);

  1132. #else

  1133.       png_destroy_struct((png_voidp)info_ptr);

  1134. #endif

  1135.       *info_ptr_ptr = NULL;

  1136.    }

  1137. 

  1138.    if (end_info_ptr != NULL)

  1139.    {

  1140. #if defined(PNG_READ_TEXT_SUPPORTED)

  1141.       png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);

  1142. #endif

  1143. #ifdef PNG_USER_MEM_SUPPORTED

  1144.       png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,

  1145.          (png_voidp)mem_ptr);

  1146. #else

  1147.       png_destroy_struct((png_voidp)end_info_ptr);

  1148. #endif

  1149.       *end_info_ptr_ptr = NULL;

  1150.    }

  1151. 

  1152.    if (png_ptr != NULL)

  1153.    {

  1154. #ifdef PNG_USER_MEM_SUPPORTED

  1155.       png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,

  1156.           (png_voidp)mem_ptr);

  1157. #else

  1158.       png_destroy_struct((png_voidp)png_ptr);

  1159. #endif

  1160.       *png_ptr_ptr = NULL;

  1161.    }

  1162. }

  1163. 

  1164. /* free all memory used by the read (old method) */

  1165. void /* PRIVATE */

  1166. png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)

  1167. {

  1168. #ifdef PNG_SETJMP_SUPPORTED

  1169.    jmp_buf tmp_jmp;

  1170. #endif

  1171.    png_error_ptr error_fn;

  1172.    png_error_ptr warning_fn;

  1173.    png_voidp error_ptr;

  1174. #ifdef PNG_USER_MEM_SUPPORTED

  1175.    png_free_ptr free_fn;

  1176. #endif

  1177. 

  1178.    png_debug(1, "in png_read_destroy\n");

  1179.    if (info_ptr != NULL)

  1180.       png_info_destroy(png_ptr, info_ptr);

  1181. 

  1182.    if (end_info_ptr != NULL)

  1183.       png_info_destroy(png_ptr, end_info_ptr);

  1184. 

  1185.    png_free(png_ptr, png_ptr->zbuf);

  1186.    png_free(png_ptr, png_ptr->big_row_buf);

  1187.    png_free(png_ptr, png_ptr->prev_row);

  1188. #if defined(PNG_READ_DITHER_SUPPORTED)

  1189.    png_free(png_ptr, png_ptr->palette_lookup);

  1190.    png_free(png_ptr, png_ptr->dither_index);

  1191. #endif

  1192. #if defined(PNG_READ_GAMMA_SUPPORTED)

  1193.    png_free(png_ptr, png_ptr->gamma_table);

  1194. #endif

  1195. #if defined(PNG_READ_BACKGROUND_SUPPORTED)

  1196.    png_free(png_ptr, png_ptr->gamma_from_1);

  1197.    png_free(png_ptr, png_ptr->gamma_to_1);

  1198. #endif

  1199. #ifdef PNG_FREE_ME_SUPPORTED

  1200.    if (png_ptr->free_me & PNG_FREE_PLTE)

  1201.       png_zfree(png_ptr, png_ptr->palette);

  1202.    png_ptr->free_me &= ~PNG_FREE_PLTE;

  1203. #else

  1204.    if (png_ptr->flags & PNG_FLAG_FREE_PLTE)

  1205.       png_zfree(png_ptr, png_ptr->palette);

  1206.    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;

  1207. #endif

  1208. #if defined(PNG_tRNS_SUPPORTED) || \

  1209.     defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

  1210. #ifdef PNG_FREE_ME_SUPPORTED

  1211.    if (png_ptr->free_me & PNG_FREE_TRNS)

  1212.       png_free(png_ptr, png_ptr->trans);

  1213.    png_ptr->free_me &= ~PNG_FREE_TRNS;

  1214. #else

  1215.    if (png_ptr->flags & PNG_FLAG_FREE_TRNS)

  1216.       png_free(png_ptr, png_ptr->trans);

  1217.    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;

  1218. #endif

  1219. #endif

  1220. #if defined(PNG_READ_hIST_SUPPORTED)

  1221. #ifdef PNG_FREE_ME_SUPPORTED

  1222.    if (png_ptr->free_me & PNG_FREE_HIST)

  1223.       png_free(png_ptr, png_ptr->hist);

  1224.    png_ptr->free_me &= ~PNG_FREE_HIST;

  1225. #else

  1226.    if (png_ptr->flags & PNG_FLAG_FREE_HIST)

  1227.       png_free(png_ptr, png_ptr->hist);

  1228.    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;

  1229. #endif

  1230. #endif

  1231. #if defined(PNG_READ_GAMMA_SUPPORTED)

  1232.    if (png_ptr->gamma_16_table != 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_table[i]);

  1239.       }

  1240.    png_free(png_ptr, png_ptr->gamma_16_table);

  1241.    }

  1242. #if defined(PNG_READ_BACKGROUND_SUPPORTED)

  1243.    if (png_ptr->gamma_16_from_1 != NULL)

  1244.    {

  1245.       int i;

  1246.       int istop = (1 << (8 - png_ptr->gamma_shift));

  1247.       for (i = 0; i < istop; i++)

  1248.       {

  1249.          png_free(png_ptr, png_ptr->gamma_16_from_1[i]);

  1250.       }

  1251.    png_free(png_ptr, png_ptr->gamma_16_from_1);

  1252.    }

  1253.    if (png_ptr->gamma_16_to_1 != NULL)

  1254.    {

  1255.       int i;

  1256.       int istop = (1 << (8 - png_ptr->gamma_shift));

  1257.       for (i = 0; i < istop; i++)

  1258.       {

  1259.          png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

  1260.       }

  1261.    png_free(png_ptr, png_ptr->gamma_16_to_1);

  1262.    }

  1263. #endif

  1264. #endif

  1265. #if defined(PNG_TIME_RFC1123_SUPPORTED)

  1266.    png_free(png_ptr, png_ptr->time_buffer);

  1267. #endif

  1268. 

  1269.    inflateEnd(&png_ptr->zstream);

  1270. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

  1271.    png_free(png_ptr, png_ptr->save_buffer);

  1272. #endif

  1273. 

  1274. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED

  1275. #ifdef PNG_TEXT_SUPPORTED

  1276.    png_free(png_ptr, png_ptr->current_text);

  1277. #endif /* PNG_TEXT_SUPPORTED */

  1278. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

  1279. 

  1280.    /* Save the important info out of the png_struct, in case it is

  1281.     * being used again.

  1282.     */

  1283. #ifdef PNG_SETJMP_SUPPORTED

  1284.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

  1285. #endif

  1286. 

  1287.    error_fn = png_ptr->error_fn;

  1288.    warning_fn = png_ptr->warning_fn;

  1289.    error_ptr = png_ptr->error_ptr;

  1290. #ifdef PNG_USER_MEM_SUPPORTED

  1291.    free_fn = png_ptr->free_fn;

  1292. #endif

  1293. 

  1294.    png_memset(png_ptr, 0, png_sizeof (png_struct));

  1295. 

  1296.    png_ptr->error_fn = error_fn;

  1297.    png_ptr->warning_fn = warning_fn;

  1298.    png_ptr->error_ptr = error_ptr;

  1299. #ifdef PNG_USER_MEM_SUPPORTED

  1300.    png_ptr->free_fn = free_fn;

  1301. #endif

  1302. 

  1303. #ifdef PNG_SETJMP_SUPPORTED

  1304.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

  1305. #endif

  1306. 

  1307. }

  1308. 

  1309. void PNGAPI

  1310. png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)

  1311. {

  1312.    if(png_ptr == NULL) return;

  1313.    png_ptr->read_row_fn = read_row_fn;

  1314. }

  1315. 

  1316. 

  1317. #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

  1318. #if defined(PNG_INFO_IMAGE_SUPPORTED)

  1319. void PNGAPI

  1320. png_read_png(png_structp png_ptr, png_infop info_ptr,

  1321.                            int transforms,

  1322.                            voidp params)

  1323. {

  1324.    int row;

  1325. 

  1326.    if(png_ptr == NULL) return;

  1327. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

  1328.    /* invert the alpha channel from opacity to transparency

  1329.     */

  1330.    if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

  1331.        png_set_invert_alpha(png_ptr);

  1332. #endif

  1333. 

  1334.    /* png_read_info() gives us all of the information from the

  1335.     * PNG file before the first IDAT (image data chunk).

  1336.     */

  1337.    png_read_info(png_ptr, info_ptr);

  1338.    if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))

  1339.       png_error(png_ptr,"Image is too high to process with png_read_png()");

  1340. 

  1341.    /* -------------- image transformations start here ------------------- */

  1342. 

  1343. #if defined(PNG_READ_16_TO_8_SUPPORTED)

  1344.    /* tell libpng to strip 16 bit/color files down to 8 bits per color

  1345.     */

  1346.    if (transforms & PNG_TRANSFORM_STRIP_16)

  1347.        png_set_strip_16(png_ptr);

  1348. #endif

  1349. 

  1350. #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

  1351.    /* Strip alpha bytes from the input data without combining with

  1352.     * the background (not recommended).

  1353.     */

  1354.    if (transforms & PNG_TRANSFORM_STRIP_ALPHA)

  1355.        png_set_strip_alpha(png_ptr);

  1356. #endif

  1357. 

  1358. #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)

  1359.    /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single

  1360.     * byte into separate bytes (useful for paletted and grayscale images).

  1361.     */

  1362.    if (transforms & PNG_TRANSFORM_PACKING)

  1363.        png_set_packing(png_ptr);

  1364. #endif

  1365. 

  1366. #if defined(PNG_READ_PACKSWAP_SUPPORTED)

  1367.    /* Change the order of packed pixels to least significant bit first

  1368.     * (not useful if you are using png_set_packing).

  1369.     */

  1370.    if (transforms & PNG_TRANSFORM_PACKSWAP)

  1371.        png_set_packswap(png_ptr);

  1372. #endif

  1373. 

  1374. #if defined(PNG_READ_EXPAND_SUPPORTED)

  1375.    /* Expand paletted colors into true RGB triplets

  1376.     * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel

  1377.     * Expand paletted or RGB images with transparency to full alpha

  1378.     * channels so the data will be available as RGBA quartets.

  1379.     */

  1380.    if (transforms & PNG_TRANSFORM_EXPAND)

  1381.        if ((png_ptr->bit_depth < 8) ||

  1382.            (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||

  1383.            (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))

  1384.          png_set_expand(png_ptr);

  1385. #endif

  1386. 

  1387.    /* We don't handle background color or gamma transformation or dithering.

  1388.     */

  1389. 

  1390. #if defined(PNG_READ_INVERT_SUPPORTED)

  1391.    /* invert monochrome files to have 0 as white and 1 as black

  1392.     */

  1393.    if (transforms & PNG_TRANSFORM_INVERT_MONO)

  1394.        png_set_invert_mono(png_ptr);

  1395. #endif

  1396. 

  1397. #if defined(PNG_READ_SHIFT_SUPPORTED)

  1398.    /* If you want to shift the pixel values from the range [0,255] or

  1399.     * [0,65535] to the original [0,7] or [0,31], or whatever range the

  1400.     * colors were originally in:

  1401.     */

  1402.    if ((transforms & PNG_TRANSFORM_SHIFT)

  1403.        && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))

  1404.    {

  1405.       png_color_8p sig_bit;

  1406. 

  1407.       png_get_sBIT(png_ptr, info_ptr, &sig_bit);

  1408.       png_set_shift(png_ptr, sig_bit);

  1409.    }

  1410. #endif

  1411. 

  1412. #if defined(PNG_READ_BGR_SUPPORTED)

  1413.    /* flip the RGB pixels to BGR (or RGBA to BGRA)

  1414.     */

  1415.    if (transforms & PNG_TRANSFORM_BGR)

  1416.        png_set_bgr(png_ptr);

  1417. #endif

  1418. 

  1419. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)

  1420.    /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)

  1421.     */

  1422.    if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

  1423.        png_set_swap_alpha(png_ptr);

  1424. #endif

  1425. 

  1426. #if defined(PNG_READ_SWAP_SUPPORTED)

  1427.    /* swap bytes of 16 bit files to least significant byte first

  1428.     */

  1429.    if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

  1430.        png_set_swap(png_ptr);

  1431. #endif

  1432. 

  1433.    /* We don't handle adding filler bytes */

  1434. 

  1435.    /* Optional call to gamma correct and add the background to the palette

  1436.     * and update info structure.  REQUIRED if you are expecting libpng to

  1437.     * update the palette for you (i.e., you selected such a transform above).

  1438.     */

  1439.    png_read_update_info(png_ptr, info_ptr);

  1440. 

  1441.    /* -------------- image transformations end here ------------------- */

  1442. 

  1443. #ifdef PNG_FREE_ME_SUPPORTED

  1444.    png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

  1445. #endif

  1446.    if(info_ptr->row_pointers == NULL)

  1447.    {

  1448.       info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

  1449.          info_ptr->height * png_sizeof(png_bytep));

  1450. #ifdef PNG_FREE_ME_SUPPORTED

  1451.       info_ptr->free_me |= PNG_FREE_ROWS;

  1452. #endif

  1453.       for (row = 0; row < (int)info_ptr->height; row++)

  1454.       {

  1455.          info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,

  1456.             png_get_rowbytes(png_ptr, info_ptr));

  1457.       }

  1458.    }

  1459. 

  1460.    png_read_image(png_ptr, info_ptr->row_pointers);

  1461.    info_ptr->valid |= PNG_INFO_IDAT;

  1462. 

  1463.    /* read rest of file, and get additional chunks in info_ptr - REQUIRED */

  1464.    png_read_end(png_ptr, info_ptr);

  1465. 

  1466.    (void) transforms; /* quiet compiler warnings */

  1467.    (void) params;

  1468. 

  1469. }

  1470. #endif /* PNG_INFO_IMAGE_SUPPORTED */

  1471. #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

  1472. #endif /* PNG_READ_SUPPORTED */