/src/compiler/android/jni/ftk/pngpread.c

http://ftk.googlecode.com/ · C · 1774 lines · 1398 code · 278 blank · 98 comment · 325 complexity · 2ee0cf85f96c50c53463d7a1ec3b5e75 MD5 · raw file

  1. /* pngpread.c - read a png file in push mode
  2. *
  3. * Last changed in libpng 1.2.44 [June 26, 2010]
  4. * Copyright (c) 1998-2010 Glenn Randers-Pehrson
  5. * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  6. * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  7. *
  8. * This code is released under the libpng license.
  9. * For conditions of distribution and use, see the disclaimer
  10. * and license in png.h
  11. */
  12. #define PNG_INTERNAL
  13. #define PNG_NO_PEDANTIC_WARNINGS
  14. #include "png.h"
  15. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  16. /* Push model modes */
  17. #define PNG_READ_SIG_MODE 0
  18. #define PNG_READ_CHUNK_MODE 1
  19. #define PNG_READ_IDAT_MODE 2
  20. #define PNG_SKIP_MODE 3
  21. #define PNG_READ_tEXt_MODE 4
  22. #define PNG_READ_zTXt_MODE 5
  23. #define PNG_READ_DONE_MODE 6
  24. #define PNG_READ_iTXt_MODE 7
  25. #define PNG_ERROR_MODE 8
  26. void PNGAPI
  27. png_process_data(png_structp png_ptr, png_infop info_ptr,
  28. png_bytep buffer, png_size_t buffer_size)
  29. {
  30. if (png_ptr == NULL || info_ptr == NULL)
  31. return;
  32. png_push_restore_buffer(png_ptr, buffer, buffer_size);
  33. while (png_ptr->buffer_size)
  34. {
  35. png_process_some_data(png_ptr, info_ptr);
  36. }
  37. }
  38. /* What we do with the incoming data depends on what we were previously
  39. * doing before we ran out of data...
  40. */
  41. void /* PRIVATE */
  42. png_process_some_data(png_structp png_ptr, png_infop info_ptr)
  43. {
  44. if (png_ptr == NULL)
  45. return;
  46. switch (png_ptr->process_mode)
  47. {
  48. case PNG_READ_SIG_MODE:
  49. {
  50. png_push_read_sig(png_ptr, info_ptr);
  51. break;
  52. }
  53. case PNG_READ_CHUNK_MODE:
  54. {
  55. png_push_read_chunk(png_ptr, info_ptr);
  56. break;
  57. }
  58. case PNG_READ_IDAT_MODE:
  59. {
  60. png_push_read_IDAT(png_ptr);
  61. break;
  62. }
  63. #ifdef PNG_READ_tEXt_SUPPORTED
  64. case PNG_READ_tEXt_MODE:
  65. {
  66. png_push_read_tEXt(png_ptr, info_ptr);
  67. break;
  68. }
  69. #endif
  70. #ifdef PNG_READ_zTXt_SUPPORTED
  71. case PNG_READ_zTXt_MODE:
  72. {
  73. png_push_read_zTXt(png_ptr, info_ptr);
  74. break;
  75. }
  76. #endif
  77. #ifdef PNG_READ_iTXt_SUPPORTED
  78. case PNG_READ_iTXt_MODE:
  79. {
  80. png_push_read_iTXt(png_ptr, info_ptr);
  81. break;
  82. }
  83. #endif
  84. case PNG_SKIP_MODE:
  85. {
  86. png_push_crc_finish(png_ptr);
  87. break;
  88. }
  89. default:
  90. {
  91. png_ptr->buffer_size = 0;
  92. break;
  93. }
  94. }
  95. }
  96. /* Read any remaining signature bytes from the stream and compare them with
  97. * the correct PNG signature. It is possible that this routine is called
  98. * with bytes already read from the signature, either because they have been
  99. * checked by the calling application, or because of multiple calls to this
  100. * routine.
  101. */
  102. void /* PRIVATE */
  103. png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
  104. {
  105. png_size_t num_checked = png_ptr->sig_bytes,
  106. num_to_check = 8 - num_checked;
  107. if (png_ptr->buffer_size < num_to_check)
  108. {
  109. num_to_check = png_ptr->buffer_size;
  110. }
  111. png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
  112. num_to_check);
  113. png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
  114. if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
  115. {
  116. if (num_checked < 4 &&
  117. png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
  118. png_error(png_ptr, "Not a PNG file");
  119. else
  120. png_error(png_ptr, "PNG file corrupted by ASCII conversion");
  121. }
  122. else
  123. {
  124. if (png_ptr->sig_bytes >= 8)
  125. {
  126. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  127. }
  128. }
  129. }
  130. void /* PRIVATE */
  131. png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
  132. {
  133. #ifdef PNG_USE_LOCAL_ARRAYS
  134. PNG_CONST PNG_IHDR;
  135. PNG_CONST PNG_IDAT;
  136. PNG_CONST PNG_IEND;
  137. PNG_CONST PNG_PLTE;
  138. #ifdef PNG_READ_bKGD_SUPPORTED
  139. PNG_CONST PNG_bKGD;
  140. #endif
  141. #ifdef PNG_READ_cHRM_SUPPORTED
  142. PNG_CONST PNG_cHRM;
  143. #endif
  144. #ifdef PNG_READ_gAMA_SUPPORTED
  145. PNG_CONST PNG_gAMA;
  146. #endif
  147. #ifdef PNG_READ_hIST_SUPPORTED
  148. PNG_CONST PNG_hIST;
  149. #endif
  150. #ifdef PNG_READ_iCCP_SUPPORTED
  151. PNG_CONST PNG_iCCP;
  152. #endif
  153. #ifdef PNG_READ_iTXt_SUPPORTED
  154. PNG_CONST PNG_iTXt;
  155. #endif
  156. #ifdef PNG_READ_oFFs_SUPPORTED
  157. PNG_CONST PNG_oFFs;
  158. #endif
  159. #ifdef PNG_READ_pCAL_SUPPORTED
  160. PNG_CONST PNG_pCAL;
  161. #endif
  162. #ifdef PNG_READ_pHYs_SUPPORTED
  163. PNG_CONST PNG_pHYs;
  164. #endif
  165. #ifdef PNG_READ_sBIT_SUPPORTED
  166. PNG_CONST PNG_sBIT;
  167. #endif
  168. #ifdef PNG_READ_sCAL_SUPPORTED
  169. PNG_CONST PNG_sCAL;
  170. #endif
  171. #ifdef PNG_READ_sRGB_SUPPORTED
  172. PNG_CONST PNG_sRGB;
  173. #endif
  174. #ifdef PNG_READ_sPLT_SUPPORTED
  175. PNG_CONST PNG_sPLT;
  176. #endif
  177. #ifdef PNG_READ_tEXt_SUPPORTED
  178. PNG_CONST PNG_tEXt;
  179. #endif
  180. #ifdef PNG_READ_tIME_SUPPORTED
  181. PNG_CONST PNG_tIME;
  182. #endif
  183. #ifdef PNG_READ_tRNS_SUPPORTED
  184. PNG_CONST PNG_tRNS;
  185. #endif
  186. #ifdef PNG_READ_zTXt_SUPPORTED
  187. PNG_CONST PNG_zTXt;
  188. #endif
  189. #endif /* PNG_USE_LOCAL_ARRAYS */
  190. /* First we make sure we have enough data for the 4 byte chunk name
  191. * and the 4 byte chunk length before proceeding with decoding the
  192. * chunk data. To fully decode each of these chunks, we also make
  193. * sure we have enough data in the buffer for the 4 byte CRC at the
  194. * end of every chunk (except IDAT, which is handled separately).
  195. */
  196. if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
  197. {
  198. png_byte chunk_length[4];
  199. if (png_ptr->buffer_size < 8)
  200. {
  201. png_push_save_buffer(png_ptr);
  202. return;
  203. }
  204. png_push_fill_buffer(png_ptr, chunk_length, 4);
  205. png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
  206. png_reset_crc(png_ptr);
  207. png_crc_read(png_ptr, png_ptr->chunk_name, 4);
  208. png_check_chunk_name(png_ptr, png_ptr->chunk_name);
  209. png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
  210. }
  211. if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  212. if (png_ptr->mode & PNG_AFTER_IDAT)
  213. png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
  214. if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
  215. {
  216. if (png_ptr->push_length != 13)
  217. png_error(png_ptr, "Invalid IHDR length");
  218. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  219. {
  220. png_push_save_buffer(png_ptr);
  221. return;
  222. }
  223. png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
  224. }
  225. else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
  226. {
  227. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  228. {
  229. png_push_save_buffer(png_ptr);
  230. return;
  231. }
  232. png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
  233. png_ptr->process_mode = PNG_READ_DONE_MODE;
  234. png_push_have_end(png_ptr, info_ptr);
  235. }
  236. #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
  237. else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
  238. {
  239. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  240. {
  241. png_push_save_buffer(png_ptr);
  242. return;
  243. }
  244. if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  245. png_ptr->mode |= PNG_HAVE_IDAT;
  246. png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
  247. if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  248. png_ptr->mode |= PNG_HAVE_PLTE;
  249. else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  250. {
  251. if (!(png_ptr->mode & PNG_HAVE_IHDR))
  252. png_error(png_ptr, "Missing IHDR before IDAT");
  253. else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  254. !(png_ptr->mode & PNG_HAVE_PLTE))
  255. png_error(png_ptr, "Missing PLTE before IDAT");
  256. }
  257. }
  258. #endif
  259. else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
  260. {
  261. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  262. {
  263. png_push_save_buffer(png_ptr);
  264. return;
  265. }
  266. png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
  267. }
  268. else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  269. {
  270. /* If we reach an IDAT chunk, this means we have read all of the
  271. * header chunks, and we can start reading the image (or if this
  272. * is called after the image has been read - we have an error).
  273. */
  274. if (!(png_ptr->mode & PNG_HAVE_IHDR))
  275. png_error(png_ptr, "Missing IHDR before IDAT");
  276. else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
  277. !(png_ptr->mode & PNG_HAVE_PLTE))
  278. png_error(png_ptr, "Missing PLTE before IDAT");
  279. if (png_ptr->mode & PNG_HAVE_IDAT)
  280. {
  281. if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
  282. if (png_ptr->push_length == 0)
  283. return;
  284. if (png_ptr->mode & PNG_AFTER_IDAT)
  285. png_error(png_ptr, "Too many IDAT's found");
  286. }
  287. png_ptr->idat_size = png_ptr->push_length;
  288. png_ptr->mode |= PNG_HAVE_IDAT;
  289. png_ptr->process_mode = PNG_READ_IDAT_MODE;
  290. png_push_have_info(png_ptr, info_ptr);
  291. png_ptr->zstream.avail_out =
  292. (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
  293. png_ptr->iwidth) + 1;
  294. png_ptr->zstream.next_out = png_ptr->row_buf;
  295. return;
  296. }
  297. #ifdef PNG_READ_gAMA_SUPPORTED
  298. else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
  299. {
  300. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  301. {
  302. png_push_save_buffer(png_ptr);
  303. return;
  304. }
  305. png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
  306. }
  307. #endif
  308. #ifdef PNG_READ_sBIT_SUPPORTED
  309. else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
  310. {
  311. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  312. {
  313. png_push_save_buffer(png_ptr);
  314. return;
  315. }
  316. png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
  317. }
  318. #endif
  319. #ifdef PNG_READ_cHRM_SUPPORTED
  320. else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
  321. {
  322. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  323. {
  324. png_push_save_buffer(png_ptr);
  325. return;
  326. }
  327. png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
  328. }
  329. #endif
  330. #ifdef PNG_READ_sRGB_SUPPORTED
  331. else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
  332. {
  333. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  334. {
  335. png_push_save_buffer(png_ptr);
  336. return;
  337. }
  338. png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
  339. }
  340. #endif
  341. #ifdef PNG_READ_iCCP_SUPPORTED
  342. else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
  343. {
  344. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  345. {
  346. png_push_save_buffer(png_ptr);
  347. return;
  348. }
  349. png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
  350. }
  351. #endif
  352. #ifdef PNG_READ_sPLT_SUPPORTED
  353. else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
  354. {
  355. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  356. {
  357. png_push_save_buffer(png_ptr);
  358. return;
  359. }
  360. png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
  361. }
  362. #endif
  363. #ifdef PNG_READ_tRNS_SUPPORTED
  364. else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
  365. {
  366. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  367. {
  368. png_push_save_buffer(png_ptr);
  369. return;
  370. }
  371. png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
  372. }
  373. #endif
  374. #ifdef PNG_READ_bKGD_SUPPORTED
  375. else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
  376. {
  377. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  378. {
  379. png_push_save_buffer(png_ptr);
  380. return;
  381. }
  382. png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
  383. }
  384. #endif
  385. #ifdef PNG_READ_hIST_SUPPORTED
  386. else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
  387. {
  388. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  389. {
  390. png_push_save_buffer(png_ptr);
  391. return;
  392. }
  393. png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
  394. }
  395. #endif
  396. #ifdef PNG_READ_pHYs_SUPPORTED
  397. else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
  398. {
  399. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  400. {
  401. png_push_save_buffer(png_ptr);
  402. return;
  403. }
  404. png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
  405. }
  406. #endif
  407. #ifdef PNG_READ_oFFs_SUPPORTED
  408. else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
  409. {
  410. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  411. {
  412. png_push_save_buffer(png_ptr);
  413. return;
  414. }
  415. png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
  416. }
  417. #endif
  418. #ifdef PNG_READ_pCAL_SUPPORTED
  419. else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
  420. {
  421. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  422. {
  423. png_push_save_buffer(png_ptr);
  424. return;
  425. }
  426. png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
  427. }
  428. #endif
  429. #ifdef PNG_READ_sCAL_SUPPORTED
  430. else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
  431. {
  432. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  433. {
  434. png_push_save_buffer(png_ptr);
  435. return;
  436. }
  437. png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
  438. }
  439. #endif
  440. #ifdef PNG_READ_tIME_SUPPORTED
  441. else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
  442. {
  443. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  444. {
  445. png_push_save_buffer(png_ptr);
  446. return;
  447. }
  448. png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
  449. }
  450. #endif
  451. #ifdef PNG_READ_tEXt_SUPPORTED
  452. else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
  453. {
  454. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  455. {
  456. png_push_save_buffer(png_ptr);
  457. return;
  458. }
  459. png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
  460. }
  461. #endif
  462. #ifdef PNG_READ_zTXt_SUPPORTED
  463. else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
  464. {
  465. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  466. {
  467. png_push_save_buffer(png_ptr);
  468. return;
  469. }
  470. png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
  471. }
  472. #endif
  473. #ifdef PNG_READ_iTXt_SUPPORTED
  474. else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
  475. {
  476. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  477. {
  478. png_push_save_buffer(png_ptr);
  479. return;
  480. }
  481. png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
  482. }
  483. #endif
  484. else
  485. {
  486. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  487. {
  488. png_push_save_buffer(png_ptr);
  489. return;
  490. }
  491. png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
  492. }
  493. png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
  494. }
  495. void /* PRIVATE */
  496. png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
  497. {
  498. png_ptr->process_mode = PNG_SKIP_MODE;
  499. png_ptr->skip_length = skip;
  500. }
  501. void /* PRIVATE */
  502. png_push_crc_finish(png_structp png_ptr)
  503. {
  504. if (png_ptr->skip_length && png_ptr->save_buffer_size)
  505. {
  506. png_size_t save_size;
  507. if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)
  508. save_size = (png_size_t)png_ptr->skip_length;
  509. else
  510. save_size = png_ptr->save_buffer_size;
  511. png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
  512. png_ptr->skip_length -= save_size;
  513. png_ptr->buffer_size -= save_size;
  514. png_ptr->save_buffer_size -= save_size;
  515. png_ptr->save_buffer_ptr += save_size;
  516. }
  517. if (png_ptr->skip_length && png_ptr->current_buffer_size)
  518. {
  519. png_size_t save_size;
  520. if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)
  521. save_size = (png_size_t)png_ptr->skip_length;
  522. else
  523. save_size = png_ptr->current_buffer_size;
  524. png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
  525. png_ptr->skip_length -= save_size;
  526. png_ptr->buffer_size -= save_size;
  527. png_ptr->current_buffer_size -= save_size;
  528. png_ptr->current_buffer_ptr += save_size;
  529. }
  530. if (!png_ptr->skip_length)
  531. {
  532. if (png_ptr->buffer_size < 4)
  533. {
  534. png_push_save_buffer(png_ptr);
  535. return;
  536. }
  537. png_crc_finish(png_ptr, 0);
  538. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  539. }
  540. }
  541. void PNGAPI
  542. png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
  543. {
  544. png_bytep ptr;
  545. if (png_ptr == NULL)
  546. return;
  547. ptr = buffer;
  548. if (png_ptr->save_buffer_size)
  549. {
  550. png_size_t save_size;
  551. if (length < png_ptr->save_buffer_size)
  552. save_size = length;
  553. else
  554. save_size = png_ptr->save_buffer_size;
  555. png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
  556. length -= save_size;
  557. ptr += save_size;
  558. png_ptr->buffer_size -= save_size;
  559. png_ptr->save_buffer_size -= save_size;
  560. png_ptr->save_buffer_ptr += save_size;
  561. }
  562. if (length && png_ptr->current_buffer_size)
  563. {
  564. png_size_t save_size;
  565. if (length < png_ptr->current_buffer_size)
  566. save_size = length;
  567. else
  568. save_size = png_ptr->current_buffer_size;
  569. png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
  570. png_ptr->buffer_size -= save_size;
  571. png_ptr->current_buffer_size -= save_size;
  572. png_ptr->current_buffer_ptr += save_size;
  573. }
  574. }
  575. void /* PRIVATE */
  576. png_push_save_buffer(png_structp png_ptr)
  577. {
  578. if (png_ptr->save_buffer_size)
  579. {
  580. if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
  581. {
  582. png_size_t i, istop;
  583. png_bytep sp;
  584. png_bytep dp;
  585. istop = png_ptr->save_buffer_size;
  586. for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
  587. i < istop; i++, sp++, dp++)
  588. {
  589. *dp = *sp;
  590. }
  591. }
  592. }
  593. if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
  594. png_ptr->save_buffer_max)
  595. {
  596. png_size_t new_max;
  597. png_bytep old_buffer;
  598. if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
  599. (png_ptr->current_buffer_size + 256))
  600. {
  601. png_error(png_ptr, "Potential overflow of save_buffer");
  602. }
  603. new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
  604. old_buffer = png_ptr->save_buffer;
  605. png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
  606. (png_uint_32)new_max);
  607. if (png_ptr->save_buffer == NULL)
  608. {
  609. png_free(png_ptr, old_buffer);
  610. png_error(png_ptr, "Insufficient memory for save_buffer");
  611. }
  612. png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
  613. png_free(png_ptr, old_buffer);
  614. png_ptr->save_buffer_max = new_max;
  615. }
  616. if (png_ptr->current_buffer_size)
  617. {
  618. png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
  619. png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
  620. png_ptr->save_buffer_size += png_ptr->current_buffer_size;
  621. png_ptr->current_buffer_size = 0;
  622. }
  623. png_ptr->save_buffer_ptr = png_ptr->save_buffer;
  624. png_ptr->buffer_size = 0;
  625. }
  626. void /* PRIVATE */
  627. png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
  628. png_size_t buffer_length)
  629. {
  630. png_ptr->current_buffer = buffer;
  631. png_ptr->current_buffer_size = buffer_length;
  632. png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
  633. png_ptr->current_buffer_ptr = png_ptr->current_buffer;
  634. }
  635. void /* PRIVATE */
  636. png_push_read_IDAT(png_structp png_ptr)
  637. {
  638. #ifdef PNG_USE_LOCAL_ARRAYS
  639. PNG_CONST PNG_IDAT;
  640. #endif
  641. if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
  642. {
  643. png_byte chunk_length[4];
  644. if (png_ptr->buffer_size < 8)
  645. {
  646. png_push_save_buffer(png_ptr);
  647. return;
  648. }
  649. png_push_fill_buffer(png_ptr, chunk_length, 4);
  650. png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
  651. png_reset_crc(png_ptr);
  652. png_crc_read(png_ptr, png_ptr->chunk_name, 4);
  653. png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
  654. if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
  655. {
  656. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  657. if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
  658. png_error(png_ptr, "Not enough compressed data");
  659. return;
  660. }
  661. png_ptr->idat_size = png_ptr->push_length;
  662. }
  663. if (png_ptr->idat_size && png_ptr->save_buffer_size)
  664. {
  665. png_size_t save_size;
  666. if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
  667. {
  668. save_size = (png_size_t)png_ptr->idat_size;
  669. /* Check for overflow */
  670. if ((png_uint_32)save_size != png_ptr->idat_size)
  671. png_error(png_ptr, "save_size overflowed in pngpread");
  672. }
  673. else
  674. save_size = png_ptr->save_buffer_size;
  675. png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
  676. png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
  677. png_ptr->idat_size -= save_size;
  678. png_ptr->buffer_size -= save_size;
  679. png_ptr->save_buffer_size -= save_size;
  680. png_ptr->save_buffer_ptr += save_size;
  681. }
  682. if (png_ptr->idat_size && png_ptr->current_buffer_size)
  683. {
  684. png_size_t save_size;
  685. if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
  686. {
  687. save_size = (png_size_t)png_ptr->idat_size;
  688. /* Check for overflow */
  689. if ((png_uint_32)save_size != png_ptr->idat_size)
  690. png_error(png_ptr, "save_size overflowed in pngpread");
  691. }
  692. else
  693. save_size = png_ptr->current_buffer_size;
  694. png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
  695. png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
  696. png_ptr->idat_size -= save_size;
  697. png_ptr->buffer_size -= save_size;
  698. png_ptr->current_buffer_size -= save_size;
  699. png_ptr->current_buffer_ptr += save_size;
  700. }
  701. if (!png_ptr->idat_size)
  702. {
  703. if (png_ptr->buffer_size < 4)
  704. {
  705. png_push_save_buffer(png_ptr);
  706. return;
  707. }
  708. png_crc_finish(png_ptr, 0);
  709. png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
  710. png_ptr->mode |= PNG_AFTER_IDAT;
  711. }
  712. }
  713. void /* PRIVATE */
  714. png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
  715. png_size_t buffer_length)
  716. {
  717. /* The caller checks for a non-zero buffer length. */
  718. if (!(buffer_length > 0) || buffer == NULL)
  719. png_error(png_ptr, "No IDAT data (internal error)");
  720. /* This routine must process all the data it has been given
  721. * before returning, calling the row callback as required to
  722. * handle the uncompressed results.
  723. */
  724. png_ptr->zstream.next_in = buffer;
  725. png_ptr->zstream.avail_in = (uInt)buffer_length;
  726. /* Keep going until the decompressed data is all processed
  727. * or the stream marked as finished.
  728. */
  729. while (png_ptr->zstream.avail_in > 0 &&
  730. !(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
  731. {
  732. int ret;
  733. /* We have data for zlib, but we must check that zlib
  734. * has somewhere to put the results. It doesn't matter
  735. * if we don't expect any results -- it may be the input
  736. * data is just the LZ end code.
  737. */
  738. if (!(png_ptr->zstream.avail_out > 0))
  739. {
  740. png_ptr->zstream.avail_out =
  741. (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
  742. png_ptr->iwidth) + 1;
  743. png_ptr->zstream.next_out = png_ptr->row_buf;
  744. }
  745. /* Using Z_SYNC_FLUSH here means that an unterminated
  746. * LZ stream can still be handled (a stream with a missing
  747. * end code), otherwise (Z_NO_FLUSH) a future zlib
  748. * implementation might defer output and, therefore,
  749. * change the current behavior. (See comments in inflate.c
  750. * for why this doesn't happen at present with zlib 1.2.5.)
  751. */
  752. ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
  753. /* Check for any failure before proceeding. */
  754. if (ret != Z_OK && ret != Z_STREAM_END)
  755. {
  756. /* Terminate the decompression. */
  757. png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
  758. /* This may be a truncated stream (missing or
  759. * damaged end code). Treat that as a warning.
  760. */
  761. if (png_ptr->row_number >= png_ptr->num_rows ||
  762. png_ptr->pass > 6)
  763. png_warning(png_ptr, "Truncated compressed data in IDAT");
  764. else
  765. png_error(png_ptr, "Decompression error in IDAT");
  766. /* Skip the check on unprocessed input */
  767. return;
  768. }
  769. /* Did inflate output any data? */
  770. if (png_ptr->zstream.next_out != png_ptr->row_buf)
  771. {
  772. /* Is this unexpected data after the last row?
  773. * If it is, artificially terminate the LZ output
  774. * here.
  775. */
  776. if (png_ptr->row_number >= png_ptr->num_rows ||
  777. png_ptr->pass > 6)
  778. {
  779. /* Extra data. */
  780. png_warning(png_ptr, "Extra compressed data in IDAT");
  781. png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
  782. /* Do no more processing; skip the unprocessed
  783. * input check below.
  784. */
  785. return;
  786. }
  787. /* Do we have a complete row? */
  788. if (png_ptr->zstream.avail_out == 0)
  789. png_push_process_row(png_ptr);
  790. }
  791. /* And check for the end of the stream. */
  792. if (ret == Z_STREAM_END)
  793. png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
  794. }
  795. /* All the data should have been processed, if anything
  796. * is left at this point we have bytes of IDAT data
  797. * after the zlib end code.
  798. */
  799. if (png_ptr->zstream.avail_in > 0)
  800. png_warning(png_ptr, "Extra compression data");
  801. }
  802. void /* PRIVATE */
  803. png_push_process_row(png_structp png_ptr)
  804. {
  805. png_ptr->row_info.color_type = png_ptr->color_type;
  806. png_ptr->row_info.width = png_ptr->iwidth;
  807. png_ptr->row_info.channels = png_ptr->channels;
  808. png_ptr->row_info.bit_depth = png_ptr->bit_depth;
  809. png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
  810. png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
  811. png_ptr->row_info.width);
  812. png_read_filter_row(png_ptr, &(png_ptr->row_info),
  813. png_ptr->row_buf + 1, png_ptr->prev_row + 1,
  814. (int)(png_ptr->row_buf[0]));
  815. png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
  816. png_ptr->rowbytes + 1);
  817. if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
  818. png_do_read_transformations(png_ptr);
  819. #ifdef PNG_READ_INTERLACING_SUPPORTED
  820. /* Blow up interlaced rows to full size */
  821. if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
  822. {
  823. if (png_ptr->pass < 6)
  824. /* old interface (pre-1.0.9):
  825. png_do_read_interlace(&(png_ptr->row_info),
  826. png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
  827. */
  828. png_do_read_interlace(png_ptr);
  829. switch (png_ptr->pass)
  830. {
  831. case 0:
  832. {
  833. int i;
  834. for (i = 0; i < 8 && png_ptr->pass == 0; i++)
  835. {
  836. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  837. png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
  838. }
  839. if (png_ptr->pass == 2) /* Pass 1 might be empty */
  840. {
  841. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  842. {
  843. png_push_have_row(png_ptr, png_bytep_NULL);
  844. png_read_push_finish_row(png_ptr);
  845. }
  846. }
  847. if (png_ptr->pass == 4 && png_ptr->height <= 4)
  848. {
  849. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  850. {
  851. png_push_have_row(png_ptr, png_bytep_NULL);
  852. png_read_push_finish_row(png_ptr);
  853. }
  854. }
  855. if (png_ptr->pass == 6 && png_ptr->height <= 4)
  856. {
  857. png_push_have_row(png_ptr, png_bytep_NULL);
  858. png_read_push_finish_row(png_ptr);
  859. }
  860. break;
  861. }
  862. case 1:
  863. {
  864. int i;
  865. for (i = 0; i < 8 && png_ptr->pass == 1; i++)
  866. {
  867. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  868. png_read_push_finish_row(png_ptr);
  869. }
  870. if (png_ptr->pass == 2) /* Skip top 4 generated rows */
  871. {
  872. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  873. {
  874. png_push_have_row(png_ptr, png_bytep_NULL);
  875. png_read_push_finish_row(png_ptr);
  876. }
  877. }
  878. break;
  879. }
  880. case 2:
  881. {
  882. int i;
  883. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  884. {
  885. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  886. png_read_push_finish_row(png_ptr);
  887. }
  888. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  889. {
  890. png_push_have_row(png_ptr, png_bytep_NULL);
  891. png_read_push_finish_row(png_ptr);
  892. }
  893. if (png_ptr->pass == 4) /* Pass 3 might be empty */
  894. {
  895. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  896. {
  897. png_push_have_row(png_ptr, png_bytep_NULL);
  898. png_read_push_finish_row(png_ptr);
  899. }
  900. }
  901. break;
  902. }
  903. case 3:
  904. {
  905. int i;
  906. for (i = 0; i < 4 && png_ptr->pass == 3; i++)
  907. {
  908. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  909. png_read_push_finish_row(png_ptr);
  910. }
  911. if (png_ptr->pass == 4) /* Skip top two generated rows */
  912. {
  913. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  914. {
  915. png_push_have_row(png_ptr, png_bytep_NULL);
  916. png_read_push_finish_row(png_ptr);
  917. }
  918. }
  919. break;
  920. }
  921. case 4:
  922. {
  923. int i;
  924. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  925. {
  926. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  927. png_read_push_finish_row(png_ptr);
  928. }
  929. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  930. {
  931. png_push_have_row(png_ptr, png_bytep_NULL);
  932. png_read_push_finish_row(png_ptr);
  933. }
  934. if (png_ptr->pass == 6) /* Pass 5 might be empty */
  935. {
  936. png_push_have_row(png_ptr, png_bytep_NULL);
  937. png_read_push_finish_row(png_ptr);
  938. }
  939. break;
  940. }
  941. case 5:
  942. {
  943. int i;
  944. for (i = 0; i < 2 && png_ptr->pass == 5; i++)
  945. {
  946. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  947. png_read_push_finish_row(png_ptr);
  948. }
  949. if (png_ptr->pass == 6) /* Skip top generated row */
  950. {
  951. png_push_have_row(png_ptr, png_bytep_NULL);
  952. png_read_push_finish_row(png_ptr);
  953. }
  954. break;
  955. }
  956. case 6:
  957. {
  958. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  959. png_read_push_finish_row(png_ptr);
  960. if (png_ptr->pass != 6)
  961. break;
  962. png_push_have_row(png_ptr, png_bytep_NULL);
  963. png_read_push_finish_row(png_ptr);
  964. }
  965. }
  966. }
  967. else
  968. #endif
  969. {
  970. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  971. png_read_push_finish_row(png_ptr);
  972. }
  973. }
  974. void /* PRIVATE */
  975. png_read_push_finish_row(png_structp png_ptr)
  976. {
  977. #ifdef PNG_USE_LOCAL_ARRAYS
  978. /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  979. /* Start of interlace block */
  980. PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
  981. /* Offset to next interlace block */
  982. PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
  983. /* Start of interlace block in the y direction */
  984. PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
  985. /* Offset to next interlace block in the y direction */
  986. PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
  987. /* Height of interlace block. This is not currently used - if you need
  988. * it, uncomment it here and in png.h
  989. PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
  990. */
  991. #endif
  992. png_ptr->row_number++;
  993. if (png_ptr->row_number < png_ptr->num_rows)
  994. return;
  995. #ifdef PNG_READ_INTERLACING_SUPPORTED
  996. if (png_ptr->interlaced)
  997. {
  998. png_ptr->row_number = 0;
  999. png_memset_check(png_ptr, png_ptr->prev_row, 0,
  1000. png_ptr->rowbytes + 1);
  1001. do
  1002. {
  1003. png_ptr->pass++;
  1004. if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
  1005. (png_ptr->pass == 3 && png_ptr->width < 3) ||
  1006. (png_ptr->pass == 5 && png_ptr->width < 2))
  1007. png_ptr->pass++;
  1008. if (png_ptr->pass > 7)
  1009. png_ptr->pass--;
  1010. if (png_ptr->pass >= 7)
  1011. break;
  1012. png_ptr->iwidth = (png_ptr->width +
  1013. png_pass_inc[png_ptr->pass] - 1 -
  1014. png_pass_start[png_ptr->pass]) /
  1015. png_pass_inc[png_ptr->pass];
  1016. if (png_ptr->transformations & PNG_INTERLACE)
  1017. break;
  1018. png_ptr->num_rows = (png_ptr->height +
  1019. png_pass_yinc[png_ptr->pass] - 1 -
  1020. png_pass_ystart[png_ptr->pass]) /
  1021. png_pass_yinc[png_ptr->pass];
  1022. } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
  1023. }
  1024. #endif /* PNG_READ_INTERLACING_SUPPORTED */
  1025. }
  1026. #ifdef PNG_READ_tEXt_SUPPORTED
  1027. void /* PRIVATE */
  1028. png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
  1029. length)
  1030. {
  1031. if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
  1032. {
  1033. png_error(png_ptr, "Out of place tEXt");
  1034. info_ptr = info_ptr; /* To quiet some compiler warnings */
  1035. }
  1036. #ifdef PNG_MAX_MALLOC_64K
  1037. png_ptr->skip_length = 0; /* This may not be necessary */
  1038. if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
  1039. {
  1040. png_warning(png_ptr, "tEXt chunk too large to fit in memory");
  1041. png_ptr->skip_length = length - (png_uint_32)65535L;
  1042. length = (png_uint_32)65535L;
  1043. }
  1044. #endif
  1045. png_ptr->current_text = (png_charp)png_malloc(png_ptr,
  1046. (png_uint_32)(length + 1));
  1047. png_ptr->current_text[length] = '\0';
  1048. png_ptr->current_text_ptr = png_ptr->current_text;
  1049. png_ptr->current_text_size = (png_size_t)length;
  1050. png_ptr->current_text_left = (png_size_t)length;
  1051. png_ptr->process_mode = PNG_READ_tEXt_MODE;
  1052. }
  1053. void /* PRIVATE */
  1054. png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
  1055. {
  1056. if (png_ptr->buffer_size && png_ptr->current_text_left)
  1057. {
  1058. png_size_t text_size;
  1059. if (png_ptr->buffer_size < png_ptr->current_text_left)
  1060. text_size = png_ptr->buffer_size;
  1061. else
  1062. text_size = png_ptr->current_text_left;
  1063. png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
  1064. png_ptr->current_text_left -= text_size;
  1065. png_ptr->current_text_ptr += text_size;
  1066. }
  1067. if (!(png_ptr->current_text_left))
  1068. {
  1069. png_textp text_ptr;
  1070. png_charp text;
  1071. png_charp key;
  1072. int ret;
  1073. if (png_ptr->buffer_size < 4)
  1074. {
  1075. png_push_save_buffer(png_ptr);
  1076. return;
  1077. }
  1078. png_push_crc_finish(png_ptr);
  1079. #ifdef PNG_MAX_MALLOC_64K
  1080. if (png_ptr->skip_length)
  1081. return;
  1082. #endif
  1083. key = png_ptr->current_text;
  1084. for (text = key; *text; text++)
  1085. /* Empty loop */ ;
  1086. if (text < key + png_ptr->current_text_size)
  1087. text++;
  1088. text_ptr = (png_textp)png_malloc(png_ptr,
  1089. (png_uint_32)png_sizeof(png_text));
  1090. text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
  1091. text_ptr->key = key;
  1092. #ifdef PNG_iTXt_SUPPORTED
  1093. text_ptr->lang = NULL;
  1094. text_ptr->lang_key = NULL;
  1095. #endif
  1096. text_ptr->text = text;
  1097. ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
  1098. png_free(png_ptr, key);
  1099. png_free(png_ptr, text_ptr);
  1100. png_ptr->current_text = NULL;
  1101. if (ret)
  1102. png_warning(png_ptr, "Insufficient memory to store text chunk.");
  1103. }
  1104. }
  1105. #endif
  1106. #ifdef PNG_READ_zTXt_SUPPORTED
  1107. void /* PRIVATE */
  1108. png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
  1109. length)
  1110. {
  1111. if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
  1112. {
  1113. png_error(png_ptr, "Out of place zTXt");
  1114. info_ptr = info_ptr; /* To quiet some compiler warnings */
  1115. }
  1116. #ifdef PNG_MAX_MALLOC_64K
  1117. /* We can't handle zTXt chunks > 64K, since we don't have enough space
  1118. * to be able to store the uncompressed data. Actually, the threshold
  1119. * is probably around 32K, but it isn't as definite as 64K is.
  1120. */
  1121. if (length > (png_uint_32)65535L)
  1122. {
  1123. png_warning(png_ptr, "zTXt chunk too large to fit in memory");
  1124. png_push_crc_skip(png_ptr, length);
  1125. return;
  1126. }
  1127. #endif
  1128. png_ptr->current_text = (png_charp)png_malloc(png_ptr,
  1129. (png_uint_32)(length + 1));
  1130. png_ptr->current_text[length] = '\0';
  1131. png_ptr->current_text_ptr = png_ptr->current_text;
  1132. png_ptr->current_text_size = (png_size_t)length;
  1133. png_ptr->current_text_left = (png_size_t)length;
  1134. png_ptr->process_mode = PNG_READ_zTXt_MODE;
  1135. }
  1136. void /* PRIVATE */
  1137. png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
  1138. {
  1139. if (png_ptr->buffer_size && png_ptr->current_text_left)
  1140. {
  1141. png_size_t text_size;
  1142. if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
  1143. text_size = png_ptr->buffer_size;
  1144. else
  1145. text_size = png_ptr->current_text_left;
  1146. png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
  1147. png_ptr->current_text_left -= text_size;
  1148. png_ptr->current_text_ptr += text_size;
  1149. }
  1150. if (!(png_ptr->current_text_left))
  1151. {
  1152. png_textp text_ptr;
  1153. png_charp text;
  1154. png_charp key;
  1155. int ret;
  1156. png_size_t text_size, key_size;
  1157. if (png_ptr->buffer_size < 4)
  1158. {
  1159. png_push_save_buffer(png_ptr);
  1160. return;
  1161. }
  1162. png_push_crc_finish(png_ptr);
  1163. key = png_ptr->current_text;
  1164. for (text = key; *text; text++)
  1165. /* Empty loop */ ;
  1166. /* zTXt can't have zero text */
  1167. if (text >= key + png_ptr->current_text_size)
  1168. {
  1169. png_ptr->current_text = NULL;
  1170. png_free(png_ptr, key);
  1171. return;
  1172. }
  1173. text++;
  1174. if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
  1175. {
  1176. png_ptr->current_text = NULL;
  1177. png_free(png_ptr, key);
  1178. return;
  1179. }
  1180. text++;
  1181. png_ptr->zstream.next_in = (png_bytep )text;
  1182. png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
  1183. (text - key));
  1184. png_ptr->zstream.next_out = png_ptr->zbuf;
  1185. png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1186. key_size = text - key;
  1187. text_size = 0;
  1188. text = NULL;
  1189. ret = Z_STREAM_END;
  1190. while (png_ptr->zstream.avail_in)
  1191. {
  1192. ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
  1193. if (ret != Z_OK && ret != Z_STREAM_END)
  1194. {
  1195. inflateReset(&png_ptr->zstream);
  1196. png_ptr->zstream.avail_in = 0;
  1197. png_ptr->current_text = NULL;
  1198. png_free(png_ptr, key);
  1199. png_free(png_ptr, text);
  1200. return;
  1201. }
  1202. if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)
  1203. {
  1204. if (text == NULL)
  1205. {
  1206. text = (png_charp)png_malloc(png_ptr,
  1207. (png_uint_32)(png_ptr->zbuf_size
  1208. - png_ptr->zstream.avail_out + key_size + 1));
  1209. png_memcpy(text + key_size, png_ptr->zbuf,
  1210. png_ptr->zbuf_size - png_ptr->zstream.avail_out);
  1211. png_memcpy(text, key, key_size);
  1212. text_size = key_size + png_ptr->zbuf_size -
  1213. png_ptr->zstream.avail_out;
  1214. *(text + text_size) = '\0';
  1215. }
  1216. else
  1217. {
  1218. png_charp tmp;
  1219. tmp = text;
  1220. text = (png_charp)png_malloc(png_ptr, text_size +
  1221. (png_uint_32)(png_ptr->zbuf_size
  1222. - png_ptr->zstream.avail_out + 1));
  1223. png_memcpy(text, tmp, text_size);
  1224. png_free(png_ptr, tmp);
  1225. png_memcpy(text + text_size, png_ptr->zbuf,
  1226. png_ptr->zbuf_size - png_ptr->zstream.avail_out);
  1227. text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
  1228. *(text + text_size) = '\0';
  1229. }
  1230. if (ret != Z_STREAM_END)
  1231. {
  1232. png_ptr->zstream.next_out = png_ptr->zbuf;
  1233. png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1234. }
  1235. }
  1236. else
  1237. {
  1238. break;
  1239. }
  1240. if (ret == Z_STREAM_END)
  1241. break;
  1242. }
  1243. inflateReset(&png_ptr->zstream);
  1244. png_ptr->zstream.avail_in = 0;
  1245. if (ret != Z_STREAM_END)
  1246. {
  1247. png_ptr->current_text = NULL;
  1248. png_free(png_ptr, key);
  1249. png_free(png_ptr, text);
  1250. return;
  1251. }
  1252. png_ptr->current_text = NULL;
  1253. png_free(png_ptr, key);
  1254. key = text;
  1255. text += key_size;
  1256. text_ptr = (png_textp)png_malloc(png_ptr,
  1257. (png_uint_32)png_sizeof(png_text));
  1258. text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
  1259. text_ptr->key = key;
  1260. #ifdef PNG_iTXt_SUPPORTED
  1261. text_ptr->lang = NULL;
  1262. text_ptr->lang_key = NULL;
  1263. #endif
  1264. text_ptr->text = text;
  1265. ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
  1266. png_free(png_ptr, key);
  1267. png_free(png_ptr, text_ptr);
  1268. if (ret)
  1269. png_warning(png_ptr, "Insufficient memory to store text chunk.");
  1270. }
  1271. }
  1272. #endif
  1273. #ifdef PNG_READ_iTXt_SUPPORTED
  1274. void /* PRIVATE */
  1275. png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
  1276. length)
  1277. {
  1278. if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
  1279. {
  1280. png_error(png_ptr, "Out of place iTXt");
  1281. info_ptr = info_ptr; /* To quiet some compiler warnings */
  1282. }
  1283. #ifdef PNG_MAX_MALLOC_64K
  1284. png_ptr->skip_length = 0; /* This may not be necessary */
  1285. if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */
  1286. {
  1287. png_warning(png_ptr, "iTXt chunk too large to fit in memory");
  1288. png_ptr->skip_length = length - (png_uint_32)65535L;
  1289. length = (png_uint_32)65535L;
  1290. }
  1291. #endif
  1292. png_ptr->current_text = (png_charp)png_malloc(png_ptr,
  1293. (png_uint_32)(length + 1));
  1294. png_ptr->current_text[length] = '\0';
  1295. png_ptr->current_text_ptr = png_ptr->current_text;
  1296. png_ptr->current_text_size = (png_size_t)length;
  1297. png_ptr->current_text_left = (png_size_t)length;
  1298. png_ptr->process_mode = PNG_READ_iTXt_MODE;
  1299. }
  1300. void /* PRIVATE */
  1301. png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
  1302. {
  1303. if (png_ptr->buffer_size && png_ptr->current_text_left)
  1304. {
  1305. png_size_t text_size;
  1306. if (png_ptr->buffer_size < png_ptr->current_text_left)
  1307. text_size = png_ptr->buffer_size;
  1308. else
  1309. text_size = png_ptr->current_text_left;
  1310. png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
  1311. png_ptr->current_text_left -= text_size;
  1312. png_ptr->current_text_ptr += text_size;
  1313. }
  1314. if (!(png_ptr->current_text_left))
  1315. {
  1316. png_textp text_ptr;
  1317. png_charp key;
  1318. int comp_flag;
  1319. png_charp lang;
  1320. png_charp lang_key;
  1321. png_charp text;
  1322. int ret;
  1323. if (png_ptr->buffer_size < 4)
  1324. {
  1325. png_push_save_buffer(png_ptr);
  1326. return;
  1327. }
  1328. png_push_crc_finish(png_ptr);
  1329. #ifdef PNG_MAX_MALLOC_64K
  1330. if (png_ptr->skip_length)
  1331. return;
  1332. #endif
  1333. key = png_ptr->current_text;
  1334. for (lang = key; *lang; lang++)
  1335. /* Empty loop */ ;
  1336. if (lang < key + png_ptr->current_text_size - 3)
  1337. lang++;
  1338. comp_flag = *lang++;
  1339. lang++; /* Skip comp_type, always zero */
  1340. for (lang_key = lang; *lang_key; lang_key++)
  1341. /* Empty loop */ ;
  1342. lang_key++; /* Skip NUL separator */
  1343. text=lang_key;
  1344. if (lang_key < key + png_ptr->current_text_size - 1)
  1345. {
  1346. for (; *text; text++)
  1347. /* Empty loop */ ;
  1348. }
  1349. if (text < key + png_ptr->current_text_size)
  1350. text++;
  1351. text_ptr = (png_textp)png_malloc(png_ptr,
  1352. (png_uint_32)png_sizeof(png_text));
  1353. text_ptr->compression = comp_flag + 2;
  1354. text_ptr->key = key;
  1355. text_ptr->lang = lang;
  1356. text_ptr->lang_key = lang_key;
  1357. text_ptr->text = text;
  1358. text_ptr->text_length = 0;
  1359. text_ptr->itxt_length = png_strlen(text);
  1360. ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);
  1361. png_ptr->current_text = NULL;
  1362. png_free(png_ptr, text_ptr);
  1363. if (ret)
  1364. png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");
  1365. }
  1366. }
  1367. #endif
  1368. /* This function is called when we haven't found a handler for this
  1369. * chunk. If there isn't a problem with the chunk itself (ie a bad chunk
  1370. * name or a critical chunk), the chunk is (currently) silently ignored.
  1371. */
  1372. void /* PRIVATE */
  1373. png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
  1374. length)
  1375. {
  1376. png_uint_32 skip = 0;
  1377. if (!(png_ptr->chunk_name[0] & 0x20))
  1378. {
  1379. #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
  1380. if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
  1381. PNG_HANDLE_CHUNK_ALWAYS
  1382. #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
  1383. && png_ptr->read_user_chunk_fn == NULL
  1384. #endif
  1385. )
  1386. #endif
  1387. png_chunk_error(png_ptr, "unknown critical chunk");
  1388. info_ptr = info_ptr; /* To quiet some compiler warnings */
  1389. }
  1390. #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
  1391. if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)
  1392. {
  1393. #ifdef PNG_MAX_MALLOC_64K
  1394. if (length > (png_uint_32)65535L)
  1395. {
  1396. png_warning(png_ptr, "unknown chunk too large to fit in memory");
  1397. skip = length - (png_uint_32)65535L;
  1398. length = (png_uint_32)65535L;
  1399. }
  1400. #endif
  1401. png_memcpy((png_charp)png_ptr->unknown_chunk.name,
  1402. (png_charp)png_ptr->chunk_name,
  1403. png_sizeof(png_ptr->unknown_chunk.name));
  1404. png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
  1405. = '\0';
  1406. png_ptr->unknown_chunk.size = (png_size_t)length;
  1407. if (length == 0)
  1408. png_ptr->unknown_chunk.data = NULL;
  1409. else
  1410. {
  1411. png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
  1412. (png_uint_32)length);
  1413. png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
  1414. }
  1415. #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
  1416. if (png_ptr->read_user_chunk_fn != NULL)
  1417. {
  1418. /* Callback to user unknown chunk handler */
  1419. int ret;
  1420. ret = (*(png_ptr->read_user_chunk_fn))
  1421. (png_ptr, &png_ptr->unknown_chunk);
  1422. if (ret < 0)
  1423. png_chunk_error(png_ptr, "error in user chunk");
  1424. if (ret == 0)
  1425. {
  1426. if (!(png_ptr->chunk_name[0] & 0x20))
  1427. if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
  1428. PNG_HANDLE_CHUNK_ALWAYS)
  1429. png_chunk_error(png_ptr, "unknown critical chunk");
  1430. png_set_unknown_chunks(png_ptr, info_ptr,
  1431. &png_ptr->unknown_chunk, 1);
  1432. }
  1433. }
  1434. else
  1435. #endif
  1436. png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
  1437. png_free(png_ptr, png_ptr->unknown_chunk.data);
  1438. png_ptr->unknown_chunk.data = NULL;
  1439. }
  1440. else
  1441. #endif
  1442. skip=length;
  1443. png_push_crc_skip(png_ptr, skip);
  1444. }
  1445. void /* PRIVATE */
  1446. png_push_have_info(png_structp png_ptr, png_infop info_ptr)
  1447. {
  1448. if (png_ptr->info_fn != NULL)
  1449. (*(png_ptr->info_fn))(png_ptr, info_ptr);
  1450. }
  1451. void /* PRIVATE */
  1452. png_push_have_end(png_structp png_ptr, png_infop info_ptr)
  1453. {
  1454. if (png_ptr->end_fn != NULL)
  1455. (*(png_ptr->end_fn))(png_ptr, info_ptr);
  1456. }
  1457. void /* PRIVATE */
  1458. png_push_have_row(png_structp png_ptr, png_bytep row)
  1459. {
  1460. if (png_ptr->row_fn != NULL)
  1461. (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
  1462. (int)png_ptr->pass);
  1463. }
  1464. void PNGAPI
  1465. png_progressive_combine_row (png_structp png_ptr,
  1466. png_bytep old_row, png_bytep new_row)
  1467. {
  1468. #ifdef PNG_USE_LOCAL_ARRAYS
  1469. PNG_CONST int FARDATA png_pass_dsp_mask[7] =
  1470. {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
  1471. #endif
  1472. if (png_ptr == NULL)
  1473. return;
  1474. if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
  1475. png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
  1476. }
  1477. void PNGAPI
  1478. png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
  1479. png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
  1480. png_progressive_end_ptr end_fn)
  1481. {
  1482. if (png_ptr == NULL)
  1483. return;
  1484. png_ptr->info_fn = info_fn;
  1485. png_ptr->row_fn = row_fn;
  1486. png_ptr->end_fn = end_fn;
  1487. png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
  1488. }
  1489. png_voidp PNGAPI
  1490. png_get_progressive_ptr(png_structp png_ptr)
  1491. {
  1492. if (png_ptr == NULL)
  1493. return (NULL);
  1494. return png_ptr->io_ptr;
  1495. }
  1496. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */