Category

Development Platform
Home > SourceCode/Document > Internet-Socket-Network > Browser Client > View Code
pngrutil.c
Package: arena-beta-2b-src.tar.gz　[view]
Upload User: zlh9724
Upload Date: 2007-01-04
Package Size: 1991k
Code Size: 34k
Category:

Browser Client

Development Platform:

Unix_Linux

pngrutil.c：Code Content
  2. /* pngrutil.c - utilities to read a png file
  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. /* grab an uint 32 from a buffer */
  14. png_uint_32
  15. png_get_uint_32(png_bytep buf)
  16. {
  17.    png_uint_32 i;
  19.    i = ((png_uint_32)(*buf) << 24) +
  20.       ((png_uint_32)(*(buf + 1)) << 16) +
  21.       ((png_uint_32)(*(buf + 2)) << 8) +
  22.       (png_uint_32)(*(buf + 3));
  24.    return i;
  25. }
  27. /* grab an uint 16 from a buffer */
  28. png_uint_16
  29. png_get_uint_16(png_bytep buf)
  30. {
  31.    png_uint_16 i;
  33. i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
  34. (png_uint_16)(*(buf + 1)));
  36.    return i;
  37. }
  39. /* read data, and run it through the crc */
  40. void
  41. png_crc_read(png_structp png_ptr, png_bytep buf, png_uint_32 length)
  42. {
  43.    png_read_data(png_ptr, buf, length);
  44.    png_calculate_crc(png_ptr, buf, length);
  45. }
  47. /* skip data, but calcuate the crc anyway */
  48. void
  49. png_crc_skip(png_structp png_ptr, png_uint_32 length)
  50. {
  51.    png_uint_32 i;
  53.    for (i = length; i > png_ptr->zbuf_size; i -= png_ptr->zbuf_size)
  54.    {
  55.       png_read_data(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
  56.       png_calculate_crc(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
  57.    }
  58.    if (i)
  59.    {
  60.       png_read_data(png_ptr, png_ptr->zbuf, i);
  61.       png_calculate_crc(png_ptr, png_ptr->zbuf, i);
  62.    }
  63. }
  65. /* read and check the IDHR chunk */
  66. void
  67. png_handle_IHDR(png_structp png_ptr, png_infop info, png_uint_32 length)
  68. {
  69.    png_byte buf[13];
  70.    png_uint_32 width, height;
  71.    int bit_depth, color_type, compression_type, filter_type;
  72.    int interlace_type;
  74.    /* check the length */
  75.    if (length != 13)
  76.       png_error(png_ptr, "Invalid IHDR chunk");
  78.    png_crc_read(png_ptr, buf, 13);
  80.    width = png_get_uint_32(buf);
  81.    height = png_get_uint_32(buf + 4);
  82.    bit_depth = buf[8];
  83.    color_type = buf[9];
  84.    compression_type = buf[10];
  85.    filter_type = buf[11];
  86.    interlace_type = buf[12];
  88.    /* check for width and height valid values */
  89.    if (width == 0 || height == 0)
  90.       png_error(png_ptr, "Invalid Width or Height Found");
  92.    /* check other values */
  93.    if (bit_depth != 1 && bit_depth != 2 &&
  94.       bit_depth != 4 && bit_depth != 8 &&
  95.       bit_depth != 16)
  96.       png_error(png_ptr, "Invalid Bit Depth Found");
  98.    if (color_type < 0 || color_type == 1 ||
  99.       color_type == 5 || color_type > 6)
  100.       png_error(png_ptr, "Invalid Color Type Found");
  102. if (color_type == PNG_COLOR_TYPE_PALETTE &&
  103.       bit_depth == 16)
  104.       png_error(png_ptr, "Found Invalid Color Type and Bit Depth Combination");
  106.    if ((color_type == PNG_COLOR_TYPE_RGB ||
  107.       color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
  108.       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
  109.       bit_depth < 8)
  110.       png_error(png_ptr, "Found Invalid Color Type and Bit Depth Combination");
  112.    if (interlace_type > 1)
  113.       png_error(png_ptr, "Found Invalid Interlace Value");
  115.    if (compression_type > 0)
  116.       png_error(png_ptr, "Found Invalid Compression Value");
  118.    if (filter_type > 0)
  119.       png_error(png_ptr, "Found Invalid Filter Value");
  121.    /* set internal variables */
  122.    png_ptr->width = width;
  123.    png_ptr->height = height;
  124. png_ptr->bit_depth = (png_byte)bit_depth;
  125. png_ptr->interlaced = (png_byte)interlace_type;
  126. png_ptr->color_type = (png_byte)color_type;
  128.    /* find number of channels */
  129.    switch (png_ptr->color_type)
  130.    {
  131.       case 0:
  132.       case 3:
  133.          png_ptr->channels = 1;
  134.          break;
  135.       case 2:
  136.          png_ptr->channels = 3;
  137.          break;
  138.       case 4:
  139.          png_ptr->channels = 2;
  140.          break;
  141.       case 6:
  142.          png_ptr->channels = 4;
  143.          break;
  144.    }
  145.    /* set up other useful info */
  146. png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
  147. png_ptr->channels);
  148.    png_ptr->rowbytes = ((png_ptr->width *
  149.       (png_uint_32)png_ptr->pixel_depth + 7) >> 3);
  150.    /* call the IHDR callback (which should just set up info) */
  151.    png_read_IHDR(png_ptr, info, width, height, bit_depth,
  152.       color_type, compression_type, filter_type, interlace_type);
  153. }
  155. /* read and check the palette */
  156. void
  157. png_handle_PLTE(png_structp png_ptr, png_infop info, png_uint_32 length)
  158. {
  159.    int num, i;
  160.    png_colorp palette;
  162.    if (length % 3)
  163.       png_error(png_ptr, "Invalid Palette Chunk");
  165.    num = (int)length / 3;
  166.    palette = (png_colorp)png_large_malloc(png_ptr, num * sizeof (png_color));
  167.    png_ptr->do_free |= PNG_FREE_PALETTE;
  168. for (i = 0; i < num; i++)
  169.    {
  170.       png_byte buf[3];
  172.       png_crc_read(png_ptr, buf, 3);
  173.       /* don't depend upon png_color being any order */
  174.       palette[i].red = buf[0];
  175.       palette[i].green = buf[1];
  176.       palette[i].blue = buf[2];
  177.    }
  178.    png_ptr->palette = palette;
  179. png_ptr->num_palette = (png_uint_16)num;
  180.    png_read_PLTE(png_ptr, info, palette, num);
  181. }
  183. #if defined(PNG_READ_gAMA_SUPPORTED)
  184. void
  185. png_handle_gAMA(png_structp png_ptr, png_infop info, png_uint_32 length)
  186. {
  187.    png_uint_32 igamma;
  188.    float gamma;
  189.    png_byte buf[4];
  191.    if (length != 4)
  192.    {
  193.       png_warning(png_ptr, "Incorrect gAMA chunk length");
  194. png_crc_skip(png_ptr, length);
  195.       return;
  196.    }
  198.    png_crc_read(png_ptr, buf, 4);
  199.    igamma = png_get_uint_32(buf);
  200.    /* check for zero gamma */
  201.    if (!igamma)
  202. return;
  204.    gamma = (float)igamma / (float)100000.0;
  205.    png_read_gAMA(png_ptr, info, gamma);
  206.    png_ptr->gamma = gamma;
  207. }
  208. #endif
  210. #if defined(PNG_READ_sBIT_SUPPORTED)
  211. void
  212. png_handle_sBIT(png_structp png_ptr, png_infop info, png_uint_32 length)
  213. {
  214.    int slen;
  215. png_byte buf[4];
  217.    buf[0] = buf[1] = buf[2] = buf[3] = 0;
  219.    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  220.       slen = 3;
  221.    else
  222. slen = png_ptr->channels;
  224.    if (length != (png_uint_32)slen)
  225.    {
  226.       png_warning(png_ptr, "Incorrect sBIT chunk length");
  227. png_crc_skip(png_ptr, length);
  228. return;
  229.    }
  231.    png_crc_read(png_ptr, buf, length);
  232.    if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  233.    {
  234.       png_ptr->sig_bit.red = buf[0];
  235.       png_ptr->sig_bit.green = buf[1];
  236.       png_ptr->sig_bit.blue = buf[2];
  237.       png_ptr->sig_bit.alpha = buf[3];
  238.    }
  239.    else
  240.    {
  241. png_ptr->sig_bit.gray = buf[0];
  242.       png_ptr->sig_bit.alpha = buf[1];
  243.    }
  244.    png_read_sBIT(png_ptr, info, &(png_ptr->sig_bit));
  245. }
  246. #endif
  248. #if defined(PNG_READ_cHRM_SUPPORTED)
  249. void
  250. png_handle_cHRM(png_structp png_ptr, png_infop info, png_uint_32 length)
  251. {
  252.    png_byte buf[4];
  253.    png_uint_32 v;
  254.    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
  256.    if (length != 32)
  257.    {
  258.       png_warning(png_ptr, "Incorrect cHRM chunk length");
  259. png_crc_skip(png_ptr, length);
  260. return;
  261.    }
  263.    png_crc_read(png_ptr, buf, 4);
  264.    v = png_get_uint_32(buf);
  265.    white_x = (float)v / (float)100000.0;
  267.    png_crc_read(png_ptr, buf, 4);
  268.    v = png_get_uint_32(buf);
  269.    white_y = (float)v / (float)100000.0;
  271.    png_crc_read(png_ptr, buf, 4);
  272.    v = png_get_uint_32(buf);
  273.    red_x = (float)v / (float)100000.0;
  275.    png_crc_read(png_ptr, buf, 4);
  276.    v = png_get_uint_32(buf);
  277.    red_y = (float)v / (float)100000.0;
  279.    png_crc_read(png_ptr, buf, 4);
  280.    v = png_get_uint_32(buf);
  281.    green_x = (float)v / (float)100000.0;
  283.    png_crc_read(png_ptr, buf, 4);
  284.    v = png_get_uint_32(buf);
  285.    green_y = (float)v / (float)100000.0;
  287.    png_crc_read(png_ptr, buf, 4);
  288.    v = png_get_uint_32(buf);
  289.    blue_x = (float)v / (float)100000.0;
  291.    png_crc_read(png_ptr, buf, 4);
  292.    v = png_get_uint_32(buf);
  293.    blue_y = (float)v / (float)100000.0;
  295.    png_read_cHRM(png_ptr, info,
  296. white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
  297. }
  298. #endif
  300. #if defined(PNG_READ_tRNS_SUPPORTED)
  301. void
  302. png_handle_tRNS(png_structp png_ptr, png_infop info, png_uint_32 length)
  303. {
  304.    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  305.    {
  306.       if (length > png_ptr->num_palette)
  307.       {
  308.          png_warning(png_ptr, "Incorrect tRNS chunk length");
  309. png_crc_skip(png_ptr, length);
  310.          return;
  311.       }
  313.       png_ptr->trans = (png_bytep)png_large_malloc(png_ptr, length);
  314.       png_ptr->do_free |= PNG_FREE_TRANS;
  315. png_crc_read(png_ptr, png_ptr->trans, length);
  316. png_ptr->num_trans = (png_uint_16)length;
  317.    }
  318.    else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
  319.    {
  320.       png_byte buf[6];
  322.       if (length != 6)
  323.       {
  324.          png_warning(png_ptr, "Incorrect tRNS chunk length");
  325. png_crc_skip(png_ptr, length);
  326.          return;
  327.       }
  329.       png_crc_read(png_ptr, buf, length);
  330.       png_ptr->num_trans = 3;
  331.       png_ptr->trans_values.red = png_get_uint_16(buf);
  332.       png_ptr->trans_values.green = png_get_uint_16(buf + 2);
  333.       png_ptr->trans_values.blue = png_get_uint_16(buf + 4);
  334.    }
  335.    else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
  336.    {
  337.       png_byte buf[6];
  339.       if (length != 2)
  340.       {
  341.          png_warning(png_ptr, "Incorrect tRNS chunk length");
  342. png_crc_skip(png_ptr, length);
  343. return;
  344. }
  346. png_crc_read(png_ptr, buf, 2);
  347. png_ptr->num_trans = 1;
  348. png_ptr->trans_values.gray = png_get_uint_16(buf);
  349. }
  350. else
  351.       png_warning(png_ptr, "Invalid tRNS chunk");
  353.    png_read_tRNS(png_ptr, info, png_ptr->trans, png_ptr->num_trans,
  354.       &(png_ptr->trans_values));
  355. }
  356. #endif
  358. #if defined(PNG_READ_bKGD_SUPPORTED)
  359. void
  360. png_handle_bKGD(png_structp png_ptr, png_infop info, png_uint_32 length)
  361. {
  362.    int truelen;
  363.    png_byte buf[6];
  365.    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  366.       truelen = 1;
  367.    else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
  368.       truelen = 6;
  369.    else
  370.       truelen = 2;
  372.    if (length != (png_uint_32)truelen)
  373.    {
  374. png_warning(png_ptr, "Incorrect bKGD chunk length");
  375. png_crc_skip(png_ptr, length);
  376.       return;
  377.    }
  379.    png_crc_read(png_ptr, buf, length);
  380.    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  381.       png_ptr->background.index = buf[0];
  382.    else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR))
  383.       png_ptr->background.gray = png_get_uint_16(buf);
  384.    else
  385.    {
  386.       png_ptr->background.red = png_get_uint_16(buf);
  387.       png_ptr->background.green = png_get_uint_16(buf + 2);
  388.       png_ptr->background.blue = png_get_uint_16(buf + 4);
  389.    }
  391.    png_read_bKGD(png_ptr, info, &(png_ptr->background));
  392. }
  393. #endif
  395. #if defined(PNG_READ_hIST_SUPPORTED)
  396. void
  397. png_handle_hIST(png_structp png_ptr, png_infop info, png_uint_32 length)
  398. {
  399. int num, i;
  401. if (length != 2 * png_ptr->num_palette)
  402. {
  403. png_warning(png_ptr, "Incorrect hIST chunk length");
  404. png_crc_skip(png_ptr, length);
  405. return;
  406. }
  408.    num = (int)length / 2;
  409. png_ptr->hist = (png_uint_16p)png_large_malloc(png_ptr,
  410. num * sizeof (png_uint_16));
  411.    png_ptr->do_free |= PNG_FREE_HIST;
  412. for (i = 0; i < num; i++)
  413.    {
  414.       png_byte buf[2];
  416.       png_crc_read(png_ptr, buf, 2);
  417.       png_ptr->hist[i] = png_get_uint_16(buf);
  418.    }
  419.    png_read_hIST(png_ptr, info, png_ptr->hist);
  420. }
  421. #endif
  423. #if defined(PNG_READ_pHYs_SUPPORTED)
  424. void
  425. png_handle_pHYs(png_structp png_ptr, png_infop info, png_uint_32 length)
  426. {
  427.    png_byte buf[9];
  428.    png_uint_32 res_x, res_y;
  429.    int unit_type;
  431.    if (length != 9)
  432.    {
  433. png_warning(png_ptr, "Incorrect pHYs chunk length");
  434. png_crc_skip(png_ptr, length);
  435.       return;
  436. }
  438.    png_crc_read(png_ptr, buf, 9);
  440.    res_x = png_get_uint_32(buf);
  441.    res_y = png_get_uint_32(buf + 4);
  442.    unit_type = buf[8];
  443.    png_read_pHYs(png_ptr, info, res_x, res_y, unit_type);
  444. }
  445. #endif
  447. #if defined(PNG_READ_oFFs_SUPPORTED)
  448. void
  449. png_handle_oFFs(png_structp png_ptr, png_infop info, png_uint_32 length)
  450. {
  451.    png_byte buf[9];
  452.    png_uint_32 offset_x, offset_y;
  453.    int unit_type;
  455.    if (length != 9)
  456.    {
  457. png_warning(png_ptr, "Incorrect oFFs chunk length");
  458. png_crc_skip(png_ptr, length);
  459.       return;
  460.    }
  462. png_crc_read(png_ptr, buf, 9);
  464.    offset_x = png_get_uint_32(buf);
  465.    offset_y = png_get_uint_32(buf + 4);
  466.    unit_type = buf[8];
  467.    png_read_oFFs(png_ptr, info, offset_x, offset_y, unit_type);
  468. }
  469. #endif
  471. #if defined(PNG_READ_tIME_SUPPORTED)
  472. void
  473. png_handle_tIME(png_structp png_ptr, png_infop info, png_uint_32 length)
  474. {
  475.    png_byte buf[7];
  476.    png_time mod_time;
  478.    if (length != 7)
  479.    {
  480. png_warning(png_ptr, "Incorrect tIME chunk length");
  481. png_crc_skip(png_ptr, length);
  482.       return;
  483.    }
  485.    png_crc_read(png_ptr, buf, 7);
  487.    mod_time.second = buf[6];
  488.    mod_time.minute = buf[5];
  489.    mod_time.hour = buf[4];
  490.    mod_time.day = buf[3];
  491.    mod_time.month = buf[2];
  492. mod_time.year = png_get_uint_16(buf);
  494.    png_read_tIME(png_ptr, info, &mod_time);
  495. }
  496. #endif
  498. #if defined(PNG_READ_tEXt_SUPPORTED)
  499. /* note: this does not correctly handle chunks that are > 64K */
  500. void
  501. png_handle_tEXt(png_structp png_ptr, png_infop info, png_uint_32 length)
  502. {
  503. png_charp key;
  504.    png_charp text;
  506. key = (png_charp )png_large_malloc(png_ptr, length + 1);
  507.    png_crc_read(png_ptr, (png_bytep )key, length);
  508. key[(png_size_t)length] = '';
  510.    for (text = key; *text; text++)
  511.       /* empty loop */ ;
  513.    if (text != key + (png_size_t)length)
  514.       text++;
  516.    png_read_tEXt(png_ptr, info, key, text, length - (text - key));
  517. }
  518. #endif
  520. #if defined(PNG_READ_zTXt_SUPPORTED)
  521. /* note: this does not correctly handle chunks that are > 64K compressed */
  522. void
  523. png_handle_zTXt(png_structp png_ptr, png_infop info, png_uint_32 length)
  524. {
  525.    png_charp key;
  526.    png_charp text;
  527.    int ret;
  528.    png_uint_32 text_size, key_size;
  530. key = png_large_malloc(png_ptr, length + 1);
  531. png_crc_read(png_ptr, (png_bytep )key, length);
  532.    key[(png_size_t)length] = '';
  534.    for (text = key; *text; text++)
  535.       /* empty loop */ ;
  537.    /* zTXt can't have zero text */
  538.    if (text == key + (png_size_t)length)
  539.    {
  540.       png_warning(png_ptr, "Zero length zTXt chunk");
  541. png_large_free(png_ptr, key);
  542.       return;
  543.    }
  545.    text++;
  547.    if (*text) /* check compression byte */
  548.    {
  549.       png_large_free(png_ptr, key);
  550.       return;
  551.    }
  553.    text++;
  555.    png_ptr->zstream->next_in = (png_bytep )text;
  556.    png_ptr->zstream->avail_in = (uInt)(length - (text - key));
  557.    png_ptr->zstream->next_out = png_ptr->zbuf;
  558.    png_ptr->zstream->avail_out = (png_size_t)png_ptr->zbuf_size;
  560.    key_size = text - key;
  561.    text_size = 0;
  562. text = NULL;
  563.    ret = Z_STREAM_END;
  565.    while (png_ptr->zstream->avail_in)
  566.    {
  567. ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
  568.       if (ret != Z_OK && ret != Z_STREAM_END)
  569.       {
  570. if (png_ptr->zstream->msg)
  571. png_warning(png_ptr, png_ptr->zstream->msg);
  572.          else
  573. png_warning(png_ptr, "zTXt decompression error");
  574. inflateReset(png_ptr->zstream);
  575.          png_ptr->zstream->avail_in = 0;
  576.          png_large_free(png_ptr, key);
  577.          png_large_free(png_ptr, text);
  578.          return;
  579.       }
  580.       if (!png_ptr->zstream->avail_out || ret == Z_STREAM_END)
  581.       {
  582.          if (!text)
  583.          {
  584.             text = (png_charp)png_large_malloc(png_ptr,
  585.                png_ptr->zbuf_size - png_ptr->zstream->avail_out +
  586.                   key_size + 1);
  587.             png_memcpy(text + (png_size_t)key_size, png_ptr->zbuf,
  588.                (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
  589.             png_memcpy(text, key, (png_size_t)key_size);
  590.             text_size = key_size + (png_size_t)png_ptr->zbuf_size -
  591.                png_ptr->zstream->avail_out;
  592.             *(text + (png_size_t)text_size) = '';
  593.          }
  594.          else
  595.          {
  596. png_charp tmp;
  598.             tmp = text;
  599.             text = png_large_malloc(png_ptr, text_size +
  600.                png_ptr->zbuf_size - png_ptr->zstream->avail_out + 1);
  601.             png_memcpy(text, tmp, (png_size_t)text_size);
  602.             png_large_free(png_ptr, tmp);
  603.             png_memcpy(text + (png_size_t)text_size, png_ptr->zbuf,
  604.                (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream->avail_out));
  605.             text_size += png_ptr->zbuf_size - png_ptr->zstream->avail_out;
  606.             *(text + (png_size_t)text_size) = '';
  607.          }
  608.          if (ret != Z_STREAM_END)
  609.          {
  610.             png_ptr->zstream->next_out = png_ptr->zbuf;
  611.             png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;
  612.          }
  613.       }
  614.       else
  615.       {
  616.          break;
  617.       }
  619.       if (ret == Z_STREAM_END)
  620.          break;
  621.    }
  623. inflateReset(png_ptr->zstream);
  624.    png_ptr->zstream->avail_in = 0;
  626.    if (ret != Z_STREAM_END)
  627.    {
  628.       png_large_free(png_ptr, key);
  629.       png_large_free(png_ptr, text);
  630.       return;
  631.    }
  633.    png_large_free(png_ptr, key);
  634.    key = text;
  635.    text += (png_size_t)key_size;
  636.    text_size -= key_size;
  638.    png_read_zTXt(png_ptr, info, key, text, text_size, 0);
  639. }
  640. #endif
  642. /* Combines the row recently read in with the previous row.
  643.    This routine takes care of alpha and transparency if requested.
  644.    This routine also handles the two methods of progressive display
  645.    of interlaced images, depending on the mask value.
  646.    The mask value describes which pixels are to be combined with
  647.    the row.  The pattern always repeats every 8 pixels, so just 8
  648.    bits are needed.  A one indicates the pixels is to be combined,
  649.    a zero indicates the pixel is to be skipped.  This is in addition
  650.    to any alpha or transparency value associated with the pixel.  If
  651.    you want all pixels to be combined, pass 0xff (255) in mask.
  652. */
  653. void
  654. png_combine_row(png_structp png_ptr, png_bytep row,
  655.    int mask)
  656. {
  657.    if (mask == 0xff)
  658.    {
  659.       png_memcpy(row, png_ptr->row_buf + 1,
  660.          (png_size_t)((png_ptr->width *
  661.          png_ptr->row_info.pixel_depth + 7) >> 3));
  662.    }
  663.    else
  664.    {
  665.       switch (png_ptr->row_info.pixel_depth)
  666.       {
  667.          case 1:
  668.          {
  669.             png_bytep sp;
  670.             png_bytep dp;
  671.             int m;
  672.             int shift;
  673.             png_uint_32 i;
  674.             int value;
  676.             sp = png_ptr->row_buf + 1;
  677.             dp = row;
  678.             shift = 7;
  679.             m = 0x80;
  680.             for (i = 0; i < png_ptr->width; i++)
  681.             {
  682.                if (m & mask)
  683.                {
  684.                   value = (*sp >> shift) & 0x1;
  685.                   *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
  686. *dp |= (png_byte)(value << shift);
  687.                }
  689.                if (shift == 0)
  690.                {
  691.                   shift = 7;
  692.                   sp++;
  693.                   dp++;
  694.                }
  695.                else
  696.                   shift--;
  698.                if (m == 1)
  699.                   m = 0x80;
  700.                else
  701.                   m >>= 1;
  702.             }
  703.             break;
  704.          }
  705.          case 2:
  706.          {
  707.             png_bytep sp;
  708.             png_bytep dp;
  709.             int m;
  710.             int shift;
  711.             png_uint_32 i;
  712.             int value;
  714.             sp = png_ptr->row_buf + 1;
  715.             dp = row;
  716.             shift = 6;
  717.             m = 0x80;
  718.             for (i = 0; i < png_ptr->width; i++)
  719.             {
  720.                if (m & mask)
  721.                {
  722.                   value = (*sp >> shift) & 0x3;
  723.                   *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
  724. *dp |= (png_byte)(value << shift);
  725.                }
  727.                if (shift == 0)
  728.                {
  729.                   shift = 6;
  730.                   sp++;
  731.                   dp++;
  732.                }
  733.                else
  734.                   shift -= 2;
  735.                if (m == 1)
  736.                   m = 0x80;
  737.                else
  738.                   m >>= 1;
  739.             }
  740.             break;
  741.          }
  742.          case 4:
  743.          {
  744.             png_bytep sp;
  745.             png_bytep dp;
  746.             int m;
  747.             int shift;
  748.             png_uint_32 i;
  749.             int value;
  751.             sp = png_ptr->row_buf + 1;
  752.             dp = row;
  753.             shift = 4;
  754.             m = 0x80;
  755.             for (i = 0; i < png_ptr->width; i++)
  756.             {
  757.                if (m & mask)
  758.                {
  759.                   value = (*sp >> shift) & 0xf;
  760.                   *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
  761. *dp |= (png_byte)(value << shift);
  762.                }
  764.                if (shift == 0)
  765.                {
  766.                   shift = 4;
  767.                   sp++;
  768.                   dp++;
  769.                }
  770.                else
  771.                   shift -= 4;
  772.                if (m == 1)
  773.                   m = 0x80;
  774.                else
  775.                   m >>= 1;
  776.             }
  777.             break;
  778.          }
  779.          default:
  780.          {
  781.             png_bytep sp;
  782.             png_bytep dp;
  783.             png_uint_32 i;
  784.             int pixel_bytes, m;
  786.             pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  788.             sp = png_ptr->row_buf + 1;
  789.             dp = row;
  790.             m = 0x80;
  791.             for (i = 0; i < png_ptr->width; i++)
  792.             {
  793.                if (m & mask)
  794.                {
  795.                   png_memcpy(dp, sp, pixel_bytes);
  796.                }
  798.                sp += pixel_bytes;
  799.                dp += pixel_bytes;
  801.                if (m == 1)
  802.                   m = 0x80;
  803.                else
  804.                   m >>= 1;
  805.             }
  806.             break;
  807.          }
  808.       }
  809.    }
  810. }
  812. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  813. void
  814. png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass)
  815. {
  816.    if (row && row_info)
  817.    {
  818.       png_uint_32 final_width;
  820.       final_width = row_info->width * png_pass_inc[pass];
  822.       switch (row_info->pixel_depth)
  823.       {
  824.          case 1:
  825.          {
  826.             png_bytep sp, dp;
  827.             int sshift, dshift;
  828.             png_byte v;
  829.             png_uint_32 i;
  830.             int j;
  832.             sp = row + (png_size_t)((row_info->width - 1) >> 3);
  833.             sshift = 7 - (int)((row_info->width + 7) & 7);
  834.             dp = row + (png_size_t)((final_width - 1) >> 3);
  835.             dshift = 7 - (int)((final_width + 7) & 7);
  836.             for (i = row_info->width; i; i--)
  837.             {
  838. v = (png_byte)((*sp >> sshift) & 0x1);
  839.                for (j = 0; j < png_pass_inc[pass]; j++)
  840.                {
  841.                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
  842.                   *dp |= (png_byte)(v << dshift);
  843.                   if (dshift == 7)
  844.                   {
  845.                      dshift = 0;
  846.                      dp--;
  847.                   }
  848.                   else
  849.                      dshift++;
  850.                }
  851.                if (sshift == 7)
  852.                {
  853.                   sshift = 0;
  854.                   sp--;
  855.                }
  856.                else
  857.                   sshift++;
  858.             }
  859.             break;
  860.          }
  861.          case 2:
  862.          {
  863.             png_bytep sp, dp;
  864.             int sshift, dshift;
  865.             png_byte v;
  866.             png_uint_32 i, j;
  868.             sp = row + (png_size_t)((row_info->width - 1) >> 2);
  869.             sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);
  870.             dp = row + (png_size_t)((final_width - 1) >> 2);
  871.             dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
  872.             for (i = row_info->width; i; i--)
  873.             {
  874. v = (png_byte)((*sp >> sshift) & 0x3);
  875.                for (j = 0; j < png_pass_inc[pass]; j++)
  876.                {
  877.                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
  878. *dp |= (png_byte)(v << dshift);
  879.                   if (dshift == 6)
  880.                   {
  881.                      dshift = 0;
  882.                      dp--;
  883.                   }
  884.                   else
  885.                      dshift += 2;
  886.                }
  887.                if (sshift == 6)
  888.                {
  889.                   sshift = 0;
  890.                   sp--;
  891.                }
  892.                else
  893.                   sshift += 2;
  894.             }
  895.             break;
  896.          }
  897.          case 4:
  898.          {
  899.             png_bytep sp, dp;
  900.             int sshift, dshift;
  901.             png_byte v;
  902.             png_uint_32 i;
  903.             int j;
  905.             sp = row + (png_size_t)((row_info->width - 1) >> 1);
  906.             sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);
  907.             dp = row + (png_size_t)((final_width - 1) >> 1);
  908.             dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
  909.             for (i = row_info->width; i; i--)
  910.             {
  911. v = (png_byte)((*sp >> sshift) & 0xf);
  912.                for (j = 0; j < png_pass_inc[pass]; j++)
  913.                {
  914.                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
  915.                   *dp |= (png_byte)(v << dshift);
  916.                   if (dshift == 4)
  917.                   {
  918.                      dshift = 0;
  919.                      dp--;
  920.                   }
  921.                   else
  922.                      dshift = 4;
  923.                }
  924.                if (sshift == 4)
  925.                {
  926.                   sshift = 0;
  927.                   sp--;
  928.                }
  929.                else
  930.                   sshift = 4;
  931.             }
  932.             break;
  933.          }
  934.          default:
  935.          {
  936.             png_bytep sp, dp;
  937.             png_byte v[8];
  938.             png_uint_32 i;
  939.             int j;
  940.             int pixel_bytes;
  942.             pixel_bytes = (row_info->pixel_depth >> 3);
  944.             sp = row + (png_size_t)((row_info->width - 1) * pixel_bytes);
  945.             dp = row + (png_size_t)((final_width - 1) * pixel_bytes);
  946.             for (i = row_info->width; i; i--)
  947.             {
  948.                png_memcpy(v, sp, pixel_bytes);
  949.                for (j = 0; j < png_pass_inc[pass]; j++)
  950.                {
  951.                   png_memcpy(dp, v, pixel_bytes);
  952.                   dp -= pixel_bytes;
  953.                }
  954.                sp -= pixel_bytes;
  955.             }
  956.             break;
  957.          }
  958.       }
  959.       row_info->width = final_width;
  960.       row_info->rowbytes = ((final_width *
  961.          (png_uint_32)row_info->pixel_depth + 7) >> 3);
  962.    }
  963. }
  964. #endif
  966. void
  967. png_read_filter_row(png_row_infop row_info, png_bytep row,
  968.    png_bytep prev_row, int filter)
  969. {
  970.    switch (filter)
  971.    {
  972.       case 0:
  973.          break;
  974.       case 1:
  975.       {
  976.          png_uint_32 i;
  977.          int bpp;
  978.          png_bytep rp;
  979.          png_bytep lp;
  981.          bpp = (row_info->pixel_depth + 7) / 8;
  982.          for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
  983.             i < row_info->rowbytes; i++, rp++, lp++)
  984.          {
  985.             *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
  986.          }
  987.          break;
  988.       }
  989.       case 2:
  990.       {
  991.          png_uint_32 i;
  992.          png_bytep rp;
  993.          png_bytep pp;
  995.          for (i = 0, rp = row, pp = prev_row;
  996.             i < row_info->rowbytes; i++, rp++, pp++)
  997.          {
  998.             *rp = (png_byte)(((int)(*rp) + (int)(*pp)) & 0xff);
  999.          }
  1000.          break;
  1001.       }
  1002.       case 3:
  1003.       {
  1004.          png_uint_32 i;
  1005.          int bpp;
  1006.          png_bytep rp;
  1007.          png_bytep pp;
  1008.          png_bytep lp;
  1010.          bpp = (row_info->pixel_depth + 7) / 8;
  1011.          for (i = 0, rp = row, pp = prev_row;
  1012.             i < (png_uint_32)bpp; i++, rp++, pp++)
  1013.          {
  1014.             *rp = (png_byte)(((int)(*rp) +
  1015.                ((int)(*pp) / 2)) & 0xff);
  1016.          }
  1017.          for (lp = row; i < row_info->rowbytes; i++, rp++, lp++, pp++)
  1018.          {
  1019.             *rp = (png_byte)(((int)(*rp) +
  1020.                (int)(*pp + *lp) / 2) & 0xff);
  1021.          }
  1022.          break;
  1023.       }
  1024.       case 4:
  1025.       {
  1026.          int bpp;
  1027.          png_uint_32 i;
  1028.          png_bytep rp;
  1029.          png_bytep pp;
  1030.          png_bytep lp;
  1031.          png_bytep cp;
  1033.          bpp = (row_info->pixel_depth + 7) / 8;
  1034.          for (i = 0, rp = row, pp = prev_row,
  1035.             lp = row - bpp, cp = prev_row - bpp;
  1036.             i < row_info->rowbytes; i++, rp++, pp++, lp++, cp++)
  1037.          {
  1038.             int a, b, c, pa, pb, pc, p;
  1040.             b = *pp;
  1041.             if (i >= (png_uint_32)bpp)
  1042.             {
  1043.                c = *cp;
  1044.                a = *lp;
  1045.             }
  1046.             else
  1047.             {
  1048.                a = c = 0;
  1049.             }
  1050.             p = a + b - c;
  1051.             pa = abs(p - a);
  1052.             pb = abs(p - b);
  1053.             pc = abs(p - c);
  1055.             if (pa <= pb && pa <= pc)
  1056.                p = a;
  1057.             else if (pb <= pc)
  1058.                p = b;
  1059.             else
  1060.                p = c;
  1062.             *rp = (png_byte)(((int)(*rp) + p) & 0xff);
  1063.          }
  1064.          break;
  1065.       }
  1066.       default:
  1067.          break;
  1068.    }
  1069. }
  1071. void
  1072. png_read_finish_row(png_structp png_ptr)
  1073. {
  1074.    png_ptr->row_number++;
  1075.    if (png_ptr->row_number < png_ptr->num_rows)
  1076.       return;
  1078.    if (png_ptr->interlaced)
  1079.    {
  1080.       png_ptr->row_number = 0;
  1081.       png_memset(png_ptr->prev_row, 0, (png_size_t)png_ptr->rowbytes + 1);
  1082.       do
  1083.       {
  1084.          png_ptr->pass++;
  1085.          if (png_ptr->pass >= 7)
  1086.             break;
  1087.          png_ptr->iwidth = (png_ptr->width +
  1088.             png_pass_inc[png_ptr->pass] - 1 -
  1089.             png_pass_start[png_ptr->pass]) /
  1090.             png_pass_inc[png_ptr->pass];
  1091.          png_ptr->irowbytes = ((png_ptr->iwidth *
  1092.             png_ptr->pixel_depth + 7) >> 3) + 1;
  1093.          if (!(png_ptr->transformations & PNG_INTERLACE))
  1094.          {
  1095.             png_ptr->num_rows = (png_ptr->height +
  1096.                png_pass_yinc[png_ptr->pass] - 1 -
  1097.                png_pass_ystart[png_ptr->pass]) /
  1098.                png_pass_yinc[png_ptr->pass];
  1099.             if (!(png_ptr->num_rows))
  1100.                continue;
  1101.          }
  1102.          if (png_ptr->transformations & PNG_INTERLACE)
  1103.             break;
  1104.       } while (png_ptr->iwidth == 0);
  1106.       if (png_ptr->pass < 7)
  1107.          return;
  1108.    }
  1110.    if (!png_ptr->zlib_finished)
  1111.    {
  1112.       char extra;
  1113.       int ret;
  1115.       png_ptr->zstream->next_out = (Byte *)&extra;
  1116.       png_ptr->zstream->avail_out = (uInt)1;
  1117.       do
  1118.       {
  1119.          if (!(png_ptr->zstream->avail_in))
  1120.          {
  1121.             while (!png_ptr->idat_size)
  1122.             {
  1123.                png_byte buf[4];
  1124.                png_uint_32 crc;
  1126.                png_read_data(png_ptr, buf, 4);
  1127.                crc = png_get_uint_32(buf);
  1128.                if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
  1129.                   (png_ptr->crc & 0xffffffffL))
  1130.                   png_error(png_ptr, "Bad CRC value");
  1132.                png_read_data(png_ptr, buf, 4);
  1133.                png_ptr->idat_size = png_get_uint_32(buf);
  1134.                png_reset_crc(png_ptr);
  1136.                png_crc_read(png_ptr, buf, 4);
  1137.                if (png_memcmp(buf, png_IDAT, 4))
  1138.                   png_error(png_ptr, "Not enough image data");
  1140.             }
  1141.             png_ptr->zstream->avail_in = (uInt)png_ptr->zbuf_size;
  1142.             png_ptr->zstream->next_in = png_ptr->zbuf;
  1143.             if (png_ptr->zbuf_size > png_ptr->idat_size)
  1144.                png_ptr->zstream->avail_in = (uInt)png_ptr->idat_size;
  1145.             png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream->avail_in);
  1146.             png_ptr->idat_size -= png_ptr->zstream->avail_in;
  1147.          }
  1148. ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
  1149.          if (ret == Z_STREAM_END)
  1150.          {
  1151.             if (!(png_ptr->zstream->avail_out) || png_ptr->zstream->avail_in ||
  1152.                png_ptr->idat_size)
  1153.                png_error(png_ptr, "Extra compressed data");
  1154.             png_ptr->mode = PNG_AT_LAST_IDAT;
  1155.             break;
  1156.          }
  1157.          if (ret != Z_OK)
  1158.             png_error(png_ptr, "Compression Error");
  1160.          if (!(png_ptr->zstream->avail_out))
  1161.             png_error(png_ptr, "Extra compressed data");
  1163.       } while (1);
  1164.       png_ptr->zstream->avail_out = 0;
  1165.    }
  1167.    if (png_ptr->idat_size || png_ptr->zstream->avail_in)
  1168.       png_error(png_ptr, "Extra compression data");
  1170.    inflateReset(png_ptr->zstream);
  1172.    png_ptr->mode = PNG_AT_LAST_IDAT;
  1173. }
  1175. void
  1176. png_read_start_row(png_structp png_ptr)
  1177. {
  1178.    int max_pixel_depth;
  1179.    png_uint_32 rowbytes;
  1181.    png_ptr->zstream->avail_in = 0;
  1182.    png_init_read_transformations(png_ptr);
  1183.    if (png_ptr->interlaced)
  1184.    {
  1185.       if (!(png_ptr->transformations & PNG_INTERLACE))
  1186.          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
  1187.             png_pass_ystart[0]) / png_pass_yinc[0];
  1188.       else
  1189.          png_ptr->num_rows = png_ptr->height;
  1191.       png_ptr->iwidth = (png_ptr->width +
  1192.          png_pass_inc[png_ptr->pass] - 1 -
  1193.          png_pass_start[png_ptr->pass]) /
  1194.          png_pass_inc[png_ptr->pass];
  1195.       png_ptr->irowbytes = ((png_ptr->iwidth *
  1196.          png_ptr->pixel_depth + 7) >> 3) + 1;
  1197.    }
  1198.    else
  1199.    {
  1200.       png_ptr->num_rows = png_ptr->height;
  1201.       png_ptr->iwidth = png_ptr->width;
  1202.       png_ptr->irowbytes = png_ptr->rowbytes + 1;
  1203.    }
  1205.    max_pixel_depth = png_ptr->pixel_depth;
  1207. #if defined(PNG_READ_PACK_SUPPORTED)
  1208.    if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)
  1209.    {
  1210.       max_pixel_depth = 8;
  1211.    }
  1212. #endif
  1214. #if defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_PACK_SUPPORTED)
  1215.    if (png_ptr->transformations & (PNG_EXPAND | PNG_PACK))
  1216.    {
  1217.       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  1218.       {
  1219.          if (png_ptr->num_trans)
  1220.             max_pixel_depth = 32;
  1221.          else
  1222.             max_pixel_depth = 24;
  1223.       }
  1224.       else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
  1225.       {
  1226.          if (max_pixel_depth < 8)
  1227.             max_pixel_depth = 8;
  1228.          if (png_ptr->num_trans)
  1229.             max_pixel_depth *= 2;
  1230.       }
  1231.       else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
  1232.       {
  1233.          if (png_ptr->num_trans)
  1234.          {
  1235.             max_pixel_depth *= 4;
  1236.             max_pixel_depth /= 3;
  1237.          }
  1238.       }
  1239.    }
  1240. #endif
  1242. #if defined(PNG_READ_FILLER_SUPPORTED)
  1243.    if (png_ptr->transformations & (PNG_FILLER))
  1244.    {
  1245.       if (max_pixel_depth < 32)
  1246.          max_pixel_depth = 32;
  1247.    }
  1248. #endif
  1250. #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
  1251.    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
  1252.    {
  1253.       if ((png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
  1254.          png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  1255.       {
  1256.          if (max_pixel_depth <= 16)
  1257.             max_pixel_depth = 32;
  1258.          else if (max_pixel_depth <= 32)
  1259.             max_pixel_depth = 64;
  1260.       }
  1261.       else
  1262.       {
  1263.          if (max_pixel_depth <= 8)
  1264.             max_pixel_depth = 24;
  1265.          else if (max_pixel_depth <= 16)
  1266.             max_pixel_depth = 48;
  1267.       }
  1268.    }
  1269. #endif
  1271.    /* align the width on the next larger 8 pixels.  Mainly used
  1272.       for interlacing */
  1273.    rowbytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
  1274.    /* calculate the maximum bytes needed, adding a byte and a pixel
  1275.       for safety sake */
  1276.    rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
  1277.       1 + ((max_pixel_depth + 7) >> 3);
  1278. #ifdef PNG_MAX_MALLOC_64K
  1279.    if (rowbytes > 65536L)
  1280.       png_error(png_ptr, "This image requires a row greater then 64KB");
  1281. #endif
  1282. png_ptr->row_buf = (png_bytep )png_large_malloc(png_ptr, rowbytes);
  1284. #ifdef PNG_MAX_MALLOC_64K
  1285.    if (png_ptr->rowbytes + 1 > 65536L)
  1286. png_error(png_ptr, "This image requires a row greater then 64KB");
  1287. #endif
  1288.    png_ptr->prev_row = png_large_malloc(png_ptr,
  1289.       png_ptr->rowbytes + 1);
  1291.    png_memset(png_ptr->prev_row, 0, (png_size_t)png_ptr->rowbytes + 1);
  1293.    png_ptr->row_init = 1;
  1294. }