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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
pngset.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：39k
源码类别：

打印编程

开发平台：

Visual C++

pngset.c：源码内容
  2. /* pngset.c - storage of image information into info struct
  3.  *
  4.  * Last changed in libpng 1.2.15 December 31, 2006
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2006 Glenn Randers-Pehrson
  7.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  8.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  9.  *
  10.  * The functions here are used during reads to store data from the file
  11.  * into the info struct, and during writes to store application data
  12.  * into the info struct for writing into the file.  This abstracts the
  13.  * info struct and allows us to change the structure in the future.
  14.  */
  16. #define PNG_INTERNAL
  17. #include "png.h"
  19. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  21. #if defined(PNG_bKGD_SUPPORTED)
  22. void PNGAPI
  23. png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
  24. {
  25.    png_debug1(1, "in %s storage functionn", "bKGD");
  26.    if (png_ptr == NULL || info_ptr == NULL)
  27.       return;
  29.    png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
  30.    info_ptr->valid |= PNG_INFO_bKGD;
  31. }
  32. #endif
  34. #if defined(PNG_cHRM_SUPPORTED)
  35. #ifdef PNG_FLOATING_POINT_SUPPORTED
  36. void PNGAPI
  37. png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
  38.    double white_x, double white_y, double red_x, double red_y,
  39.    double green_x, double green_y, double blue_x, double blue_y)
  40. {
  41.    png_debug1(1, "in %s storage functionn", "cHRM");
  42.    if (png_ptr == NULL || info_ptr == NULL)
  43.       return;
  45.    if (white_x < 0.0 || white_y < 0.0 ||
  46.          red_x < 0.0 ||   red_y < 0.0 ||
  47.        green_x < 0.0 || green_y < 0.0 ||
  48.         blue_x < 0.0 ||  blue_y < 0.0)
  49.    {
  50.       png_warning(png_ptr,
  51.         "Ignoring attempt to set negative chromaticity value");
  52.       return;
  53.    }
  54.    if (white_x > 21474.83 || white_y > 21474.83 ||
  55.          red_x > 21474.83 ||   red_y > 21474.83 ||
  56.        green_x > 21474.83 || green_y > 21474.83 ||
  57.         blue_x > 21474.83 ||  blue_y > 21474.83)
  58.    {
  59.       png_warning(png_ptr,
  60.         "Ignoring attempt to set chromaticity value exceeding 21474.83");
  61.       return;
  62.    }
  64.    info_ptr->x_white = (float)white_x;
  65.    info_ptr->y_white = (float)white_y;
  66.    info_ptr->x_red   = (float)red_x;
  67.    info_ptr->y_red   = (float)red_y;
  68.    info_ptr->x_green = (float)green_x;
  69.    info_ptr->y_green = (float)green_y;
  70.    info_ptr->x_blue  = (float)blue_x;
  71.    info_ptr->y_blue  = (float)blue_y;
  72. #ifdef PNG_FIXED_POINT_SUPPORTED
  73.    info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
  74.    info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
  75.    info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);
  76.    info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);
  77.    info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
  78.    info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
  79.    info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);
  80.    info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);
  81. #endif
  82.    info_ptr->valid |= PNG_INFO_cHRM;
  83. }
  84. #endif
  85. #ifdef PNG_FIXED_POINT_SUPPORTED
  86. void PNGAPI
  87. png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
  88.    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
  89.    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
  90.    png_fixed_point blue_x, png_fixed_point blue_y)
  91. {
  92.    png_debug1(1, "in %s storage functionn", "cHRM");
  93.    if (png_ptr == NULL || info_ptr == NULL)
  94.       return;
  96.    if (white_x < 0 || white_y < 0 ||
  97.          red_x < 0 ||   red_y < 0 ||
  98.        green_x < 0 || green_y < 0 ||
  99.         blue_x < 0 ||  blue_y < 0)
  100.    {
  101.       png_warning(png_ptr,
  102.         "Ignoring attempt to set negative chromaticity value");
  103.       return;
  104.    }
  105. #ifdef PNG_FLOATING_POINT_SUPPORTED
  106.    if (white_x > (double) PNG_UINT_31_MAX ||
  107.        white_y > (double) PNG_UINT_31_MAX ||
  108.          red_x > (double) PNG_UINT_31_MAX ||
  109.          red_y > (double) PNG_UINT_31_MAX ||
  110.        green_x > (double) PNG_UINT_31_MAX ||
  111.        green_y > (double) PNG_UINT_31_MAX ||
  112.         blue_x > (double) PNG_UINT_31_MAX ||
  113.         blue_y > (double) PNG_UINT_31_MAX)
  114. #else
  115.    if (white_x > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  116.        white_y > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  117.          red_x > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  118.          red_y > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  119.        green_x > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  120.        green_y > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  121.         blue_x > (png_fixed_point) PNG_UINT_31_MAX/100000L ||
  122.         blue_y > (png_fixed_point) PNG_UINT_31_MAX/100000L)
  123. #endif
  124.    {
  125.       png_warning(png_ptr,
  126.         "Ignoring attempt to set chromaticity value exceeding 21474.83");
  127.       return;
  128.    }
  129.    info_ptr->int_x_white = white_x;
  130.    info_ptr->int_y_white = white_y;
  131.    info_ptr->int_x_red   = red_x;
  132.    info_ptr->int_y_red   = red_y;
  133.    info_ptr->int_x_green = green_x;
  134.    info_ptr->int_y_green = green_y;
  135.    info_ptr->int_x_blue  = blue_x;
  136.    info_ptr->int_y_blue  = blue_y;
  137. #ifdef PNG_FLOATING_POINT_SUPPORTED
  138.    info_ptr->x_white = (float)(white_x/100000.);
  139.    info_ptr->y_white = (float)(white_y/100000.);
  140.    info_ptr->x_red   = (float)(  red_x/100000.);
  141.    info_ptr->y_red   = (float)(  red_y/100000.);
  142.    info_ptr->x_green = (float)(green_x/100000.);
  143.    info_ptr->y_green = (float)(green_y/100000.);
  144.    info_ptr->x_blue  = (float)( blue_x/100000.);
  145.    info_ptr->y_blue  = (float)( blue_y/100000.);
  146. #endif
  147.    info_ptr->valid |= PNG_INFO_cHRM;
  148. }
  149. #endif
  150. #endif
  152. #if defined(PNG_gAMA_SUPPORTED)
  153. #ifdef PNG_FLOATING_POINT_SUPPORTED
  154. void PNGAPI
  155. png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
  156. {
  157.    double gamma;
  158.    png_debug1(1, "in %s storage functionn", "gAMA");
  159.    if (png_ptr == NULL || info_ptr == NULL)
  160.       return;
  162.    /* Check for overflow */
  163.    if (file_gamma > 21474.83)
  164.    {
  165.       png_warning(png_ptr, "Limiting gamma to 21474.83");
  166.       gamma=21474.83;
  167.    }
  168.    else
  169.       gamma=file_gamma;
  170.    info_ptr->gamma = (float)gamma;
  171. #ifdef PNG_FIXED_POINT_SUPPORTED
  172.    info_ptr->int_gamma = (int)(gamma*100000.+.5);
  173. #endif
  174.    info_ptr->valid |= PNG_INFO_gAMA;
  175.    if(gamma == 0.0)
  176.       png_warning(png_ptr, "Setting gamma=0");
  177. }
  178. #endif
  179. void PNGAPI
  180. png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
  181.    int_gamma)
  182. {
  183.    png_fixed_point gamma;
  185.    png_debug1(1, "in %s storage functionn", "gAMA");
  186.    if (png_ptr == NULL || info_ptr == NULL)
  187.       return;
  189.    if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)
  190.    {
  191.      png_warning(png_ptr, "Limiting gamma to 21474.83");
  192.      gamma=PNG_UINT_31_MAX;
  193.    }
  194.    else
  195.    {
  196.      if (int_gamma < 0)
  197.      {
  198.        png_warning(png_ptr, "Setting negative gamma to zero");
  199.        gamma=0;
  200.      }
  201.      else
  202.        gamma=int_gamma;
  203.    }
  204. #ifdef PNG_FLOATING_POINT_SUPPORTED
  205.    info_ptr->gamma = (float)(gamma/100000.);
  206. #endif
  207. #ifdef PNG_FIXED_POINT_SUPPORTED
  208.    info_ptr->int_gamma = gamma;
  209. #endif
  210.    info_ptr->valid |= PNG_INFO_gAMA;
  211.    if(gamma == 0)
  212.       png_warning(png_ptr, "Setting gamma=0");
  213. }
  214. #endif
  216. #if defined(PNG_hIST_SUPPORTED)
  217. void PNGAPI
  218. png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
  219. {
  220.    int i;
  222.    png_debug1(1, "in %s storage functionn", "hIST");
  223.    if (png_ptr == NULL || info_ptr == NULL)
  224.       return;
  225.    if (info_ptr->num_palette <= 0 || info_ptr->num_palette
  226.        > PNG_MAX_PALETTE_LENGTH)
  227.    {
  228.        png_warning(png_ptr,
  229.           "Invalid palette size, hIST allocation skipped.");
  230.        return;
  231.    }
  233. #ifdef PNG_FREE_ME_SUPPORTED
  234.    png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
  235. #endif
  236.    /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version
  237.       1.2.1 */
  238.    png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
  239.       (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof (png_uint_16)));
  240.    if (png_ptr->hist == NULL)
  241.      {
  242.        png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
  243.        return;
  244.      }
  246.    for (i = 0; i < info_ptr->num_palette; i++)
  247.        png_ptr->hist[i] = hist[i];
  248.    info_ptr->hist = png_ptr->hist;
  249.    info_ptr->valid |= PNG_INFO_hIST;
  251. #ifdef PNG_FREE_ME_SUPPORTED
  252.    info_ptr->free_me |= PNG_FREE_HIST;
  253. #else
  254.    png_ptr->flags |= PNG_FLAG_FREE_HIST;
  255. #endif
  256. }
  257. #endif
  259. void PNGAPI
  260. png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
  261.    png_uint_32 width, png_uint_32 height, int bit_depth,
  262.    int color_type, int interlace_type, int compression_type,
  263.    int filter_type)
  264. {
  265.    png_debug1(1, "in %s storage functionn", "IHDR");
  266.    if (png_ptr == NULL || info_ptr == NULL)
  267.       return;
  269.    /* check for width and height valid values */
  270.    if (width == 0 || height == 0)
  271.       png_error(png_ptr, "Image width or height is zero in IHDR");
  272. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  273.    if (width > png_ptr->user_width_max || height > png_ptr->user_height_max)
  274.       png_error(png_ptr, "image size exceeds user limits in IHDR");
  275. #else
  276.    if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX)
  277.       png_error(png_ptr, "image size exceeds user limits in IHDR");
  278. #endif
  279.    if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX)
  280.       png_error(png_ptr, "Invalid image size in IHDR");
  281.    if ( width > (PNG_UINT_32_MAX
  282.                  >> 3)      /* 8-byte RGBA pixels */
  283.                  - 64       /* bigrowbuf hack */
  284.                  - 1        /* filter byte */
  285.                  - 7*8      /* rounding of width to multiple of 8 pixels */
  286.                  - 8)       /* extra max_pixel_depth pad */
  287.       png_warning(png_ptr, "Width is too large for libpng to process pixels");
  289.    /* check other values */
  290.    if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
  291.       bit_depth != 8 && bit_depth != 16)
  292.       png_error(png_ptr, "Invalid bit depth in IHDR");
  294.    if (color_type < 0 || color_type == 1 ||
  295.       color_type == 5 || color_type > 6)
  296.       png_error(png_ptr, "Invalid color type in IHDR");
  298.    if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
  299.        ((color_type == PNG_COLOR_TYPE_RGB ||
  300.          color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
  301.          color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
  302.       png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");
  304.    if (interlace_type >= PNG_INTERLACE_LAST)
  305.       png_error(png_ptr, "Unknown interlace method in IHDR");
  307.    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  308.       png_error(png_ptr, "Unknown compression method in IHDR");
  310. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  311.    /* Accept filter_method 64 (intrapixel differencing) only if
  312.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  313.     * 2. Libpng did not read a PNG signature (this filter_method is only
  314.     *    used in PNG datastreams that are embedded in MNG datastreams) and
  315.     * 3. The application called png_permit_mng_features with a mask that
  316.     *    included PNG_FLAG_MNG_FILTER_64 and
  317.     * 4. The filter_method is 64 and
  318.     * 5. The color_type is RGB or RGBA
  319.     */
  320.    if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)
  321.       png_warning(png_ptr,"MNG features are not allowed in a PNG datastream");
  322.    if(filter_type != PNG_FILTER_TYPE_BASE)
  323.    {
  324.      if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  325.         (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
  326.         ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
  327.         (color_type == PNG_COLOR_TYPE_RGB ||
  328.          color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
  329.         png_error(png_ptr, "Unknown filter method in IHDR");
  330.      if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
  331.         png_warning(png_ptr, "Invalid filter method in IHDR");
  332.    }
  333. #else
  334.    if(filter_type != PNG_FILTER_TYPE_BASE)
  335.       png_error(png_ptr, "Unknown filter method in IHDR");
  336. #endif
  338.    info_ptr->width = width;
  339.    info_ptr->height = height;
  340.    info_ptr->bit_depth = (png_byte)bit_depth;
  341.    info_ptr->color_type =(png_byte) color_type;
  342.    info_ptr->compression_type = (png_byte)compression_type;
  343.    info_ptr->filter_type = (png_byte)filter_type;
  344.    info_ptr->interlace_type = (png_byte)interlace_type;
  345.    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  346.       info_ptr->channels = 1;
  347.    else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
  348.       info_ptr->channels = 3;
  349.    else
  350.       info_ptr->channels = 1;
  351.    if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
  352.       info_ptr->channels++;
  353.    info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
  355.    /* check for potential overflow */
  356.    if ( width > (PNG_UINT_32_MAX
  357.                  >> 3)      /* 8-byte RGBA pixels */
  358.                  - 64       /* bigrowbuf hack */
  359.                  - 1        /* filter byte */
  360.                  - 7*8      /* rounding of width to multiple of 8 pixels */
  361.                  - 8)       /* extra max_pixel_depth pad */
  362.       info_ptr->rowbytes = (png_size_t)0;
  363.    else
  364.       info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width);
  365. }
  367. #if defined(PNG_oFFs_SUPPORTED)
  368. void PNGAPI
  369. png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
  370.    png_int_32 offset_x, png_int_32 offset_y, int unit_type)
  371. {
  372.    png_debug1(1, "in %s storage functionn", "oFFs");
  373.    if (png_ptr == NULL || info_ptr == NULL)
  374.       return;
  376.    info_ptr->x_offset = offset_x;
  377.    info_ptr->y_offset = offset_y;
  378.    info_ptr->offset_unit_type = (png_byte)unit_type;
  379.    info_ptr->valid |= PNG_INFO_oFFs;
  380. }
  381. #endif
  383. #if defined(PNG_pCAL_SUPPORTED)
  384. void PNGAPI
  385. png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
  386.    png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
  387.    png_charp units, png_charpp params)
  388. {
  389.    png_uint_32 length;
  390.    int i;
  392.    png_debug1(1, "in %s storage functionn", "pCAL");
  393.    if (png_ptr == NULL || info_ptr == NULL)
  394.       return;
  396.    length = png_strlen(purpose) + 1;
  397.    png_debug1(3, "allocating purpose for info (%lu bytes)n", length);
  398.    info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
  399.    if (info_ptr->pcal_purpose == NULL)
  400.      {
  401.        png_warning(png_ptr, "Insufficient memory for pCAL purpose.");
  402.        return;
  403.      }
  404.    png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
  406.    png_debug(3, "storing X0, X1, type, and nparams in infon");
  407.    info_ptr->pcal_X0 = X0;
  408.    info_ptr->pcal_X1 = X1;
  409.    info_ptr->pcal_type = (png_byte)type;
  410.    info_ptr->pcal_nparams = (png_byte)nparams;
  412.    length = png_strlen(units) + 1;
  413.    png_debug1(3, "allocating units for info (%lu bytes)n", length);
  414.    info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
  415.    if (info_ptr->pcal_units == NULL)
  416.      {
  417.        png_warning(png_ptr, "Insufficient memory for pCAL units.");
  418.        return;
  419.      }
  420.    png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
  422.    info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
  423.       (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));
  424.    if (info_ptr->pcal_params == NULL)
  425.      {
  426.        png_warning(png_ptr, "Insufficient memory for pCAL params.");
  427.        return;
  428.      }
  430.    info_ptr->pcal_params[nparams] = NULL;
  432.    for (i = 0; i < nparams; i++)
  433.    {
  434.       length = png_strlen(params[i]) + 1;
  435.       png_debug2(3, "allocating parameter %d for info (%lu bytes)n", i, length);
  436.       info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
  437.       if (info_ptr->pcal_params[i] == NULL)
  438.         {
  439.           png_warning(png_ptr, "Insufficient memory for pCAL parameter.");
  440.           return;
  441.         }
  442.       png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
  443.    }
  445.    info_ptr->valid |= PNG_INFO_pCAL;
  446. #ifdef PNG_FREE_ME_SUPPORTED
  447.    info_ptr->free_me |= PNG_FREE_PCAL;
  448. #endif
  449. }
  450. #endif
  452. #if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
  453. #ifdef PNG_FLOATING_POINT_SUPPORTED
  454. void PNGAPI
  455. png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
  456.              int unit, double width, double height)
  457. {
  458.    png_debug1(1, "in %s storage functionn", "sCAL");
  459.    if (png_ptr == NULL || info_ptr == NULL)
  460.       return;
  462.    info_ptr->scal_unit = (png_byte)unit;
  463.    info_ptr->scal_pixel_width = width;
  464.    info_ptr->scal_pixel_height = height;
  466.    info_ptr->valid |= PNG_INFO_sCAL;
  467. }
  468. #else
  469. #ifdef PNG_FIXED_POINT_SUPPORTED
  470. void PNGAPI
  471. png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
  472.              int unit, png_charp swidth, png_charp sheight)
  473. {
  474.    png_uint_32 length;
  476.    png_debug1(1, "in %s storage functionn", "sCAL");
  477.    if (png_ptr == NULL || info_ptr == NULL)
  478.       return;
  480.    info_ptr->scal_unit = (png_byte)unit;
  482.    length = png_strlen(swidth) + 1;
  483.    png_debug1(3, "allocating unit for info (%d bytes)n", length);
  484.    info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
  485.    if (info_ptr->scal_s_width == NULL)
  486.    {
  487.       png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
  488.    }
  489.    png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
  491.    length = png_strlen(sheight) + 1;
  492.    png_debug1(3, "allocating unit for info (%d bytes)n", length);
  493.    info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
  494.    if (info_ptr->scal_s_height == NULL)
  495.    {
  496.       png_free (png_ptr, info_ptr->scal_s_width);
  497.       png_warning(png_ptr, "Memory allocation failed while processing sCAL.");
  498.    }
  499.    png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
  501.    info_ptr->valid |= PNG_INFO_sCAL;
  502. #ifdef PNG_FREE_ME_SUPPORTED
  503.    info_ptr->free_me |= PNG_FREE_SCAL;
  504. #endif
  505. }
  506. #endif
  507. #endif
  508. #endif
  510. #if defined(PNG_pHYs_SUPPORTED)
  511. void PNGAPI
  512. png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
  513.    png_uint_32 res_x, png_uint_32 res_y, int unit_type)
  514. {
  515.    png_debug1(1, "in %s storage functionn", "pHYs");
  516.    if (png_ptr == NULL || info_ptr == NULL)
  517.       return;
  519.    info_ptr->x_pixels_per_unit = res_x;
  520.    info_ptr->y_pixels_per_unit = res_y;
  521.    info_ptr->phys_unit_type = (png_byte)unit_type;
  522.    info_ptr->valid |= PNG_INFO_pHYs;
  523. }
  524. #endif
  526. void PNGAPI
  527. png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
  528.    png_colorp palette, int num_palette)
  529. {
  531.    png_debug1(1, "in %s storage functionn", "PLTE");
  532.    if (png_ptr == NULL || info_ptr == NULL)
  533.       return;
  535.    if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
  536.      {
  537.        if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  538.          png_error(png_ptr, "Invalid palette length");
  539.        else
  540.        {
  541.          png_warning(png_ptr, "Invalid palette length");
  542.          return;
  543.        }
  544.      }
  546.    /*
  547.     * It may not actually be necessary to set png_ptr->palette here;
  548.     * we do it for backward compatibility with the way the png_handle_tRNS
  549.     * function used to do the allocation.
  550.     */
  551. #ifdef PNG_FREE_ME_SUPPORTED
  552.    png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
  553. #endif
  555.    /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
  556.       of num_palette entries,
  557.       in case of an invalid PNG file that has too-large sample values. */
  558.    png_ptr->palette = (png_colorp)png_malloc(png_ptr,
  559.       PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
  560.    png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
  561.       png_sizeof(png_color));
  562.    png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color));
  563.    info_ptr->palette = png_ptr->palette;
  564.    info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
  566. #ifdef PNG_FREE_ME_SUPPORTED
  567.    info_ptr->free_me |= PNG_FREE_PLTE;
  568. #else
  569.    png_ptr->flags |= PNG_FLAG_FREE_PLTE;
  570. #endif
  572.    info_ptr->valid |= PNG_INFO_PLTE;
  573. }
  575. #if defined(PNG_sBIT_SUPPORTED)
  576. void PNGAPI
  577. png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
  578.    png_color_8p sig_bit)
  579. {
  580.    png_debug1(1, "in %s storage functionn", "sBIT");
  581.    if (png_ptr == NULL || info_ptr == NULL)
  582.       return;
  584.    png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8));
  585.    info_ptr->valid |= PNG_INFO_sBIT;
  586. }
  587. #endif
  589. #if defined(PNG_sRGB_SUPPORTED)
  590. void PNGAPI
  591. png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
  592. {
  593.    png_debug1(1, "in %s storage functionn", "sRGB");
  594.    if (png_ptr == NULL || info_ptr == NULL)
  595.       return;
  597.    info_ptr->srgb_intent = (png_byte)intent;
  598.    info_ptr->valid |= PNG_INFO_sRGB;
  599. }
  601. void PNGAPI
  602. png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
  603.    int intent)
  604. {
  605. #if defined(PNG_gAMA_SUPPORTED)
  606. #ifdef PNG_FLOATING_POINT_SUPPORTED
  607.    float file_gamma;
  608. #endif
  609. #ifdef PNG_FIXED_POINT_SUPPORTED
  610.    png_fixed_point int_file_gamma;
  611. #endif
  612. #endif
  613. #if defined(PNG_cHRM_SUPPORTED)
  614. #ifdef PNG_FLOATING_POINT_SUPPORTED
  615.    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
  616. #endif
  617. #ifdef PNG_FIXED_POINT_SUPPORTED
  618.    png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
  619.       int_green_y, int_blue_x, int_blue_y;
  620. #endif
  621. #endif
  622.    png_debug1(1, "in %s storage functionn", "sRGB_gAMA_and_cHRM");
  623.    if (png_ptr == NULL || info_ptr == NULL)
  624.       return;
  626.    png_set_sRGB(png_ptr, info_ptr, intent);
  628. #if defined(PNG_gAMA_SUPPORTED)
  629. #ifdef PNG_FLOATING_POINT_SUPPORTED
  630.    file_gamma = (float).45455;
  631.    png_set_gAMA(png_ptr, info_ptr, file_gamma);
  632. #endif
  633. #ifdef PNG_FIXED_POINT_SUPPORTED
  634.    int_file_gamma = 45455L;
  635.    png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
  636. #endif
  637. #endif
  639. #if defined(PNG_cHRM_SUPPORTED)
  640. #ifdef PNG_FIXED_POINT_SUPPORTED
  641.    int_white_x = 31270L;
  642.    int_white_y = 32900L;
  643.    int_red_x   = 64000L;
  644.    int_red_y   = 33000L;
  645.    int_green_x = 30000L;
  646.    int_green_y = 60000L;
  647.    int_blue_x  = 15000L;
  648.    int_blue_y  =  6000L;
  650.    png_set_cHRM_fixed(png_ptr, info_ptr,
  651.       int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
  652.       int_blue_x, int_blue_y);
  653. #endif
  654. #ifdef PNG_FLOATING_POINT_SUPPORTED
  655.    white_x = (float).3127;
  656.    white_y = (float).3290;
  657.    red_x   = (float).64;
  658.    red_y   = (float).33;
  659.    green_x = (float).30;
  660.    green_y = (float).60;
  661.    blue_x  = (float).15;
  662.    blue_y  = (float).06;
  664.    png_set_cHRM(png_ptr, info_ptr,
  665.       white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
  666. #endif
  667. #endif
  668. }
  669. #endif
  672. #if defined(PNG_iCCP_SUPPORTED)
  673. void PNGAPI
  674. png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
  675.              png_charp name, int compression_type,
  676.              png_charp profile, png_uint_32 proflen)
  677. {
  678.    png_charp new_iccp_name;
  679.    png_charp new_iccp_profile;
  681.    png_debug1(1, "in %s storage functionn", "iCCP");
  682.    if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
  683.       return;
  685.    new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1);
  686.    if (new_iccp_name == NULL)
  687.    {
  688.       png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
  689.       return;
  690.    }
  691.    png_strcpy(new_iccp_name, name);
  692.    new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
  693.    if (new_iccp_profile == NULL)
  694.    {
  695.       png_free (png_ptr, new_iccp_name);
  696.       png_warning(png_ptr, "Insufficient memory to process iCCP profile.");
  697.       return;
  698.    }
  699.    png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
  701.    png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
  703.    info_ptr->iccp_proflen = proflen;
  704.    info_ptr->iccp_name = new_iccp_name;
  705.    info_ptr->iccp_profile = new_iccp_profile;
  706.    /* Compression is always zero but is here so the API and info structure
  707.     * does not have to change if we introduce multiple compression types */
  708.    info_ptr->iccp_compression = (png_byte)compression_type;
  709. #ifdef PNG_FREE_ME_SUPPORTED
  710.    info_ptr->free_me |= PNG_FREE_ICCP;
  711. #endif
  712.    info_ptr->valid |= PNG_INFO_iCCP;
  713. }
  714. #endif
  716. #if defined(PNG_TEXT_SUPPORTED)
  717. void PNGAPI
  718. png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
  719.    int num_text)
  720. {
  721.    int ret;
  722.    ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
  723.    if (ret)
  724.      png_error(png_ptr, "Insufficient memory to store text");
  725. }
  727. int /* PRIVATE */
  728. png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
  729.    int num_text)
  730. {
  731.    int i;
  733.    png_debug1(1, "in %s storage functionn", (png_ptr->chunk_name[0] == '' ?
  734.       "text" : (png_const_charp)png_ptr->chunk_name));
  736.    if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
  737.       return(0);
  739.    /* Make sure we have enough space in the "text" array in info_struct
  740.     * to hold all of the incoming text_ptr objects.
  741.     */
  742.    if (info_ptr->num_text + num_text > info_ptr->max_text)
  743.    {
  744.       if (info_ptr->text != NULL)
  745.       {
  746.          png_textp old_text;
  747.          int old_max;
  749.          old_max = info_ptr->max_text;
  750.          info_ptr->max_text = info_ptr->num_text + num_text + 8;
  751.          old_text = info_ptr->text;
  752.          info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
  753.             (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));
  754.          if (info_ptr->text == NULL)
  755.            {
  756.              png_free(png_ptr, old_text);
  757.              return(1);
  758.            }
  759.          png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
  760.             png_sizeof(png_text)));
  761.          png_free(png_ptr, old_text);
  762.       }
  763.       else
  764.       {
  765.          info_ptr->max_text = num_text + 8;
  766.          info_ptr->num_text = 0;
  767.          info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
  768.             (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));
  769.          if (info_ptr->text == NULL)
  770.            return(1);
  771. #ifdef PNG_FREE_ME_SUPPORTED
  772.          info_ptr->free_me |= PNG_FREE_TEXT;
  773. #endif
  774.       }
  775.       png_debug1(3, "allocated %d entries for info_ptr->textn",
  776.          info_ptr->max_text);
  777.    }
  778.    for (i = 0; i < num_text; i++)
  779.    {
  780.       png_size_t text_length,key_len;
  781.       png_size_t lang_len,lang_key_len;
  782.       png_textp textp = &(info_ptr->text[info_ptr->num_text]);
  784.       if (text_ptr[i].key == NULL)
  785.           continue;
  787.       key_len = png_strlen(text_ptr[i].key);
  789.       if(text_ptr[i].compression <= 0)
  790.       {
  791.         lang_len = 0;
  792.         lang_key_len = 0;
  793.       }
  794.       else
  795. #ifdef PNG_iTXt_SUPPORTED
  796.       {
  797.         /* set iTXt data */
  798.         if (text_ptr[i].lang != NULL)
  799.           lang_len = png_strlen(text_ptr[i].lang);
  800.         else
  801.           lang_len = 0;
  802.         if (text_ptr[i].lang_key != NULL)
  803.           lang_key_len = png_strlen(text_ptr[i].lang_key);
  804.         else
  805.           lang_key_len = 0;
  806.       }
  807. #else
  808.       {
  809.         png_warning(png_ptr, "iTXt chunk not supported.");
  810.         continue;
  811.       }
  812. #endif
  814.       if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '')
  815.       {
  816.          text_length = 0;
  817. #ifdef PNG_iTXt_SUPPORTED
  818.          if(text_ptr[i].compression > 0)
  819.             textp->compression = PNG_ITXT_COMPRESSION_NONE;
  820.          else
  821. #endif
  822.             textp->compression = PNG_TEXT_COMPRESSION_NONE;
  823.       }
  824.       else
  825.       {
  826.          text_length = png_strlen(text_ptr[i].text);
  827.          textp->compression = text_ptr[i].compression;
  828.       }
  830.       textp->key = (png_charp)png_malloc_warn(png_ptr,
  831.          (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));
  832.       if (textp->key == NULL)
  833.         return(1);
  834.       png_debug2(2, "Allocated %lu bytes at %x in png_set_textn",
  835.          (png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4),
  836.          (int)textp->key);
  838.       png_memcpy(textp->key, text_ptr[i].key,
  839.          (png_size_t)(key_len));
  840.       *(textp->key+key_len) = '';
  841. #ifdef PNG_iTXt_SUPPORTED
  842.       if (text_ptr[i].compression > 0)
  843.       {
  844.          textp->lang=textp->key + key_len + 1;
  845.          png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
  846.          *(textp->lang+lang_len) = '';
  847.          textp->lang_key=textp->lang + lang_len + 1;
  848.          png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
  849.          *(textp->lang_key+lang_key_len) = '';
  850.          textp->text=textp->lang_key + lang_key_len + 1;
  851.       }
  852.       else
  853. #endif
  854.       {
  855. #ifdef PNG_iTXt_SUPPORTED
  856.          textp->lang=NULL;
  857.          textp->lang_key=NULL;
  858. #endif
  859.          textp->text=textp->key + key_len + 1;
  860.       }
  861.       if(text_length)
  862.          png_memcpy(textp->text, text_ptr[i].text,
  863.             (png_size_t)(text_length));
  864.       *(textp->text+text_length) = '';
  866. #ifdef PNG_iTXt_SUPPORTED
  867.       if(textp->compression > 0)
  868.       {
  869.          textp->text_length = 0;
  870.          textp->itxt_length = text_length;
  871.       }
  872.       else
  873. #endif
  874.       {
  875.          textp->text_length = text_length;
  876. #ifdef PNG_iTXt_SUPPORTED
  877.          textp->itxt_length = 0;
  878. #endif
  879.       }
  880.       info_ptr->text[info_ptr->num_text]= *textp;
  881.       info_ptr->num_text++;
  882.       png_debug1(3, "transferred text chunk %dn", info_ptr->num_text);
  883.    }
  884.    return(0);
  885. }
  886. #endif
  888. #if defined(PNG_tIME_SUPPORTED)
  889. void PNGAPI
  890. png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
  891. {
  892.    png_debug1(1, "in %s storage functionn", "tIME");
  893.    if (png_ptr == NULL || info_ptr == NULL ||
  894.        (png_ptr->mode & PNG_WROTE_tIME))
  895.       return;
  897.    png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time));
  898.    info_ptr->valid |= PNG_INFO_tIME;
  899. }
  900. #endif
  902. #if defined(PNG_tRNS_SUPPORTED)
  903. void PNGAPI
  904. png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
  905.    png_bytep trans, int num_trans, png_color_16p trans_values)
  906. {
  907.    png_debug1(1, "in %s storage functionn", "tRNS");
  908.    if (png_ptr == NULL || info_ptr == NULL)
  909.       return;
  911.    if (trans != NULL)
  912.    {
  913.        /*
  914.         * It may not actually be necessary to set png_ptr->trans here;
  915.         * we do it for backward compatibility with the way the png_handle_tRNS
  916.         * function used to do the allocation.
  917.         */
  918. #ifdef PNG_FREE_ME_SUPPORTED
  919.        png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
  920. #endif
  921.        /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
  922.        png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
  923.            (png_uint_32)PNG_MAX_PALETTE_LENGTH);
  924.        if (num_trans <= PNG_MAX_PALETTE_LENGTH)
  925.          png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
  926. #ifdef PNG_FREE_ME_SUPPORTED
  927.        info_ptr->free_me |= PNG_FREE_TRNS;
  928. #else
  929.        png_ptr->flags |= PNG_FLAG_FREE_TRNS;
  930. #endif
  931.    }
  933.    if (trans_values != NULL)
  934.    {
  935.       png_memcpy(&(info_ptr->trans_values), trans_values,
  936.          png_sizeof(png_color_16));
  937.       if (num_trans == 0)
  938.         num_trans = 1;
  939.    }
  940.    info_ptr->num_trans = (png_uint_16)num_trans;
  941.    info_ptr->valid |= PNG_INFO_tRNS;
  942. }
  943. #endif
  945. #if defined(PNG_sPLT_SUPPORTED)
  946. void PNGAPI
  947. png_set_sPLT(png_structp png_ptr,
  948.              png_infop info_ptr, png_sPLT_tp entries, int nentries)
  949. {
  950.     png_sPLT_tp np;
  951.     int i;
  953.     if (png_ptr == NULL || info_ptr == NULL)
  954.        return;
  956.     np = (png_sPLT_tp)png_malloc_warn(png_ptr,
  957.         (info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t));
  958.     if (np == NULL)
  959.     {
  960.       png_warning(png_ptr, "No memory for sPLT palettes.");
  961.       return;
  962.     }
  964.     png_memcpy(np, info_ptr->splt_palettes,
  965.            info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
  966.     png_free(png_ptr, info_ptr->splt_palettes);
  967.     info_ptr->splt_palettes=NULL;
  969.     for (i = 0; i < nentries; i++)
  970.     {
  971.         png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
  972.         png_sPLT_tp from = entries + i;
  974.         to->name = (png_charp)png_malloc(png_ptr,
  975.             png_strlen(from->name) + 1);
  976.         /* TODO: use png_malloc_warn */
  977.         png_strcpy(to->name, from->name);
  978.         to->entries = (png_sPLT_entryp)png_malloc(png_ptr,
  979.             from->nentries * png_sizeof(png_sPLT_entry));
  980.         /* TODO: use png_malloc_warn */
  981.         png_memcpy(to->entries, from->entries,
  982.             from->nentries * png_sizeof(png_sPLT_entry));
  983.         to->nentries = from->nentries;
  984.         to->depth = from->depth;
  985.     }
  987.     info_ptr->splt_palettes = np;
  988.     info_ptr->splt_palettes_num += nentries;
  989.     info_ptr->valid |= PNG_INFO_sPLT;
  990. #ifdef PNG_FREE_ME_SUPPORTED
  991.     info_ptr->free_me |= PNG_FREE_SPLT;
  992. #endif
  993. }
  994. #endif /* PNG_sPLT_SUPPORTED */
  996. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  997. void PNGAPI
  998. png_set_unknown_chunks(png_structp png_ptr,
  999.    png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
  1000. {
  1001.     png_unknown_chunkp np;
  1002.     int i;
  1004.     if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
  1005.         return;
  1007.     np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
  1008.         (info_ptr->unknown_chunks_num + num_unknowns) *
  1009.         png_sizeof(png_unknown_chunk));
  1010.     if (np == NULL)
  1011.     {
  1012.        png_warning(png_ptr, "Out of memory while processing unknown chunk.");
  1013.        return;
  1014.     }
  1016.     png_memcpy(np, info_ptr->unknown_chunks,
  1017.            info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
  1018.     png_free(png_ptr, info_ptr->unknown_chunks);
  1019.     info_ptr->unknown_chunks=NULL;
  1021.     for (i = 0; i < num_unknowns; i++)
  1022.     {
  1023.         png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
  1024.         png_unknown_chunkp from = unknowns + i;
  1026.         png_strncpy((png_charp)to->name, (png_charp)from->name, 5);
  1027.         to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);
  1028.         if (to->data == NULL)
  1029.         {
  1030.            png_warning(png_ptr, "Out of memory processing unknown chunk.");
  1031.         }
  1032.         else
  1033.         {
  1034.            png_memcpy(to->data, from->data, from->size);
  1035.            to->size = from->size;
  1037.            /* note our location in the read or write sequence */
  1038.            to->location = (png_byte)(png_ptr->mode & 0xff);
  1039.         }
  1040.     }
  1042.     info_ptr->unknown_chunks = np;
  1043.     info_ptr->unknown_chunks_num += num_unknowns;
  1044. #ifdef PNG_FREE_ME_SUPPORTED
  1045.     info_ptr->free_me |= PNG_FREE_UNKN;
  1046. #endif
  1047. }
  1048. void PNGAPI
  1049. png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
  1050.    int chunk, int location)
  1051. {
  1052.    if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
  1053.          (int)info_ptr->unknown_chunks_num)
  1054.       info_ptr->unknown_chunks[chunk].location = (png_byte)location;
  1055. }
  1056. #endif
  1058. #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
  1059. #if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || 
  1060.     defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
  1061. void PNGAPI
  1062. png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
  1063. {
  1064.    /* This function is deprecated in favor of png_permit_mng_features()
  1065.       and will be removed from libpng-1.3.0 */
  1066.    png_debug(1, "in png_permit_empty_plte, DEPRECATED.n");
  1067.    if (png_ptr == NULL)
  1068.       return;
  1069.    png_ptr->mng_features_permitted = (png_byte)
  1070.      ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) |
  1071.      ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
  1072. }
  1073. #endif
  1074. #endif
  1076. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  1077. png_uint_32 PNGAPI
  1078. png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
  1079. {
  1080.    png_debug(1, "in png_permit_mng_featuresn");
  1081.    if (png_ptr == NULL)
  1082.       return (png_uint_32)0;
  1083.    png_ptr->mng_features_permitted =
  1084.      (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
  1085.    return (png_uint_32)png_ptr->mng_features_permitted;
  1086. }
  1087. #endif
  1089. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  1090. void PNGAPI
  1091. png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
  1092.    chunk_list, int num_chunks)
  1093. {
  1094.     png_bytep new_list, p;
  1095.     int i, old_num_chunks;
  1096.     if (png_ptr == NULL)
  1097.        return;
  1098.     if (num_chunks == 0)
  1099.     {
  1100.       if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
  1101.         png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
  1102.       else
  1103.         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
  1105.       if(keep == PNG_HANDLE_CHUNK_ALWAYS)
  1106.         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
  1107.       else
  1108.         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
  1109.       return;
  1110.     }
  1111.     if (chunk_list == NULL)
  1112.       return;
  1113.     old_num_chunks=png_ptr->num_chunk_list;
  1114.     new_list=(png_bytep)png_malloc(png_ptr,
  1115.        (png_uint_32)(5*(num_chunks+old_num_chunks)));
  1116.     if(png_ptr->chunk_list != NULL)
  1117.     {
  1118.        png_memcpy(new_list, png_ptr->chunk_list,
  1119.           (png_size_t)(5*old_num_chunks));
  1120.        png_free(png_ptr, png_ptr->chunk_list);
  1121.        png_ptr->chunk_list=NULL;
  1122.     }
  1123.     png_memcpy(new_list+5*old_num_chunks, chunk_list,
  1124.        (png_size_t)(5*num_chunks));
  1125.     for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5)
  1126.        *p=(png_byte)keep;
  1127.     png_ptr->num_chunk_list=old_num_chunks+num_chunks;
  1128.     png_ptr->chunk_list=new_list;
  1129. #ifdef PNG_FREE_ME_SUPPORTED
  1130.     png_ptr->free_me |= PNG_FREE_LIST;
  1131. #endif
  1132. }
  1133. #endif
  1135. #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
  1136. void PNGAPI
  1137. png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
  1138.    png_user_chunk_ptr read_user_chunk_fn)
  1139. {
  1140.    png_debug(1, "in png_set_read_user_chunk_fnn");
  1141.    if (png_ptr == NULL)
  1142.       return;
  1143.    png_ptr->read_user_chunk_fn = read_user_chunk_fn;
  1144.    png_ptr->user_chunk_ptr = user_chunk_ptr;
  1145. }
  1146. #endif
  1148. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  1149. void PNGAPI
  1150. png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
  1151. {
  1152.    png_debug1(1, "in %s storage functionn", "rows");
  1154.    if (png_ptr == NULL || info_ptr == NULL)
  1155.       return;
  1157.    if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
  1158.       png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
  1159.    info_ptr->row_pointers = row_pointers;
  1160.    if(row_pointers)
  1161.       info_ptr->valid |= PNG_INFO_IDAT;
  1162. }
  1163. #endif
  1165. #ifdef PNG_WRITE_SUPPORTED
  1166. void PNGAPI
  1167. png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
  1168. {
  1169.     if (png_ptr == NULL)
  1170.        return;
  1171.     if(png_ptr->zbuf)
  1172.        png_free(png_ptr, png_ptr->zbuf);
  1173.     png_ptr->zbuf_size = (png_size_t)size;
  1174.     png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
  1175.     png_ptr->zstream.next_out = png_ptr->zbuf;
  1176.     png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1177. }
  1178. #endif
  1180. void PNGAPI
  1181. png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
  1182. {
  1183.    if (png_ptr && info_ptr)
  1184.       info_ptr->valid &= ~(mask);
  1185. }
  1188. #ifndef PNG_1_0_X
  1189. #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
  1190. /* this function was added to libpng 1.2.0 and should always exist by default */
  1191. void PNGAPI
  1192. png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
  1193. {
  1194. #ifdef PNG_MMX_CODE_SUPPORTED
  1195.     png_uint_32 settable_asm_flags;
  1196.     png_uint_32 settable_mmx_flags;
  1197. #endif
  1198.     if (png_ptr == NULL)
  1199.        return;
  1200. #ifdef PNG_MMX_CODE_SUPPORTED
  1202.     settable_mmx_flags =
  1203. #ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
  1204.                          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
  1205. #endif
  1206. #ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
  1207.                          PNG_ASM_FLAG_MMX_READ_INTERLACE    |
  1208. #endif
  1209. #ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
  1210.                          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
  1211.                          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
  1212.                          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
  1213.                          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH |
  1214. #endif
  1215.                          0;
  1217.     /* could be some non-MMX ones in the future, but not currently: */
  1218.     settable_asm_flags = settable_mmx_flags;
  1220.     if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) ||
  1221.         !(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU))
  1222.     {
  1223.         /* clear all MMX flags if MMX isn't supported */
  1224.         settable_asm_flags &= ~settable_mmx_flags;
  1225.         png_ptr->asm_flags &= ~settable_mmx_flags;
  1226.     }
  1228.     /* we're replacing the settable bits with those passed in by the user,
  1229.      * so first zero them out of the master copy, then bitwise-OR in the
  1230.      * allowed subset that was requested */
  1232.     png_ptr->asm_flags &= ~settable_asm_flags;               /* zero them */
  1233.     png_ptr->asm_flags |= (asm_flags & settable_asm_flags);  /* set them */
  1234. #endif /* ?PNG_MMX_CODE_SUPPORTED */
  1235. }
  1237. /* this function was added to libpng 1.2.0 */
  1238. void PNGAPI
  1239. png_set_mmx_thresholds (png_structp png_ptr,
  1240.                         png_byte mmx_bitdepth_threshold,
  1241.                         png_uint_32 mmx_rowbytes_threshold)
  1242. {
  1243.     if (png_ptr == NULL)
  1244.        return;
  1245. #ifdef PNG_MMX_CODE_SUPPORTED
  1246.     png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold;
  1247.     png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold;
  1248. #endif /* ?PNG_MMX_CODE_SUPPORTED */
  1249. }
  1250. #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
  1252. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  1253. /* this function was added to libpng 1.2.6 */
  1254. void PNGAPI
  1255. png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
  1256.     png_uint_32 user_height_max)
  1257. {
  1258.     /* Images with dimensions larger than these limits will be
  1259.      * rejected by png_set_IHDR().  To accept any PNG datastream
  1260.      * regardless of dimensions, set both limits to 0x7ffffffL.
  1261.      */
  1262.     if(png_ptr == NULL) return;
  1263.     png_ptr->user_width_max = user_width_max;
  1264.     png_ptr->user_height_max = user_height_max;
  1265. }
  1266. #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
  1268. #endif /* ?PNG_1_0_X */
  1269. #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */