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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
pngpread.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：30k
源码类别：

浏览器

开发平台：

Unix_Linux

pngpread.c：源码内容
  2. /* pngpread.c - read a png file in push mode
  4. libpng 1.0 beta 2 - version 0.87
  5.    For conditions of distribution and use, see copyright notice in png.h
  6. Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  7.    January 15, 1996
  8.    */
  10. #define PNG_INTERNAL
  11. #include "png.h"
  13. #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  15. void
  16. png_process_data(png_structp png_ptr, png_infop info,
  17. png_bytep buffer, png_uint_32 buffer_size)
  18. {
  19. png_push_restore_buffer(png_ptr, buffer, buffer_size);
  21. while (png_ptr->buffer_size)
  22. {
  23. png_process_some_data(png_ptr, info);
  24. }
  25. }
  27. void
  28. png_process_some_data(png_structp png_ptr, png_infop info)
  29. {
  30. switch (png_ptr->process_mode)
  31. {
  32. case PNG_READ_SIG_MODE:
  33. {
  34. png_push_read_sig(png_ptr);
  35. break;
  36. }
  37. case PNG_READ_CHUNK_MODE:
  38. {
  39. png_push_read_chunk(png_ptr, info);
  40. break;
  41. }
  42. case PNG_READ_IDAT_MODE:
  43. {
  44. png_push_read_idat(png_ptr);
  45. break;
  46. }
  47. case PNG_READ_PLTE_MODE:
  48. {
  49. png_push_read_plte(png_ptr, info);
  50. break;
  51. }
  52. #if defined(PNG_READ_tEXt_SUPPORTED)
  53. case PNG_READ_tEXt_MODE:
  54. {
  55. png_push_read_text(png_ptr, info);
  56. break;
  57. }
  58. #endif
  59. case PNG_READ_END_MODE:
  60. {
  61. png_push_read_end(png_ptr, info);
  62. break;
  63. }
  64. case PNG_SKIP_MODE:
  65. {
  66. png_push_skip(png_ptr);
  67. break;
  68. }
  69. default:
  70. {
  71. png_ptr->buffer_size = 0;
  72. break;
  73. }
  74. }
  75. }
  77. void
  78. png_push_read_sig(png_structp png_ptr)
  79. {
  80. png_byte sig[8];
  82. if (png_ptr->buffer_size < 8)
  83. {
  84. png_push_save_buffer(png_ptr);
  85. return;
  86. }
  88. png_push_fill_buffer(png_ptr, sig, 8);
  90. if (png_check_sig(sig, 8))
  91. {
  92. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  93. }
  94. else
  95. {
  96.     png_error(png_ptr, "Not a PNG file");
  97. }
  98. }
  100. void
  101. png_push_read_chunk(png_structp png_ptr, png_infop info)
  102. {
  103. if (!png_ptr->have_chunk_header)
  104. {
  105. png_byte chunk_start[8];
  107. if (png_ptr->buffer_size < 8)
  108. {
  109. png_push_save_buffer(png_ptr);
  110. return;
  111. }
  113. png_push_fill_buffer(png_ptr, chunk_start, 8);
  114. png_ptr->push_length = png_get_uint_32(chunk_start);
  115. png_memcpy(png_ptr->push_chunk_name, (png_voidp)(chunk_start + 4), 4);
  116. png_ptr->have_chunk_header = 1;
  117. png_reset_crc(png_ptr);
  118. png_calculate_crc(png_ptr, chunk_start + 4, 4);
  119. }
  121. if (!png_memcmp(png_ptr->push_chunk_name, png_IHDR, 4))
  122. {
  123. if (png_ptr->mode != PNG_BEFORE_IHDR)
  124. png_error(png_ptr, "Out of Place IHDR");
  126. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  127. {
  128. png_push_save_buffer(png_ptr);
  129. return;
  130. }
  132. png_handle_IHDR(png_ptr, info, png_ptr->push_length);
  133. png_push_check_crc(png_ptr);
  134. png_ptr->mode = PNG_HAVE_IHDR;
  135. }
  136. else if (!png_memcmp(png_ptr->push_chunk_name, png_PLTE, 4))
  137. {
  138. if (png_ptr->mode != PNG_HAVE_IHDR)
  139. png_error(png_ptr, "Missing IHDR");
  141. #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
  142. if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
  143. png_push_crc_skip(png_ptr, length);
  144. else
  145. #else
  146. {
  147. png_push_handle_PLTE(png_ptr, png_ptr->push_length);
  148. }
  149. #endif
  150. png_ptr->mode = PNG_HAVE_PLTE;
  151. }
  152. else if (!png_memcmp(png_ptr->push_chunk_name, png_IDAT, 4))
  153. {
  154. png_ptr->idat_size = png_ptr->push_length;
  155. png_ptr->mode = PNG_HAVE_IDAT;
  156. png_ptr->process_mode = PNG_READ_IDAT_MODE;
  157. png_push_have_info(png_ptr, info);
  158. png_ptr->zstream->avail_out = (uInt)png_ptr->irowbytes;
  159. png_ptr->zstream->next_out = png_ptr->row_buf;
  160. return;
  161. }
  162. else if (!png_memcmp(png_ptr->push_chunk_name, png_IEND, 4))
  163. {
  164. png_error(png_ptr, "No Image in File");
  165. }
  166. #if defined(PNG_READ_gAMA_SUPPORTED)
  167. else if (!png_memcmp(png_ptr->push_chunk_name, png_gAMA, 4))
  168. {
  169. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  170. {
  171. png_push_save_buffer(png_ptr);
  172. return;
  173. }
  175. if (png_ptr->mode != PNG_HAVE_IHDR)
  176. png_error(png_ptr, "Out of Place PLTE");
  178. png_handle_gAMA(png_ptr, info, png_ptr->push_length);
  179. png_push_check_crc(png_ptr);
  180. }
  181. #endif
  182. #if defined(PNG_READ_sBIT_SUPPORTED)
  183. else if (!png_memcmp(png_ptr->push_chunk_name, png_sBIT, 4))
  184. {
  185. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  186. {
  187. png_push_save_buffer(png_ptr);
  188. return;
  189. }
  191. if (png_ptr->mode != PNG_HAVE_IHDR)
  192. png_error(png_ptr, "Out of Place sBIT");
  194. png_handle_sBIT(png_ptr, info, png_ptr->push_length);
  195. png_push_check_crc(png_ptr);
  196. }
  197. #endif
  198. #if defined(PNG_READ_cHRM_SUPPORTED)
  199. else if (!png_memcmp(png_ptr->push_chunk_name, png_cHRM, 4))
  200. {
  201. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  202. {
  203. png_push_save_buffer(png_ptr);
  204. return;
  205. }
  207. if (png_ptr->mode != PNG_HAVE_IHDR)
  208. png_error(png_ptr, "Out of Place cHRM");
  210. png_handle_cHRM(png_ptr, info, png_ptr->push_length);
  211. png_push_check_crc(png_ptr);
  212. }
  213. #endif
  214. #if defined(PNG_READ_tRNS_SUPPORTED)
  215. else if (!png_memcmp(png_ptr->push_chunk_name, png_tRNS, 4))
  216. {
  217. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  218. {
  219. png_push_save_buffer(png_ptr);
  220. return;
  221. }
  222. if (png_ptr->mode != PNG_HAVE_IHDR &&
  223. png_ptr->mode != PNG_HAVE_PLTE)
  224. png_error(png_ptr, "Out of Place tRNS");
  226. png_handle_tRNS(png_ptr, info, png_ptr->push_length);
  227. png_push_check_crc(png_ptr);
  228. }
  229. #endif
  230. #if defined(PNG_READ_bKGD_SUPPORTED)
  231. else if (!png_memcmp(png_ptr->push_chunk_name, png_bKGD, 4))
  232. {
  233. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  234. {
  235. png_push_save_buffer(png_ptr);
  236. return;
  237. }
  239. if (png_ptr->mode != PNG_HAVE_IHDR &&
  240. png_ptr->mode != PNG_HAVE_PLTE)
  241. png_error(png_ptr, "Out of Place bKGD");
  243. png_handle_bKGD(png_ptr, info, png_ptr->push_length);
  244. png_push_check_crc(png_ptr);
  245. }
  246. #endif
  247. #if defined(PNG_READ_hIST_SUPPORTED)
  248. else if (!png_memcmp(png_ptr->push_chunk_name, png_hIST, 4))
  249. {
  250. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  251. {
  252. png_push_save_buffer(png_ptr);
  253. return;
  254. }
  256. if (png_ptr->mode != PNG_HAVE_PLTE)
  257. png_error(png_ptr, "Out of Place hIST");
  259. png_handle_hIST(png_ptr, info, png_ptr->push_length);
  260. png_push_check_crc(png_ptr);
  261. }
  262. #endif
  263. #if defined(PNG_READ_pHYs_SUPPORTED)
  264. else if (!png_memcmp(png_ptr->push_chunk_name, png_pHYs, 4))
  265. {
  266. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  267. {
  268. png_push_save_buffer(png_ptr);
  269. return;
  270. }
  272. if (png_ptr->mode != PNG_HAVE_IHDR &&
  273. png_ptr->mode != PNG_HAVE_PLTE)
  274. png_error(png_ptr, "Out of Place pHYs");
  276. png_handle_pHYs(png_ptr, info, png_ptr->push_length);
  277. png_push_check_crc(png_ptr);
  278. }
  279. #endif
  280. #if defined(PNG_READ_oFFs_SUPPORTED)
  281. else if (!png_memcmp(png_ptr->push_chunk_name, png_oFFs, 4))
  282. {
  283. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  284. {
  285. png_push_save_buffer(png_ptr);
  286. return;
  287. }
  289. if (png_ptr->mode != PNG_HAVE_IHDR &&
  290. png_ptr->mode != PNG_HAVE_PLTE)
  291. png_error(png_ptr, "Out of Place oFFs");
  293. png_handle_oFFs(png_ptr, info, png_ptr->push_length);
  294. png_push_check_crc(png_ptr);
  295. }
  296. #endif
  297. #if defined(PNG_READ_tIME_SUPPORTED)
  298. else if (!png_memcmp(png_ptr->push_chunk_name, png_tIME, 4))
  299. {
  300. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  301. {
  302. png_push_save_buffer(png_ptr);
  303. return;
  304. }
  306. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  307. png_ptr->mode == PNG_AFTER_IEND)
  308. png_error(png_ptr, "Out of Place tIME");
  310. png_handle_tIME(png_ptr, info, png_ptr->push_length);
  311. png_push_check_crc(png_ptr);
  312. }
  313. #endif
  314. #if defined(PNG_READ_tEXt_SUPPORTED)
  315. else if (!png_memcmp(png_ptr->push_chunk_name, png_tEXt, 4))
  316. {
  317. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  318. png_ptr->mode == PNG_AFTER_IEND)
  319. png_error(png_ptr, "Out of Place tEXt");
  321. png_push_handle_tEXt(png_ptr, png_ptr->push_length);
  322. }
  323. #endif
  324. #if defined(PNG_READ_zTXt_SUPPORTED)
  325. else if (!png_memcmp(png_ptr->push_chunk_name, png_zTXt, 4))
  326. {
  327. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  328. png_ptr->mode == PNG_AFTER_IEND)
  329. png_error(png_ptr, "Out of Place zTXt");
  331. png_push_handle_zTXt(png_ptr, png_ptr->push_length);
  332. }
  333. #endif
  334. else
  335. {
  336. if ((png_ptr->push_chunk_name[0] & 0x20) == 0)
  337. png_error(png_ptr, "Unknown Critical Chunk");
  339. png_push_crc_skip(png_ptr, png_ptr->push_length);
  340. }
  341. png_ptr->have_chunk_header = 0;
  342. }
  344. void
  345. png_push_check_crc(png_structp png_ptr)
  346. {
  347. png_byte crc_buf[4];
  348. png_uint_32 crc;
  350. png_push_fill_buffer(png_ptr, crc_buf, 4);
  351. crc = png_get_uint_32(crc_buf);
  352. if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
  353. (png_ptr->crc & 0xffffffffL))
  354. png_error(png_ptr, "Bad CRC value");
  355. }
  357. void
  358. png_push_crc_skip(png_structp png_ptr, png_uint_32 length)
  359. {
  360. png_ptr->process_mode = PNG_SKIP_MODE;
  361. png_ptr->skip_length = length;
  362. }
  364. void
  365. png_push_skip(png_structp png_ptr)
  366. {
  367. if (png_ptr->skip_length && png_ptr->save_buffer_size)
  368. {
  369. png_uint_32 save_size;
  371. if (png_ptr->skip_length < png_ptr->save_buffer_size)
  372. save_size = png_ptr->skip_length;
  373. else
  374. save_size = png_ptr->save_buffer_size;
  376. png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
  378. png_ptr->skip_length -= save_size;
  379. png_ptr->buffer_size -= save_size;
  380. png_ptr->save_buffer_size -= save_size;
  381. png_ptr->save_buffer_ptr += (png_size_t)save_size;
  382. }
  383. if (png_ptr->skip_length && png_ptr->current_buffer_size)
  384. {
  385. png_uint_32 save_size;
  387. if (png_ptr->skip_length < png_ptr->current_buffer_size)
  388. save_size = png_ptr->skip_length;
  389. else
  390. save_size = png_ptr->current_buffer_size;
  392. png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
  394. png_ptr->skip_length -= save_size;
  395. png_ptr->buffer_size -= save_size;
  396. png_ptr->current_buffer_size -= save_size;
  397. png_ptr->current_buffer_ptr += (png_size_t)save_size;
  398. }
  399. if (!png_ptr->skip_length && png_ptr->buffer_size >= 4)
  400. {
  401. png_push_check_crc(png_ptr);
  402. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  403. }
  404. }
  406. void
  407. png_push_fill_buffer(png_structp png_ptr, png_bytep buffer,
  408. png_uint_32 length)
  409. {
  410. png_bytep ptr;
  412. ptr = buffer;
  413. if (png_ptr->save_buffer_size)
  414. {
  415. png_uint_32 save_size;
  417. if (length < png_ptr->save_buffer_size)
  418. save_size = length;
  419. else
  420. save_size = png_ptr->save_buffer_size;
  422. png_memcpy(ptr, png_ptr->save_buffer_ptr, (png_size_t)save_size);
  423. length -= save_size;
  424. ptr += (png_size_t)save_size;
  425. png_ptr->buffer_size -= save_size;
  426. png_ptr->save_buffer_size -= save_size;
  427. png_ptr->save_buffer_ptr += (png_size_t)save_size;
  428. }
  429. if (length && png_ptr->current_buffer_size)
  430. {
  431. png_uint_32 save_size;
  433. if (length < png_ptr->current_buffer_size)
  434. save_size = length;
  435. else
  436. save_size = png_ptr->current_buffer_size;
  438. png_memcpy(ptr, png_ptr->current_buffer_ptr, (png_size_t)save_size);
  439. png_ptr->buffer_size -= save_size;
  440. png_ptr->current_buffer_size -= save_size;
  441. png_ptr->current_buffer_ptr += (png_size_t)save_size;
  442. }
  443. }
  445. void
  446. png_push_save_buffer(png_structp png_ptr)
  447. {
  448. if (png_ptr->save_buffer_size)
  449. {
  450. if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
  451. {
  452. int i;
  453. png_bytep sp;
  454. png_bytep dp;
  456. for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
  457. i < png_ptr->save_buffer_size;
  458. i++, sp++, dp++)
  459. {
  460.           *dp = *sp;
  461. }
  462. }
  463. }
  464. if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
  465. png_ptr->save_buffer_max)
  466. {
  467. int new_max;
  468. png_bytep old_buffer;
  470. new_max = (int)(png_ptr->save_buffer_size +
  471. png_ptr->current_buffer_size + 256);
  472. old_buffer = png_ptr->save_buffer;
  473. png_ptr->save_buffer = (png_bytep)
  474. png_large_malloc(png_ptr, new_max);
  475. png_memcpy(png_ptr->save_buffer, old_buffer,
  476. (png_size_t)png_ptr->save_buffer_size);
  477. png_large_free(png_ptr, old_buffer);
  478.   png_ptr->save_buffer_max = new_max;
  479. }
  480. if (png_ptr->current_buffer_size)
  481. {
  482. png_memcpy(png_ptr->save_buffer +
  483. (png_size_t)png_ptr->save_buffer_size,
  484. png_ptr->current_buffer_ptr,
  485. (png_size_t)png_ptr->current_buffer_size);
  486. png_ptr->save_buffer_size += png_ptr->current_buffer_size;
  487. png_ptr->current_buffer_size = 0;
  488. }
  489. png_ptr->save_buffer_ptr = png_ptr->save_buffer;
  490. png_ptr->buffer_size = 0;
  491. }
  493. void
  494. png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
  495. png_uint_32 buffer_length)
  496. {
  497. png_ptr->current_buffer = buffer;
  498. png_ptr->current_buffer_size = buffer_length;
  499. png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
  500. png_ptr->current_buffer_ptr = png_ptr->current_buffer;
  501. }
  503. void
  504. png_push_read_idat(png_structp png_ptr)
  505. {
  506. if (!png_ptr->have_chunk_header)
  507. {
  508. png_byte chunk_start[8];
  510. if (png_ptr->buffer_size < 8)
  511. {
  512. png_push_save_buffer(png_ptr);
  513. return;
  514. }
  516. png_push_fill_buffer(png_ptr, chunk_start, 8);
  517. png_ptr->push_length = png_get_uint_32(chunk_start);
  518. png_memcpy(png_ptr->push_chunk_name,
  519. (png_voidp)(chunk_start + 4), 4);
  520. png_ptr->have_chunk_header = 1;
  521. png_reset_crc(png_ptr);
  522. png_calculate_crc(png_ptr, chunk_start + 4, 4);
  523. if (png_memcmp(png_ptr->push_chunk_name, png_IDAT, 4))
  524. {
  525. png_ptr->process_mode = PNG_READ_END_MODE;
  526. if (!png_ptr->zlib_finished)
  527. png_error(png_ptr, "Not enough compressed data");
  528. return;
  529. }
  531. png_ptr->idat_size = png_ptr->push_length;
  532. }
  533. if (png_ptr->idat_size && png_ptr->save_buffer_size)
  534. {
  535. png_uint_32 save_size;
  537. if (png_ptr->idat_size < png_ptr->save_buffer_size)
  538. save_size = png_ptr->idat_size;
  539. else
  540. save_size = png_ptr->save_buffer_size;
  542. png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
  543. png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
  545. png_ptr->idat_size -= save_size;
  546. png_ptr->buffer_size -= save_size;
  547. png_ptr->save_buffer_size -= save_size;
  548. png_ptr->save_buffer_ptr += (png_size_t)save_size;
  549. }
  550. if (png_ptr->idat_size && png_ptr->current_buffer_size)
  551. {
  552. png_uint_32 save_size;
  554. if (png_ptr->idat_size < png_ptr->current_buffer_size)
  555. save_size = png_ptr->idat_size;
  556. else
  557. save_size = png_ptr->current_buffer_size;
  559. png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
  560. png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
  562. png_ptr->idat_size -= save_size;
  563. png_ptr->buffer_size -= save_size;
  564. png_ptr->current_buffer_size -= save_size;
  565. png_ptr->current_buffer_ptr += (png_size_t)save_size;
  566. }
  567. if (!png_ptr->idat_size && png_ptr->buffer_size >= 4)
  568. {
  569. png_push_check_crc(png_ptr);
  570. png_ptr->have_chunk_header = 0;
  571. }
  572. }
  574. void
  575. png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
  576. png_uint_32 buffer_length)
  577. {
  578. int ret;
  580. if (png_ptr->zlib_finished && buffer_length)
  581.     png_error(png_ptr, "Extra compression data");
  583. png_ptr->zstream->next_in = buffer;
  584. png_ptr->zstream->avail_in = (uInt)buffer_length;
  585. do
  586. {
  587. ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
  588. if (ret == Z_STREAM_END)
  589. {
  590. if (png_ptr->zstream->avail_in)
  591. png_error(png_ptr, "Extra compressed data");
  592. if (!png_ptr->zstream->avail_out)
  593. {
  594. png_push_process_row(png_ptr);
  595. }
  596. png_ptr->mode = PNG_AT_LAST_IDAT;
  597. png_ptr->zlib_finished = 1;
  598. break;
  599. }
  600. if (ret != Z_OK)
  601. png_error(png_ptr, "Compression Error");
  602. if (!(png_ptr->zstream->avail_out))
  603. {
  604. png_push_process_row(png_ptr);
  605. png_ptr->zstream->avail_out = (uInt)png_ptr->irowbytes;
  606. png_ptr->zstream->next_out = png_ptr->row_buf;
  607. }
  609. } while (png_ptr->zstream->avail_in);
  610. }
  612. void
  613. png_push_process_row(png_structp png_ptr)
  614. {
  615. png_ptr->row_info.color_type = png_ptr->color_type;
  616.    png_ptr->row_info.width = png_ptr->iwidth;
  617.    png_ptr->row_info.channels = png_ptr->channels;
  618.    png_ptr->row_info.bit_depth = png_ptr->bit_depth;
  619.    png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
  620.    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
  621.       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
  623. if (png_ptr->row_buf[0])
  624.       png_read_filter_row(&(png_ptr->row_info),
  625.          png_ptr->row_buf + 1, png_ptr->prev_row + 1,
  626. (int)(png_ptr->row_buf[0]));
  628.    png_memcpy(png_ptr->prev_row, png_ptr->row_buf, (png_size_t)png_ptr->rowbytes + 1);
  630.    if (png_ptr->transformations)
  631.       png_do_read_transformations(png_ptr);
  633. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  634. /* blow up interlaced rows to full size */
  635. if (png_ptr->interlaced &&
  636. (png_ptr->transformations & PNG_INTERLACE))
  637. {
  638. if (png_ptr->pass < 6)
  639. png_do_read_interlace(&(png_ptr->row_info),
  640. png_ptr->row_buf + 1, png_ptr->pass);
  642. switch (png_ptr->pass)
  643. {
  644. case 0:
  645. {
  646. int i;
  647. for (i = 0; i < 8 && png_ptr->pass == 0; i++)
  648. {
  649. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  650. png_read_push_finish_row(png_ptr);
  651. }
  652. break;
  653. }
  654. case 1:
  655. {
  656. int i;
  657. for (i = 0; i < 8 && png_ptr->pass == 1; i++)
  658. {
  659. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  660. png_read_push_finish_row(png_ptr);
  661. }
  662. if (png_ptr->pass == 2)
  663. {
  664. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  665. {
  666. png_push_have_row(png_ptr, NULL);
  667. png_read_push_finish_row(png_ptr);
  668. }
  669. }
  670. break;
  671. }
  672. case 2:
  673. {
  674. int i;
  675. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  676. {
  677. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  678. png_read_push_finish_row(png_ptr);
  679. }
  680. for (i = 0; i < 4 && png_ptr->pass == 2; i++)
  681. {
  682. png_push_have_row(png_ptr, NULL);
  683. png_read_push_finish_row(png_ptr);
  684. }
  685. break;
  686. }
  687. case 3:
  688. {
  689. int i;
  690. for (i = 0; i < 4 && png_ptr->pass == 3; i++)
  691. {
  692. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  693. png_read_push_finish_row(png_ptr);
  694. }
  695. if (png_ptr->pass == 4)
  696. {
  697. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  698. {
  699. png_push_have_row(png_ptr, NULL);
  700. png_read_push_finish_row(png_ptr);
  701. }
  702. }
  703. break;
  704. }
  705. case 4:
  706. {
  707. int i;
  708. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  709. {
  710. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  711. png_read_push_finish_row(png_ptr);
  712. }
  713. for (i = 0; i < 2 && png_ptr->pass == 4; i++)
  714. {
  715. png_push_have_row(png_ptr, NULL);
  716. png_read_push_finish_row(png_ptr);
  717. }
  718. break;
  719. }
  720. case 5:
  721. {
  722. int i;
  723. for (i = 0; i < 2 && png_ptr->pass == 5; i++)
  724. {
  725. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  726. png_read_push_finish_row(png_ptr);
  727. }
  728. if (png_ptr->pass == 6)
  729. {
  730. png_push_have_row(png_ptr, NULL);
  731. png_read_push_finish_row(png_ptr);
  732. }
  733. break;
  734. }
  735. case 6:
  736. {
  737. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  738. png_read_push_finish_row(png_ptr);
  739. if (png_ptr->pass != 6)
  740. break;
  741. png_push_have_row(png_ptr, NULL);
  742. png_read_push_finish_row(png_ptr);
  743. }
  744. }
  745. }
  746. else
  747. #endif
  748. {
  749. png_push_have_row(png_ptr, png_ptr->row_buf + 1);
  750. png_read_push_finish_row(png_ptr);
  751. }
  752. }
  754. void
  755. png_read_push_finish_row(png_structp png_ptr)
  756. {
  757.    png_ptr->row_number++;
  758.    if (png_ptr->row_number < png_ptr->num_rows)
  759. return;
  761.    if (png_ptr->interlaced)
  762.    {
  763.       png_ptr->row_number = 0;
  764.       png_memset(png_ptr->prev_row, 0, (png_size_t)png_ptr->rowbytes + 1);
  765.       do
  766.       {
  767.          png_ptr->pass++;
  768.          if (png_ptr->pass >= 7)
  769.             break;
  770.          png_ptr->iwidth = (png_ptr->width +
  771.             png_pass_inc[png_ptr->pass] - 1 -
  772.             png_pass_start[png_ptr->pass]) /
  773.             png_pass_inc[png_ptr->pass];
  774.          png_ptr->irowbytes = ((png_ptr->iwidth *
  775.             png_ptr->pixel_depth + 7) >> 3) + 1;
  776.          if (!(png_ptr->transformations & PNG_INTERLACE))
  777. {
  778.             png_ptr->num_rows = (png_ptr->height +
  779.                png_pass_yinc[png_ptr->pass] - 1 -
  780.                png_pass_ystart[png_ptr->pass]) /
  781.                png_pass_yinc[png_ptr->pass];
  782.             if (!(png_ptr->num_rows))
  783.                continue;
  784.          }
  785.          if (png_ptr->transformations & PNG_INTERLACE)
  786.             break;
  787.       } while (png_ptr->iwidth == 0);
  788.    }
  789. }
  792. void
  793. png_push_handle_PLTE(png_structp png_ptr, png_uint_32 length)
  794. {
  795. if (length % 3)
  796. png_error(png_ptr, "Invalid Palette Chunk");
  798. png_ptr->num_palette = (png_uint_16)(length / 3);
  799. png_ptr->cur_palette = 0;
  800. png_ptr->palette = (png_colorp)png_large_malloc(png_ptr,
  801. png_ptr->num_palette * sizeof (png_color));
  802. png_ptr->process_mode = PNG_READ_PLTE_MODE;
  803. }
  805. void
  806. png_push_read_plte(png_structp png_ptr, png_infop info)
  807. {
  808. while (png_ptr->cur_palette < png_ptr->num_palette &&
  809. png_ptr->buffer_size >= 3)
  810. {
  811. png_byte buf[3];
  812. png_push_fill_buffer(png_ptr, buf, 3);
  813. png_calculate_crc(png_ptr, buf, 3);
  815. /* don't depend upon png_color being any order */
  816. png_ptr->palette[png_ptr->cur_palette].red = buf[0];
  817. png_ptr->palette[png_ptr->cur_palette].green = buf[1];
  818. png_ptr->palette[png_ptr->cur_palette].blue = buf[2];
  819. png_ptr->cur_palette++;
  820. }
  821. if (png_ptr->cur_palette == png_ptr->num_palette &&
  822. png_ptr->buffer_size >= 4)
  823. {
  824. png_push_check_crc(png_ptr);
  825. png_read_PLTE(png_ptr, info, png_ptr->palette, png_ptr->num_palette);
  826. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  827. }
  828. else
  829. {
  830. png_push_save_buffer(png_ptr);
  831. }
  832. }
  834. #if defined(PNG_READ_tEXt_SUPPORTED)
  835. void
  836. png_push_handle_tEXt(png_structp png_ptr, png_uint_32 length)
  837. {
  838. png_ptr->current_text = (png_charp)png_large_malloc(png_ptr, length + 1);
  839. png_ptr->current_text[(png_size_t)length] = '';
  840. png_ptr->current_text_ptr = png_ptr->current_text;
  841. png_ptr->current_text_size = length;
  842. png_ptr->current_text_left = length;
  843. png_ptr->process_mode = PNG_READ_tEXt_MODE;
  844. }
  846. void
  847. png_push_read_text(png_structp png_ptr, png_infop info)
  848. {
  849. if (png_ptr->buffer_size && png_ptr->current_text_left)
  850. {
  851. png_uint_32 text_size;
  853. if (png_ptr->buffer_size < png_ptr->current_text_left)
  854. text_size = png_ptr->buffer_size;
  855. else
  856. text_size = png_ptr->current_text_left;
  857. png_push_fill_buffer(png_ptr, (png_bytep)png_ptr->current_text_ptr,
  858. text_size);
  859. png_calculate_crc(png_ptr, (png_bytep)png_ptr->current_text_ptr,
  860. text_size);
  861. png_ptr->current_text_left -= text_size;
  862. png_ptr->current_text_ptr += (png_size_t)text_size;
  863. }
  864. if (!(png_ptr->current_text_left) && png_ptr->buffer_size >= 4)
  865. {
  866. png_charp text;
  867. png_charp key;
  869. png_push_check_crc(png_ptr);
  871. key = png_ptr->current_text;
  872. png_ptr->current_text = 0;
  874. for (text = key; *text; text++)
  875. /* empty loop */ ;
  877. if (text != key + (png_size_t)png_ptr->current_text_size)
  878. text++;
  880. png_read_tEXt(png_ptr, info, key, text,
  881. png_ptr->current_text_size - (text - key));
  882. png_ptr->process_mode = PNG_READ_CHUNK_MODE;
  883. }
  884. }
  885. #endif
  887. #if defined(PNG_READ_zTXt_SUPPORTED)
  888. void
  889. png_push_handle_zTXt(png_structp png_ptr,
  890. png_uint_32 length)
  891. {
  892. png_ptr->current_text = (png_charp)png_large_malloc(png_ptr, length + 1);
  893. png_ptr->current_text[(png_size_t)length] = '';
  894. png_ptr->current_text_ptr = png_ptr->current_text;
  895. png_ptr->current_text_size = length;
  896. png_ptr->current_text_left = length;
  897. png_ptr->process_mode = PNG_READ_zTXt_MODE;
  898. }
  900. void
  901. png_push_read_ztxt(png_structp png_ptr, png_infop info)
  902. {
  903. if (png_ptr->buffer_size && png_ptr->current_text_left)
  904. {
  905. png_uint_32 text_size;
  907. if (png_ptr->buffer_size < png_ptr->current_text_left)
  908. text_size = png_ptr->buffer_size;
  909. else
  910. text_size = png_ptr->current_text_left;
  911. png_push_fill_buffer(png_ptr, (png_bytep)png_ptr->current_text_ptr,
  912. text_size);
  913. png_calculate_crc(png_ptr, (png_bytep)png_ptr->current_text_ptr,
  914. text_size);
  915. png_ptr->current_text_left -= text_size;
  916. png_ptr->current_text_ptr += (png_size_t)text_size;
  917. }
  918. if (!(png_ptr->current_text_left) && png_ptr->buffer_size >= 4)
  919. {
  920. png_charp text;
  921. png_charp key;
  922. int ret;
  923. png_uint_32 text_size, key_size;
  925. png_push_check_crc(png_ptr);
  927. key = png_ptr->current_text;
  928. png_ptr->current_text = 0;
  930. for (text = key; *text; text++)
  931. /* empty loop */ ;
  933. /* zTXt can't have zero text */
  934. if (text == key + (png_size_t)png_ptr->current_text_size)
  935. {
  936. png_large_free(png_ptr, key);
  937. return;
  938. }
  940. text++;
  942. if (*text) /* check compression byte */
  943. {
  944. png_large_free(png_ptr, key);
  945. return;
  946. }
  948. text++;
  950. png_ptr->zstream->next_in = (png_bytep )text;
  951. png_ptr->zstream->avail_in = (uInt)(png_ptr->current_text_size -
  952. (text - key));
  953. png_ptr->zstream->next_out = png_ptr->zbuf;
  954. png_ptr->zstream->avail_out = (png_size_t)png_ptr->zbuf_size;
  956. key_size = text - key;
  957. text_size = 0;
  958. text = NULL;
  959. ret = Z_STREAM_END;
  961. while (png_ptr->zstream->avail_in)
  962. {
  963. ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
  964. if (ret != Z_OK && ret != Z_STREAM_END)
  965. {
  966. inflateReset(png_ptr->zstream);
  967. png_ptr->zstream->avail_in = 0;
  968. png_large_free(png_ptr, key);
  969. png_large_free(png_ptr, text);
  970. return;
  971. }
  972. if (!png_ptr->zstream->avail_out || ret == Z_STREAM_END)
  973. {
  974. if (!text)
  975. {
  976. text = (png_charp)png_large_malloc(png_ptr,
  977. png_ptr->zbuf_size - png_ptr->zstream->avail_out +
  978. key_size + 1);
  979. png_memcpy(text + (png_size_t)key_size, png_ptr->zbuf,
  980. (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
  981. png_memcpy(text, key, (png_size_t)key_size);
  982. text_size = key_size + (png_size_t)png_ptr->zbuf_size -
  983. png_ptr->zstream->avail_out;
  984. *(text + (png_size_t)text_size) = '';
  985. }
  986. else
  987. {
  988. png_charp tmp;
  990. tmp = text;
  991. text = png_large_malloc(png_ptr, text_size +
  992. png_ptr->zbuf_size - png_ptr->zstream->avail_out + 1);
  993. png_memcpy(text, tmp, (png_size_t)text_size);
  994. png_large_free(png_ptr, tmp);
  995. png_memcpy(text + (png_size_t)text_size, png_ptr->zbuf,
  996. (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
  997. text_size += png_ptr->zbuf_size - png_ptr->zstream->avail_out;
  998. *(text + (png_size_t)text_size) = '';
  999. }
  1000. if (ret != Z_STREAM_END)
  1001. {
  1002. png_ptr->zstream->next_out = png_ptr->zbuf;
  1003. png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
  1004. }
  1005. }
  1006. else
  1007. {
  1008. break;
  1009. }
  1011. if (ret == Z_STREAM_END)
  1012. break;
  1013. }
  1015. inflateReset(png_ptr->zstream);
  1016. png_ptr->zstream->avail_in = 0;
  1018. if (ret != Z_STREAM_END)
  1019. {
  1020. png_large_free(png_ptr, key);
  1021. png_large_free(png_ptr, text);
  1022. return;
  1023. }
  1025. png_large_free(png_ptr, key);
  1026. key = text;
  1027. text += (png_size_t)key_size;
  1028. text_size -= key_size;
  1030. png_read_zTXt(png_ptr, info, key, text, text_size, 0);
  1031. }
  1032. }
  1033. #endif
  1035. void
  1036. png_push_have_info(png_structp png_ptr, png_infop info)
  1037. {
  1038. if (png_ptr->info_fn)
  1039. (*(png_ptr->info_fn))(png_ptr, info);
  1040. }
  1042. void
  1043. png_push_have_end(png_structp png_ptr, png_infop info)
  1044. {
  1045. if (png_ptr->end_fn)
  1046. (*(png_ptr->end_fn))(png_ptr, info);
  1047. }
  1049. void
  1050. png_push_have_row(png_structp png_ptr, png_bytep row)
  1051. {
  1052. if (png_ptr->row_fn)
  1053. (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
  1054. (int)png_ptr->pass);
  1055. }
  1057. png_voidp
  1058. png_get_progressive_ptr(png_structp png_ptr)
  1059. {
  1060. return png_ptr->push_ptr;
  1061. }
  1063. void
  1064. png_push_read_end(png_structp png_ptr, png_infop info)
  1065. {
  1066. if (!png_ptr->have_chunk_header)
  1067. {
  1068. png_byte chunk_start[8];
  1070. if (png_ptr->buffer_size < 8)
  1071. {
  1072. png_push_save_buffer(png_ptr);
  1073. return;
  1074. }
  1076. png_push_fill_buffer(png_ptr, chunk_start, 8);
  1077. png_ptr->push_length = png_get_uint_32(chunk_start);
  1078. png_memcpy(png_ptr->push_chunk_name, (png_voidp)(chunk_start + 4), 4);
  1079. png_ptr->have_chunk_header = 1;
  1080. png_reset_crc(png_ptr);
  1081. png_calculate_crc(png_ptr, chunk_start + 4, 4);
  1082. }
  1084. if (!png_memcmp(png_ptr->push_chunk_name, png_IHDR, 4))
  1085. {
  1086. png_error(png_ptr, "invalid chunk after IDAT");
  1087. }
  1088. else if (!png_memcmp(png_ptr->push_chunk_name, png_PLTE, 4))
  1089. {
  1090. png_error(png_ptr, "invalid chunk after IDAT");
  1091. }
  1092. else if (!png_memcmp(png_ptr->push_chunk_name, png_IDAT, 4))
  1093. {
  1094. if (png_ptr->push_length > 0 || png_ptr->mode != PNG_AT_LAST_IDAT)
  1095. png_error(png_ptr, "too many IDAT's found");
  1096. }
  1097. else if (!png_memcmp(png_ptr->push_chunk_name, png_IEND, 4))
  1098. {
  1099. if (png_ptr->push_length)
  1100.        png_error(png_ptr, "Invalid IEND chunk");
  1101. png_push_check_crc(png_ptr);
  1102. png_ptr->mode = PNG_AFTER_IEND;
  1103. png_ptr->process_mode = PNG_READ_DONE_MODE;
  1104. png_push_have_end(png_ptr, info);
  1105. }
  1106. #if defined(PNG_READ_gAMA_SUPPORTED)
  1107. else if (!png_memcmp(png_ptr->push_chunk_name, png_gAMA, 4))
  1108. {
  1109. png_error(png_ptr, "invalid chunk after IDAT");
  1110. }
  1111. #endif
  1112. #if defined(PNG_READ_sBIT_SUPPORTED)
  1113. else if (!png_memcmp(png_ptr->push_chunk_name, png_sBIT, 4))
  1114. {
  1115. png_error(png_ptr, "invalid chunk after IDAT");
  1116. }
  1117. #endif
  1118. #if defined(PNG_READ_cHRM_SUPPORTED)
  1119. else if (!png_memcmp(png_ptr->push_chunk_name, png_cHRM, 4))
  1120. {
  1121. png_error(png_ptr, "invalid chunk after IDAT");
  1122. }
  1123. #endif
  1124. #if defined(PNG_READ_tRNS_SUPPORTED)
  1125. else if (!png_memcmp(png_ptr->push_chunk_name, png_tRNS, 4))
  1126. {
  1127. png_error(png_ptr, "invalid chunk after IDAT");
  1128. }
  1129. #endif
  1130. #if defined(PNG_READ_bKGD_SUPPORTED)
  1131. else if (!png_memcmp(png_ptr->push_chunk_name, png_bKGD, 4))
  1132. {
  1133. png_error(png_ptr, "invalid chunk after IDAT");
  1134. }
  1135. #endif
  1136. #if defined(PNG_READ_hIST_SUPPORTED)
  1137. else if (!png_memcmp(png_ptr->push_chunk_name, png_hIST, 4))
  1138. {
  1139. png_error(png_ptr, "invalid chunk after IDAT");
  1140. }
  1141. #endif
  1142. #if defined(PNG_READ_pHYs_SUPPORTED)
  1143. else if (!png_memcmp(png_ptr->push_chunk_name, png_pHYs, 4))
  1144. {
  1145. png_error(png_ptr, "invalid chunk after IDAT");
  1146. }
  1147. #endif
  1148. #if defined(PNG_READ_oFFs_SUPPORTED)
  1149. else if (!png_memcmp(png_ptr->push_chunk_name, png_oFFs, 4))
  1150. {
  1151. png_error(png_ptr, "invalid chunk after IDAT");
  1152. }
  1153. #endif
  1154. #if defined(PNG_READ_tIME_SUPPORTED)
  1155. else if (!png_memcmp(png_ptr->push_chunk_name, png_tIME, 4))
  1156. {
  1157. if (png_ptr->push_length + 4 > png_ptr->buffer_size)
  1158. {
  1159. png_push_save_buffer(png_ptr);
  1160. return;
  1161. }
  1163. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  1164. png_ptr->mode == PNG_AFTER_IEND)
  1165. png_error(png_ptr, "Out of Place tIME");
  1167. png_handle_tIME(png_ptr, info, png_ptr->push_length);
  1168. png_push_check_crc(png_ptr);
  1169. }
  1170. #endif
  1171. #if defined(PNG_READ_tEXt_SUPPORTED)
  1172. else if (!png_memcmp(png_ptr->push_chunk_name, png_tEXt, 4))
  1173. {
  1174. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  1175. png_ptr->mode == PNG_AFTER_IEND)
  1176. png_error(png_ptr, "Out of Place tEXt");
  1178. png_push_handle_tEXt(png_ptr, png_ptr->push_length);
  1179. }
  1180. #endif
  1181. #if defined(PNG_READ_zTXt_SUPPORTED)
  1182. else if (!png_memcmp(png_ptr->push_chunk_name, png_zTXt, 4))
  1183. {
  1184. if (png_ptr->mode == PNG_BEFORE_IHDR ||
  1185. png_ptr->mode == PNG_AFTER_IEND)
  1186. png_error(png_ptr, "Out of Place zTXt");
  1188. png_push_handle_zTXt(png_ptr, png_ptr->push_length);
  1189. }
  1190. #endif
  1191. else
  1192. {
  1193. if ((png_ptr->push_chunk_name[0] & 0x20) == 0)
  1194. png_error(png_ptr, "Unknown Critical Chunk");
  1196. png_push_crc_skip(png_ptr, png_ptr->push_length);
  1197. }
  1198. if (png_ptr->mode == PNG_AT_LAST_IDAT)
  1199. png_ptr->mode = PNG_AFTER_IDAT;
  1200. png_ptr->have_chunk_header = 0;
  1201. }
  1203. void
  1204. png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
  1205. png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
  1206. png_progressive_end_ptr end_fn)
  1207. {
  1208. png_ptr->info_fn = info_fn;
  1209. png_ptr->row_fn = row_fn;
  1210. png_ptr->push_ptr = progressive_ptr;
  1211.    png_ptr->end_fn = end_fn;
  1212. png_ptr->read_mode = PNG_READ_PUSH_MODE;
  1213. }
  1215. void
  1216. png_progressive_combine_row (png_structp png_ptr,
  1217. png_bytep old_row, png_bytep new_row)
  1218. {
  1219. if (new_row)
  1220. png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
  1221. }
  1223. #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */