home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / png / pngwrite.c < prev    next >
C/C++ Source or Header  |  2002-07-09  |  49KB  |  1,451 lines
  1.  
  2. /* pngwrite.c - general routines to write a PNG file
  3.  *
  4.  * libpng 1.2.4 - July 8, 2002
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2002 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.  
  11. /* get internal access to png.h */
  12. #define PNG_INTERNAL
  13. #include "png.h"
  14. #ifdef PNG_WRITE_SUPPORTED
  15.  
  16. /* Writes all the PNG information.  This is the suggested way to use the
  17.  * library.  If you have a new chunk to add, make a function to write it,
  18.  * and put it in the correct location here.  If you want the chunk written
  19.  * after the image data, put it in png_write_end().  I strongly encourage
  20.  * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
  21.  * the chunk, as that will keep the code from breaking if you want to just
  22.  * write a plain PNG file.  If you have long comments, I suggest writing
  23.  * them in png_write_end(), and compressing them.
  24.  */
  25. void PNGAPI
  26. png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
  27. {
  28.    png_debug(1, "in png_write_info_before_PLTE\n");
  29.    if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
  30.    {
  31.    png_write_sig(png_ptr); /* write PNG signature */
  32. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  33.    if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
  34.    {
  35.       png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");
  36.       png_ptr->mng_features_permitted=0;
  37.    }
  38. #endif
  39.    /* write IHDR information. */
  40.    png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
  41.       info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
  42.       info_ptr->filter_type,
  43. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  44.       info_ptr->interlace_type);
  45. #else
  46.       0);
  47. #endif
  48.    /* the rest of these check to see if the valid field has the appropriate
  49.       flag set, and if it does, writes the chunk. */
  50. #if defined(PNG_WRITE_gAMA_SUPPORTED)
  51.    if (info_ptr->valid & PNG_INFO_gAMA)
  52.    {
  53. #  ifdef PNG_FLOATING_POINT_SUPPORTED
  54.       png_write_gAMA(png_ptr, info_ptr->gamma);
  55. #else
  56. #ifdef PNG_FIXED_POINT_SUPPORTED
  57.       png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);
  58. #  endif
  59. #endif
  60.    }
  61. #endif
  62. #if defined(PNG_WRITE_sRGB_SUPPORTED)
  63.    if (info_ptr->valid & PNG_INFO_sRGB)
  64.       png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
  65. #endif
  66. #if defined(PNG_WRITE_iCCP_SUPPORTED)
  67.    if (info_ptr->valid & PNG_INFO_iCCP)
  68.       png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
  69.                      info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
  70. #endif
  71. #if defined(PNG_WRITE_sBIT_SUPPORTED)
  72.    if (info_ptr->valid & PNG_INFO_sBIT)
  73.       png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
  74. #endif
  75. #if defined(PNG_WRITE_cHRM_SUPPORTED)
  76.    if (info_ptr->valid & PNG_INFO_cHRM)
  77.    {
  78. #ifdef PNG_FLOATING_POINT_SUPPORTED
  79.       png_write_cHRM(png_ptr,
  80.          info_ptr->x_white, info_ptr->y_white,
  81.          info_ptr->x_red, info_ptr->y_red,
  82.          info_ptr->x_green, info_ptr->y_green,
  83.          info_ptr->x_blue, info_ptr->y_blue);
  84. #else
  85. #  ifdef PNG_FIXED_POINT_SUPPORTED
  86.       png_write_cHRM_fixed(png_ptr,
  87.          info_ptr->int_x_white, info_ptr->int_y_white,
  88.          info_ptr->int_x_red, info_ptr->int_y_red,
  89.          info_ptr->int_x_green, info_ptr->int_y_green,
  90.          info_ptr->int_x_blue, info_ptr->int_y_blue);
  91. #  endif
  92. #endif
  93.    }
  94. #endif
  95. #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
  96.    if (info_ptr->unknown_chunks_num)
  97.    {
  98.        png_unknown_chunk *up;
  99.  
  100.        png_debug(5, "writing extra chunks\n");
  101.  
  102.        for (up = info_ptr->unknown_chunks;
  103.             up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
  104.             up++)
  105.        {
  106.          int keep=png_handle_as_unknown(png_ptr, up->name);
  107.          if (keep != HANDLE_CHUNK_NEVER &&
  108.             up->location && (!(up->location & PNG_HAVE_PLTE)) &&
  109.             ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS ||
  110.             (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
  111.          {
  112.             png_write_chunk(png_ptr, up->name, up->data, up->size);
  113.          }
  114.        }
  115.    }
  116. #endif
  117.       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
  118.    }
  119. }
  120.  
  121. void PNGAPI
  122. png_write_info(png_structp png_ptr, png_infop info_ptr)
  123. {
  124. #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
  125.    int i;
  126. #endif
  127.  
  128.    png_debug(1, "in png_write_info\n");
  129.  
  130.    png_write_info_before_PLTE(png_ptr, info_ptr);
  131.  
  132.    if (info_ptr->valid & PNG_INFO_PLTE)
  133.       png_write_PLTE(png_ptr, info_ptr->palette,
  134.          (png_uint_32)info_ptr->num_palette);
  135.    else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  136.       png_error(png_ptr, "Valid palette required for paletted images\n");
  137.  
  138. #if defined(PNG_WRITE_tRNS_SUPPORTED)
  139.    if (info_ptr->valid & PNG_INFO_tRNS)
  140.       {
  141. #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  142.          /* invert the alpha channel (in tRNS) */
  143.          if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
  144.             info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  145.          {
  146.             int j;
  147.             for (j=0; j<(int)info_ptr->num_trans; j++)
  148.                info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
  149.          }
  150. #endif
  151.       png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
  152.          info_ptr->num_trans, info_ptr->color_type);
  153.       }
  154. #endif
  155. #if defined(PNG_WRITE_bKGD_SUPPORTED)
  156.    if (info_ptr->valid & PNG_INFO_bKGD)
  157.       png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
  158. #endif
  159. #if defined(PNG_WRITE_hIST_SUPPORTED)
  160.    if (info_ptr->valid & PNG_INFO_hIST)
  161.       png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
  162. #endif
  163. #if defined(PNG_WRITE_oFFs_SUPPORTED)
  164.    if (info_ptr->valid & PNG_INFO_oFFs)
  165.       png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
  166.          info_ptr->offset_unit_type);
  167. #endif
  168. #if defined(PNG_WRITE_pCAL_SUPPORTED)
  169.    if (info_ptr->valid & PNG_INFO_pCAL)
  170.       png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
  171.          info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
  172.          info_ptr->pcal_units, info_ptr->pcal_params);
  173. #endif
  174. #if defined(PNG_WRITE_sCAL_SUPPORTED)
  175.    if (info_ptr->valid & PNG_INFO_sCAL)
  176. #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
  177.       png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
  178.           info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
  179. #else
  180. #ifdef PNG_FIXED_POINT_SUPPORTED
  181.       png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
  182.           info_ptr->scal_s_width, info_ptr->scal_s_height);
  183. #else
  184.       png_warning(png_ptr,
  185.           "png_write_sCAL not supported; sCAL chunk not written.\n");
  186. #endif
  187. #endif
  188. #endif
  189. #if defined(PNG_WRITE_pHYs_SUPPORTED)
  190.    if (info_ptr->valid & PNG_INFO_pHYs)
  191.       png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
  192.          info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
  193. #endif
  194. #if defined(PNG_WRITE_tIME_SUPPORTED)
  195.    if (info_ptr->valid & PNG_INFO_tIME)
  196.    {
  197.       png_write_tIME(png_ptr, &(info_ptr->mod_time));
  198.       png_ptr->mode |= PNG_WROTE_tIME;
  199.    }
  200. #endif
  201. #if defined(PNG_WRITE_sPLT_SUPPORTED)
  202.    if (info_ptr->valid & PNG_INFO_sPLT)
  203.      for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
  204.        png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
  205. #endif
  206. #if defined(PNG_WRITE_TEXT_SUPPORTED)
  207.    /* Check to see if we need to write text chunks */
  208.    for (i = 0; i < info_ptr->num_text; i++)
  209.    {
  210.       png_debug2(2, "Writing header text chunk %d, type %d\n", i,
  211.          info_ptr->text[i].compression);
  212.       /* an internationalized chunk? */
  213.       if (info_ptr->text[i].compression > 0)
  214.       {
  215. #if defined(PNG_WRITE_iTXt_SUPPORTED)
  216.           /* write international chunk */
  217.           png_write_iTXt(png_ptr,
  218.                          info_ptr->text[i].compression,
  219.                          info_ptr->text[i].key,
  220.                          info_ptr->text[i].lang,
  221.                          info_ptr->text[i].lang_key,
  222.                          info_ptr->text[i].text);
  223. #else
  224.           png_warning(png_ptr, "Unable to write international text\n");
  225. #endif
  226.           /* Mark this chunk as written */
  227.           info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
  228.       }
  229.       /* If we want a compressed text chunk */
  230.       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
  231.       {
  232. #if defined(PNG_WRITE_zTXt_SUPPORTED)
  233.          /* write compressed chunk */
  234.          png_write_zTXt(png_ptr, info_ptr->text[i].key,
  235.             info_ptr->text[i].text, 0,
  236.             info_ptr->text[i].compression);
  237. #else
  238.          png_warning(png_ptr, "Unable to write compressed text\n");
  239. #endif
  240.          /* Mark this chunk as written */
  241.          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
  242.       }
  243.       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
  244.       {
  245. #if defined(PNG_WRITE_tEXt_SUPPORTED)
  246.          /* write uncompressed chunk */
  247.          png_write_tEXt(png_ptr, info_ptr->text[i].key,
  248.                          info_ptr->text[i].text,
  249.                          0);
  250. #else
  251.          png_warning(png_ptr, "Unable to write uncompressed text\n");
  252. #endif
  253.          /* Mark this chunk as written */
  254.          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
  255.       }
  256.    }
  257. #endif
  258. #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
  259.    if (info_ptr->unknown_chunks_num)
  260.    {
  261.        png_unknown_chunk *up;
  262.  
  263.        png_debug(5, "writing extra chunks\n");
  264.  
  265.        for (up = info_ptr->unknown_chunks;
  266.             up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
  267.             up++)
  268.        {
  269.          int keep=png_handle_as_unknown(png_ptr, up->name);
  270.          if (keep != HANDLE_CHUNK_NEVER &&
  271.             up->location && (up->location & PNG_HAVE_PLTE) &&
  272.             !(up->location & PNG_HAVE_IDAT) &&
  273.             ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS ||
  274.             (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
  275.          {
  276.             png_write_chunk(png_ptr, up->name, up->data, up->size);
  277.          }
  278.        }
  279.    }
  280. #endif
  281. }
  282.  
  283. /* Writes the end of the PNG file.  If you don't want to write comments or
  284.  * time information, you can pass NULL for info.  If you already wrote these
  285.  * in png_write_info(), do not write them again here.  If you have long
  286.  * comments, I suggest writing them here, and compressing them.
  287.  */
  288. void PNGAPI
  289. png_write_end(png_structp png_ptr, png_infop info_ptr)
  290. {
  291.    png_debug(1, "in png_write_end\n");
  292.    if (!(png_ptr->mode & PNG_HAVE_IDAT))
  293.       png_error(png_ptr, "No IDATs written into file");
  294.  
  295.    /* see if user wants us to write information chunks */
  296.    if (info_ptr != NULL)
  297.    {
  298. #if defined(PNG_WRITE_TEXT_SUPPORTED)
  299.       int i; /* local index variable */
  300. #endif
  301. #if defined(PNG_WRITE_tIME_SUPPORTED)
  302.       /* check to see if user has supplied a time chunk */
  303.       if ((info_ptr->valid & PNG_INFO_tIME) &&
  304.          !(png_ptr->mode & PNG_WROTE_tIME))
  305.          png_write_tIME(png_ptr, &(info_ptr->mod_time));
  306. #endif
  307. #if defined(PNG_WRITE_TEXT_SUPPORTED)
  308.       /* loop through comment chunks */
  309.       for (i = 0; i < info_ptr->num_text; i++)
  310.       {
  311.          png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,
  312.             info_ptr->text[i].compression);
  313.          /* an internationalized chunk? */
  314.          if (info_ptr->text[i].compression > 0)
  315.          {
  316. #if defined(PNG_WRITE_iTXt_SUPPORTED)
  317.              /* write international chunk */
  318.              png_write_iTXt(png_ptr,
  319.                          info_ptr->text[i].compression,
  320.                          info_ptr->text[i].key,
  321.                          info_ptr->text[i].lang,
  322.                          info_ptr->text[i].lang_key,
  323.                          info_ptr->text[i].text);
  324. #else
  325.              png_warning(png_ptr, "Unable to write international text\n");
  326. #endif
  327.              /* Mark this chunk as written */
  328.              info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
  329.          }
  330.          else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
  331.          {
  332. #if defined(PNG_WRITE_zTXt_SUPPORTED)
  333.             /* write compressed chunk */
  334.             png_write_zTXt(png_ptr, info_ptr->text[i].key,
  335.                info_ptr->text[i].text, 0,
  336.                info_ptr->text[i].compression);
  337. #else
  338.             png_warning(png_ptr, "Unable to write compressed text\n");
  339. #endif
  340.             /* Mark this chunk as written */
  341.             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
  342.          }
  343.          else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
  344.          {
  345. #if defined(PNG_WRITE_tEXt_SUPPORTED)
  346.             /* write uncompressed chunk */
  347.             png_write_tEXt(png_ptr, info_ptr->text[i].key,
  348.                info_ptr->text[i].text, 0);
  349. #else
  350.             png_warning(png_ptr, "Unable to write uncompressed text\n");
  351. #endif
  352.  
  353.             /* Mark this chunk as written */
  354.             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
  355.          }
  356.       }
  357. #endif
  358. #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
  359.    if (info_ptr->unknown_chunks_num)
  360.    {
  361.        png_unknown_chunk *up;
  362.  
  363.        png_debug(5, "writing extra chunks\n");
  364.  
  365.        for (up = info_ptr->unknown_chunks;
  366.             up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
  367.             up++)
  368.        {
  369.          int keep=png_handle_as_unknown(png_ptr, up->name);
  370.          if (keep != HANDLE_CHUNK_NEVER &&
  371.             up->location && (up->location & PNG_AFTER_IDAT) &&
  372.             ((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS ||
  373.             (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
  374.          {
  375.             png_write_chunk(png_ptr, up->name, up->data, up->size);
  376.          }
  377.        }
  378.    }
  379. #endif
  380.    }
  381.  
  382.    png_ptr->mode |= PNG_AFTER_IDAT;
  383.  
  384.    /* write end of PNG file */
  385.    png_write_IEND(png_ptr);
  386. #if 0
  387. /* This flush, added in libpng-1.0.8,  causes some applications to crash
  388.    because they do not set png_ptr->output_flush_fn */
  389.    png_flush(png_ptr);
  390. #endif
  391. }
  392.  
  393. #if defined(PNG_WRITE_tIME_SUPPORTED)
  394. #if !defined(_WIN32_WCE)
  395. /* "time.h" functions are not supported on WindowsCE */
  396. void PNGAPI
  397. png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
  398. {
  399.    png_debug(1, "in png_convert_from_struct_tm\n");
  400.    ptime->year = (png_uint_16)(1900 + ttime->tm_year);
  401.    ptime->month = (png_byte)(ttime->tm_mon + 1);
  402.    ptime->day = (png_byte)ttime->tm_mday;
  403.    ptime->hour = (png_byte)ttime->tm_hour;
  404.    ptime->minute = (png_byte)ttime->tm_min;
  405.    ptime->second = (png_byte)ttime->tm_sec;
  406. }
  407.  
  408. void PNGAPI
  409. png_convert_from_time_t(png_timep ptime, time_t ttime)
  410. {
  411.    struct tm *tbuf;
  412.  
  413.    png_debug(1, "in png_convert_from_time_t\n");
  414.    tbuf = gmtime(&ttime);
  415.    png_convert_from_struct_tm(ptime, tbuf);
  416. }
  417. #endif
  418. #endif
  419.  
  420. /* Initialize png_ptr structure, and allocate any memory needed */
  421. png_structp PNGAPI
  422. png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
  423.    png_error_ptr error_fn, png_error_ptr warn_fn)
  424. {
  425. #ifdef PNG_USER_MEM_SUPPORTED
  426.    return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
  427.       warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
  428. }
  429.  
  430. /* Alternate initialize png_ptr structure, and allocate any memory needed */
  431. png_structp PNGAPI
  432. png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
  433.    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
  434.    png_malloc_ptr malloc_fn, png_free_ptr free_fn)
  435. {
  436. #endif /* PNG_USER_MEM_SUPPORTED */
  437.    png_structp png_ptr;
  438. #ifdef PNG_SETJMP_SUPPORTED
  439. #ifdef USE_FAR_KEYWORD
  440.    jmp_buf jmpbuf;
  441. #endif
  442. #endif
  443.    int i;
  444.    png_debug(1, "in png_create_write_struct\n");
  445. #ifdef PNG_USER_MEM_SUPPORTED
  446.    png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
  447.       (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
  448. #else
  449.    png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
  450. #endif /* PNG_USER_MEM_SUPPORTED */
  451.    if (png_ptr == NULL)
  452.       return (NULL);
  453.  
  454. #if !defined(PNG_1_0_X)
  455. #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
  456.    png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
  457. #endif
  458. #endif /* PNG_1_0_X */
  459.  
  460. #ifdef PNG_SETJMP_SUPPORTED
  461. #ifdef USE_FAR_KEYWORD
  462.    if (setjmp(jmpbuf))
  463. #else
  464.    if (setjmp(png_ptr->jmpbuf))
  465. #endif
  466.    {
  467.       png_free(png_ptr, png_ptr->zbuf);
  468.       png_ptr->zbuf=NULL;
  469.       png_destroy_struct(png_ptr);
  470.       return (NULL);
  471.    }
  472. #ifdef USE_FAR_KEYWORD
  473.    png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
  474. #endif
  475. #endif
  476.  
  477. #ifdef PNG_USER_MEM_SUPPORTED
  478.    png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
  479. #endif /* PNG_USER_MEM_SUPPORTED */
  480.    png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
  481.  
  482.    i=0;
  483.    do
  484.    {
  485.      if(user_png_ver[i] != png_libpng_ver[i])
  486.         png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  487.    } while (png_libpng_ver[i++]);
  488.  
  489.    if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
  490.    {
  491.      /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
  492.       * we must recompile any applications that use any older library version.
  493.       * For versions after libpng 1.0, we will be compatible, so we need
  494.       * only check the first digit.
  495.       */
  496.      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
  497.          (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||
  498.          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
  499.      {
  500. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  501.         char msg[80];
  502.         if (user_png_ver)
  503.         {
  504.           sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
  505.              user_png_ver);
  506.           png_warning(png_ptr, msg);
  507.         }
  508.         sprintf(msg, "Application  is  running with png.c from libpng-%.20s",
  509.            png_libpng_ver);
  510.         png_warning(png_ptr, msg);
  511. #endif
  512. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  513.         png_ptr->flags=0;
  514. #endif
  515.         png_error(png_ptr,
  516.            "Incompatible libpng version in application and library");
  517.      }
  518.    }
  519.  
  520.    /* initialize zbuf - compression buffer */
  521.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
  522.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
  523.       (png_uint_32)png_ptr->zbuf_size);
  524.  
  525.    png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
  526.       png_flush_ptr_NULL);
  527.  
  528. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  529.    png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
  530.       1, png_doublep_NULL, png_doublep_NULL);
  531. #endif
  532.  
  533. #ifdef PNG_SETJMP_SUPPORTED
  534. /* Applications that neglect to set up their own setjmp() and then encounter
  535.    a png_error() will longjmp here.  Since the jmpbuf is then meaningless we
  536.    abort instead of returning. */
  537. #ifdef USE_FAR_KEYWORD
  538.    if (setjmp(jmpbuf))
  539.       PNG_ABORT();
  540.    png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
  541. #else
  542.    if (setjmp(png_ptr->jmpbuf))
  543.       PNG_ABORT();
  544. #endif
  545. #endif
  546.    return (png_ptr);
  547. }
  548.  
  549. /* Initialize png_ptr structure, and allocate any memory needed */
  550. #undef png_write_init
  551. void PNGAPI
  552. png_write_init(png_structp png_ptr)
  553. {
  554.    /* We only come here via pre-1.0.7-compiled applications */
  555.    png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
  556. }
  557.  
  558. void PNGAPI
  559. png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
  560.    png_size_t png_struct_size, png_size_t png_info_size)
  561. {
  562.    /* We only come here via pre-1.0.12-compiled applications */
  563. #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
  564.    if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size)
  565.    {
  566.       char msg[80];
  567.       png_ptr->warning_fn=NULL;
  568.       if (user_png_ver)
  569.       {
  570.         sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
  571.            user_png_ver);
  572.         png_warning(png_ptr, msg);
  573.       }
  574.       sprintf(msg, "Application  is  running with png.c from libpng-%.20s",
  575.          png_libpng_ver);
  576.       png_warning(png_ptr, msg);
  577.    }
  578. #endif
  579.    if(sizeof(png_struct) > png_struct_size)
  580.      {
  581.        png_ptr->error_fn=NULL;
  582. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  583.        png_ptr->flags=0;
  584. #endif
  585.        png_error(png_ptr,
  586.        "The png struct allocated by the application for writing is too small.");
  587.      }
  588.    if(sizeof(png_info) > png_info_size)
  589.      {
  590.        png_ptr->error_fn=NULL;
  591. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  592.        png_ptr->flags=0;
  593. #endif
  594.        png_error(png_ptr,
  595.        "The info struct allocated by the application for writing is too small.");
  596.      }
  597.    png_write_init_3(&png_ptr, user_png_ver, png_struct_size);
  598. }
  599.  
  600.  
  601. void PNGAPI
  602. png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
  603.    png_size_t png_struct_size)
  604. {
  605.    png_structp png_ptr=*ptr_ptr;
  606. #ifdef PNG_SETJMP_SUPPORTED
  607.    jmp_buf tmp_jmp; /* to save current jump buffer */
  608. #endif
  609.    int i = 0;
  610.    do
  611.    {
  612.      if (user_png_ver[i] != png_libpng_ver[i])
  613.      {
  614. #ifdef PNG_LEGACY_SUPPORTED
  615.        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  616. #else
  617.        png_ptr->warning_fn=NULL;
  618.        png_warning(png_ptr,
  619.      "Application uses deprecated png_write_init() and should be recompiled.");
  620.        break;
  621. #endif
  622.      }
  623.    } while (png_libpng_ver[i++]);
  624.  
  625.    png_debug(1, "in png_write_init_3\n");
  626.  
  627. #ifdef PNG_SETJMP_SUPPORTED
  628.    /* save jump buffer and error functions */
  629.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
  630. #endif
  631.  
  632.    if (sizeof(png_struct) > png_struct_size)
  633.      {
  634.        png_destroy_struct(png_ptr);
  635.        png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
  636.        *ptr_ptr = png_ptr;
  637.      }
  638.  
  639.    /* reset all variables to 0 */
  640.    png_memset(png_ptr, 0, sizeof (png_struct));
  641.  
  642. #if !defined(PNG_1_0_X)
  643. #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
  644.    png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
  645. #endif
  646. #endif /* PNG_1_0_X */
  647.  
  648. #ifdef PNG_SETJMP_SUPPORTED
  649.    /* restore jump buffer */
  650.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
  651. #endif
  652.  
  653.    png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
  654.       png_flush_ptr_NULL);
  655.  
  656.    /* initialize zbuf - compression buffer */
  657.    png_ptr->zbuf_size = PNG_ZBUF_SIZE;
  658.    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
  659.       (png_uint_32)png_ptr->zbuf_size);
  660.  
  661. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  662.    png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
  663.       1, png_doublep_NULL, png_doublep_NULL);
  664. #endif
  665. }
  666.  
  667. /* Write a few rows of image data.  If the image is interlaced,
  668.  * either you will have to write the 7 sub images, or, if you
  669.  * have called png_set_interlace_handling(), you will have to
  670.  * "write" the image seven times.
  671.  */
  672. void PNGAPI
  673. png_write_rows(png_structp png_ptr, png_bytepp row,
  674.    png_uint_32 num_rows)
  675. {
  676.    png_uint_32 i; /* row counter */
  677.    png_bytepp rp; /* row pointer */
  678.  
  679.    png_debug(1, "in png_write_rows\n");
  680.    /* loop through the rows */
  681.    for (i = 0, rp = row; i < num_rows; i++, rp++)
  682.    {
  683.       png_write_row(png_ptr, *rp);
  684.    }
  685. }
  686.  
  687. /* Write the image.  You only need to call this function once, even
  688.  * if you are writing an interlaced image.
  689.  */
  690. void PNGAPI
  691. png_write_image(png_structp png_ptr, png_bytepp image)
  692. {
  693.    png_uint_32 i; /* row index */
  694.    int pass, num_pass; /* pass variables */
  695.    png_bytepp rp; /* points to current row */
  696.  
  697.    png_debug(1, "in png_write_image\n");
  698. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  699.    /* intialize interlace handling.  If image is not interlaced,
  700.       this will set pass to 1 */
  701.    num_pass = png_set_interlace_handling(png_ptr);
  702. #else
  703.    num_pass = 1;
  704. #endif
  705.    /* loop through passes */
  706.    for (pass = 0; pass < num_pass; pass++)
  707.    {
  708.       /* loop through image */
  709.       for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
  710.       {
  711.          png_write_row(png_ptr, *rp);
  712.       }
  713.    }
  714. }
  715.  
  716. /* called by user to write a row of image data */
  717. void PNGAPI
  718. png_write_row(png_structp png_ptr, png_bytep row)
  719. {
  720.    png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
  721.       png_ptr->row_number, png_ptr->pass);
  722.    /* initialize transformations and other stuff if first time */
  723.    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
  724.    {
  725.    /* make sure we wrote the header info */
  726.    if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
  727.       png_error(png_ptr,
  728.          "png_write_info was never called before png_write_row.");
  729.  
  730.    /* check for transforms that have been set but were defined out */
  731. #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
  732.    if (png_ptr->transformations & PNG_INVERT_MONO)
  733.       png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
  734. #endif
  735. #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
  736.    if (png_ptr->transformations & PNG_FILLER)
  737.       png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
  738. #endif
  739. #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
  740.    if (png_ptr->transformations & PNG_PACKSWAP)
  741.       png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
  742. #endif
  743. #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
  744.    if (png_ptr->transformations & PNG_PACK)
  745.       png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
  746. #endif
  747. #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
  748.    if (png_ptr->transformations & PNG_SHIFT)
  749.       png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
  750. #endif
  751. #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
  752.    if (png_ptr->transformations & PNG_BGR)
  753.       png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
  754. #endif
  755. #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
  756.    if (png_ptr->transformations & PNG_SWAP_BYTES)
  757.       png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
  758. #endif
  759.  
  760.       png_write_start_row(png_ptr);
  761.    }
  762.  
  763. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  764.    /* if interlaced and not interested in row, return */
  765.    if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
  766.    {
  767.       switch (png_ptr->pass)
  768.       {
  769.          case 0:
  770.             if (png_ptr->row_number & 0x07)
  771.             {
  772.                png_write_finish_row(png_ptr);
  773.                return;
  774.             }
  775.             break;
  776.          case 1:
  777.             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
  778.             {
  779.                png_write_finish_row(png_ptr);
  780.                return;
  781.             }
  782.             break;
  783.          case 2:
  784.             if ((png_ptr->row_number & 0x07) != 4)
  785.             {
  786.                png_write_finish_row(png_ptr);
  787.                return;
  788.             }
  789.             break;
  790.          case 3:
  791.             if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)
  792.             {
  793.                png_write_finish_row(png_ptr);
  794.                return;
  795.             }
  796.             break;
  797.          case 4:
  798.             if ((png_ptr->row_number & 0x03) != 2)
  799.             {
  800.                png_write_finish_row(png_ptr);
  801.                return;
  802.             }
  803.             break;
  804.          case 5:
  805.             if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)
  806.             {
  807.                png_write_finish_row(png_ptr);
  808.                return;
  809.             }
  810.             break;
  811.          case 6:
  812.             if (!(png_ptr->row_number & 0x01))
  813.             {
  814.                png_write_finish_row(png_ptr);
  815.                return;
  816.             }
  817.             break;
  818.       }
  819.    }
  820. #endif
  821.  
  822.    /* set up row info for transformations */
  823.    png_ptr->row_info.color_type = png_ptr->color_type;
  824.    png_ptr->row_info.width = png_ptr->usr_width;
  825.    png_ptr->row_info.channels = png_ptr->usr_channels;
  826.    png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
  827.    png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
  828.       png_ptr->row_info.channels);
  829.  
  830.    png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
  831.       (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
  832.  
  833.    png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
  834.    png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);
  835.    png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
  836.    png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
  837.    png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
  838.    png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);
  839.  
  840.    /* Copy user's row into buffer, leaving room for filter byte. */
  841.    png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
  842.       png_ptr->row_info.rowbytes);
  843.  
  844. #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
  845.    /* handle interlacing */
  846.    if (png_ptr->interlaced && png_ptr->pass < 6 &&
  847.       (png_ptr->transformations & PNG_INTERLACE))
  848.    {
  849.       png_do_write_interlace(&(png_ptr->row_info),
  850.          png_ptr->row_buf + 1, png_ptr->pass);
  851.       /* this should always get caught above, but still ... */
  852.       if (!(png_ptr->row_info.width))
  853.       {
  854.          png_write_finish_row(png_ptr);
  855.          return;
  856.       }
  857.    }
  858. #endif
  859.  
  860.    /* handle other transformations */
  861.    if (png_ptr->transformations)
  862.       png_do_write_transformations(png_ptr);
  863.  
  864. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  865.    /* Write filter_method 64 (intrapixel differencing) only if
  866.     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  867.     * 2. Libpng did not write a PNG signature (this filter_method is only
  868.     *    used in PNG datastreams that are embedded in MNG datastreams) and
  869.     * 3. The application called png_permit_mng_features with a mask that
  870.     *    included PNG_FLAG_MNG_FILTER_64 and
  871.     * 4. The filter_method is 64 and
  872.     * 5. The color_type is RGB or RGBA
  873.     */
  874.    if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  875.       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
  876.    {
  877.       /* Intrapixel differencing */
  878.       png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
  879.    }
  880. #endif
  881.  
  882.    /* Find a filter if necessary, filter the row and write it out. */
  883.    png_write_find_filter(png_ptr, &(png_ptr->row_info));
  884.  
  885.    if (png_ptr->write_row_fn != NULL)
  886.       (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
  887. }
  888.  
  889. #if defined(PNG_WRITE_FLUSH_SUPPORTED)
  890. /* Set the automatic flush interval or 0 to turn flushing off */
  891. void PNGAPI
  892. png_set_flush(png_structp png_ptr, int nrows)
  893. {
  894.    png_debug(1, "in png_set_flush\n");
  895.    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
  896. }
  897.  
  898. /* flush the current output buffers now */
  899. void PNGAPI
  900. png_write_flush(png_structp png_ptr)
  901. {
  902.    int wrote_IDAT;
  903.  
  904.    png_debug(1, "in png_write_flush\n");
  905.    /* We have already written out all of the data */
  906.    if (png_ptr->row_number >= png_ptr->num_rows)
  907.      return;
  908.  
  909.    do
  910.    {
  911.       int ret;
  912.  
  913.       /* compress the data */
  914.       ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
  915.       wrote_IDAT = 0;
  916.  
  917.       /* check for compression errors */
  918.       if (ret != Z_OK)
  919.       {
  920.          if (png_ptr->zstream.msg != NULL)
  921.             png_error(png_ptr, png_ptr->zstream.msg);
  922.          else
  923.             png_error(png_ptr, "zlib error");
  924.       }
  925.  
  926.       if (!(png_ptr->zstream.avail_out))
  927.       {
  928.          /* write the IDAT and reset the zlib output buffer */
  929.          png_write_IDAT(png_ptr, png_ptr->zbuf,
  930.                         png_ptr->zbuf_size);
  931.          png_ptr->zstream.next_out = png_ptr->zbuf;
  932.          png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  933.          wrote_IDAT = 1;
  934.       }
  935.    } while(wrote_IDAT == 1);
  936.  
  937.    /* If there is any data left to be output, write it into a new IDAT */
  938.    if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
  939.    {
  940.       /* write the IDAT and reset the zlib output buffer */
  941.       png_write_IDAT(png_ptr, png_ptr->zbuf,
  942.                      png_ptr->zbuf_size - png_ptr->zstream.avail_out);
  943.       png_ptr->zstream.next_out = png_ptr->zbuf;
  944.       png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  945.    }
  946.    png_ptr->flush_rows = 0;
  947.    png_flush(png_ptr);
  948. }
  949. #endif /* PNG_WRITE_FLUSH_SUPPORTED */
  950.  
  951. /* free all memory used by the write */
  952. void PNGAPI
  953. png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
  954. {
  955.    png_structp png_ptr = NULL;
  956.    png_infop info_ptr = NULL;
  957. #ifdef PNG_USER_MEM_SUPPORTED
  958.    png_free_ptr free_fn = NULL;
  959.    png_voidp mem_ptr = NULL;
  960. #endif
  961.  
  962.    png_debug(1, "in png_destroy_write_struct\n");
  963.    if (png_ptr_ptr != NULL)
  964.    {
  965.       png_ptr = *png_ptr_ptr;
  966. #ifdef PNG_USER_MEM_SUPPORTED
  967.       free_fn = png_ptr->free_fn;
  968.       mem_ptr = png_ptr->mem_ptr;
  969. #endif
  970.    }
  971.  
  972.    if (info_ptr_ptr != NULL)
  973.       info_ptr = *info_ptr_ptr;
  974.  
  975.    if (info_ptr != NULL)
  976.    {
  977.       png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  978.  
  979. #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  980.       if (png_ptr->num_chunk_list)
  981.       {
  982.          png_free(png_ptr, png_ptr->chunk_list);
  983.          png_ptr->chunk_list=NULL;
  984.          png_ptr->num_chunk_list=0;
  985.       }
  986. #endif
  987.  
  988. #ifdef PNG_USER_MEM_SUPPORTED
  989.       png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
  990.          (png_voidp)mem_ptr);
  991. #else
  992.       png_destroy_struct((png_voidp)info_ptr);
  993. #endif
  994.       *info_ptr_ptr = NULL;
  995.    }
  996.  
  997.    if (png_ptr != NULL)
  998.    {
  999.       png_write_destroy(png_ptr);
  1000. #ifdef PNG_USER_MEM_SUPPORTED
  1001.       png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
  1002.          (png_voidp)mem_ptr);
  1003. #else
  1004.       png_destroy_struct((png_voidp)png_ptr);
  1005. #endif
  1006.       *png_ptr_ptr = NULL;
  1007.    }
  1008. }
  1009.  
  1010.  
  1011. /* Free any memory used in png_ptr struct (old method) */
  1012. void /* PRIVATE */
  1013. png_write_destroy(png_structp png_ptr)
  1014. {
  1015. #ifdef PNG_SETJMP_SUPPORTED
  1016.    jmp_buf tmp_jmp; /* save jump buffer */
  1017. #endif
  1018.    png_error_ptr error_fn;
  1019.    png_error_ptr warning_fn;
  1020.    png_voidp error_ptr;
  1021. #ifdef PNG_USER_MEM_SUPPORTED
  1022.    png_free_ptr free_fn;
  1023. #endif
  1024.  
  1025.    png_debug(1, "in png_write_destroy\n");
  1026.    /* free any memory zlib uses */
  1027.    deflateEnd(&png_ptr->zstream);
  1028.  
  1029.    /* free our memory.  png_free checks NULL for us. */
  1030.    png_free(png_ptr, png_ptr->zbuf);
  1031.    png_free(png_ptr, png_ptr->row_buf);
  1032.    png_free(png_ptr, png_ptr->prev_row);
  1033.    png_free(png_ptr, png_ptr->sub_row);
  1034.    png_free(png_ptr, png_ptr->up_row);
  1035.    png_free(png_ptr, png_ptr->avg_row);
  1036.    png_free(png_ptr, png_ptr->paeth_row);
  1037.  
  1038. #if defined(PNG_TIME_RFC1123_SUPPORTED)
  1039.    png_free(png_ptr, png_ptr->time_buffer);
  1040. #endif
  1041.  
  1042. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
  1043.    png_free(png_ptr, png_ptr->prev_filters);
  1044.    png_free(png_ptr, png_ptr->filter_weights);
  1045.    png_free(png_ptr, png_ptr->inv_filter_weights);
  1046.    png_free(png_ptr, png_ptr->filter_costs);
  1047.    png_free(png_ptr, png_ptr->inv_filter_costs);
  1048. #endif
  1049.  
  1050. #ifdef PNG_SETJMP_SUPPORTED
  1051.    /* reset structure */
  1052.    png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
  1053. #endif
  1054.  
  1055.    error_fn = png_ptr->error_fn;
  1056.    warning_fn = png_ptr->warning_fn;
  1057.    error_ptr = png_ptr->error_ptr;
  1058. #ifdef PNG_USER_MEM_SUPPORTED
  1059.    free_fn = png_ptr->free_fn;
  1060. #endif
  1061.  
  1062.    png_memset(png_ptr, 0, sizeof (png_struct));
  1063.  
  1064.    png_ptr->error_fn = error_fn;
  1065.    png_ptr->warning_fn = warning_fn;
  1066.    png_ptr->error_ptr = error_ptr;
  1067. #ifdef PNG_USER_MEM_SUPPORTED
  1068.    png_ptr->free_fn = free_fn;
  1069. #endif
  1070.  
  1071. #ifdef PNG_SETJMP_SUPPORTED
  1072.    png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
  1073. #endif
  1074. }
  1075.  
  1076. /* Allow the application to select one or more row filters to use. */
  1077. void PNGAPI
  1078. png_set_filter(png_structp png_ptr, int method, int filters)
  1079. {
  1080.    png_debug(1, "in png_set_filter\n");
  1081. #if defined(PNG_MNG_FEATURES_SUPPORTED)
  1082.    if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
  1083.       (method == PNG_INTRAPIXEL_DIFFERENCING))
  1084.          method = PNG_FILTER_TYPE_BASE;
  1085. #endif
  1086.    if (method == PNG_FILTER_TYPE_BASE)
  1087.    {
  1088.       switch (filters & (PNG_ALL_FILTERS | 0x07))
  1089.       {
  1090.          case 5:
  1091.          case 6:
  1092.          case 7: png_warning(png_ptr, "Unknown row filter for method 0");
  1093.          case PNG_FILTER_VALUE_NONE:  png_ptr->do_filter=PNG_FILTER_NONE; break;
  1094.          case PNG_FILTER_VALUE_SUB:   png_ptr->do_filter=PNG_FILTER_SUB;  break;
  1095.          case PNG_FILTER_VALUE_UP:    png_ptr->do_filter=PNG_FILTER_UP;   break;
  1096.          case PNG_FILTER_VALUE_AVG:   png_ptr->do_filter=PNG_FILTER_AVG;  break;
  1097.          case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break;
  1098.          default: png_ptr->do_filter = (png_byte)filters; break;
  1099.       }
  1100.  
  1101.       /* If we have allocated the row_buf, this means we have already started
  1102.        * with the image and we should have allocated all of the filter buffers
  1103.        * that have been selected.  If prev_row isn't already allocated, then
  1104.        * it is too late to start using the filters that need it, since we
  1105.        * will be missing the data in the previous row.  If an application
  1106.        * wants to start and stop using particular filters during compression,
  1107.        * it should start out with all of the filters, and then add and
  1108.        * remove them after the start of compression.
  1109.        */
  1110.       if (png_ptr->row_buf != NULL)
  1111.       {
  1112.          if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
  1113.          {
  1114.             png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
  1115.               (png_ptr->rowbytes + 1));
  1116.             png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
  1117.          }
  1118.  
  1119.          if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
  1120.          {
  1121.             if (png_ptr->prev_row == NULL)
  1122.             {
  1123.                png_warning(png_ptr, "Can't add Up filter after starting");
  1124.                png_ptr->do_filter &= ~PNG_FILTER_UP;
  1125.             }
  1126.             else
  1127.             {
  1128.                png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
  1129.                   (png_ptr->rowbytes + 1));
  1130.                png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
  1131.             }
  1132.          }
  1133.  
  1134.          if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
  1135.          {
  1136.             if (png_ptr->prev_row == NULL)
  1137.             {
  1138.                png_warning(png_ptr, "Can't add Average filter after starting");
  1139.                png_ptr->do_filter &= ~PNG_FILTER_AVG;
  1140.             }
  1141.             else
  1142.             {
  1143.                png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
  1144.                   (png_ptr->rowbytes + 1));
  1145.                png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
  1146.             }
  1147.          }
  1148.  
  1149.          if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
  1150.              png_ptr->paeth_row == NULL)
  1151.          {
  1152.             if (png_ptr->prev_row == NULL)
  1153.             {
  1154.                png_warning(png_ptr, "Can't add Paeth filter after starting");
  1155.                png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
  1156.             }
  1157.             else
  1158.             {
  1159.                png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
  1160.                   (png_ptr->rowbytes + 1));
  1161.                png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
  1162.             }
  1163.          }
  1164.  
  1165.          if (png_ptr->do_filter == PNG_NO_FILTERS)
  1166.             png_ptr->do_filter = PNG_FILTER_NONE;
  1167.       }
  1168.    }
  1169.    else
  1170.       png_error(png_ptr, "Unknown custom filter method");
  1171. }
  1172.  
  1173. /* This allows us to influence the way in which libpng chooses the "best"
  1174.  * filter for the current scanline.  While the "minimum-sum-of-absolute-
  1175.  * differences metric is relatively fast and effective, there is some
  1176.  * question as to whether it can be improved upon by trying to keep the
  1177.  * filtered data going to zlib more consistent, hopefully resulting in
  1178.  * better compression.
  1179.  */
  1180. #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)      /* GRR 970116 */
  1181. void PNGAPI
  1182. png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
  1183.    int num_weights, png_doublep filter_weights,
  1184.    png_doublep filter_costs)
  1185. {
  1186.    int i;
  1187.  
  1188.    png_debug(1, "in png_set_filter_heuristics\n");
  1189.    if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)
  1190.    {
  1191.       png_warning(png_ptr, "Unknown filter heuristic method");
  1192.       return;
  1193.    }
  1194.  
  1195.    if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)
  1196.    {
  1197.       heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;
  1198.    }
  1199.  
  1200.    if (num_weights < 0 || filter_weights == NULL ||
  1201.       heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)
  1202.    {
  1203.       num_weights = 0;
  1204.    }
  1205.  
  1206.    png_ptr->num_prev_filters = (png_byte)num_weights;
  1207.    png_ptr->heuristic_method = (png_byte)heuristic_method;
  1208.  
  1209.    if (num_weights > 0)
  1210.    {
  1211.       if (png_ptr->prev_filters == NULL)
  1212.       {
  1213.          png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
  1214.             (png_uint_32)(sizeof(png_byte) * num_weights));
  1215.  
  1216.          /* To make sure that the weighting starts out fairly */
  1217.          for (i = 0; i < num_weights; i++)
  1218.          {
  1219.             png_ptr->prev_filters[i] = 255;
  1220.          }
  1221.       }
  1222.  
  1223.       if (png_ptr->filter_weights == NULL)
  1224.       {
  1225.          png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
  1226.             (png_uint_32)(sizeof(png_uint_16) * num_weights));
  1227.  
  1228.          png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
  1229.             (png_uint_32)(sizeof(png_uint_16) * num_weights));
  1230.          for (i = 0; i < num_weights; i++)
  1231.          {
  1232.             png_ptr->inv_filter_weights[i] =
  1233.             png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
  1234.          }
  1235.       }
  1236.  
  1237.       for (i = 0; i < num_weights; i++)
  1238.       {
  1239.          if (filter_weights[i] < 0.0)
  1240.          {
  1241.             png_ptr->inv_filter_weights[i] =
  1242.             png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
  1243.          }
  1244.          else
  1245.          {
  1246.             png_ptr->inv_filter_weights[i] =
  1247.                (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);
  1248.             png_ptr->filter_weights[i] =
  1249.                (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);
  1250.          }
  1251.       }
  1252.    }
  1253.  
  1254.    /* If, in the future, there are other filter methods, this would
  1255.     * need to be based on png_ptr->filter.
  1256.     */
  1257.    if (png_ptr->filter_costs == NULL)
  1258.    {
  1259.       png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
  1260.          (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
  1261.  
  1262.       png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
  1263.          (png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
  1264.  
  1265.       for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
  1266.       {
  1267.          png_ptr->inv_filter_costs[i] =
  1268.          png_ptr->filter_costs[i] = PNG_COST_FACTOR;
  1269.       }
  1270.    }
  1271.  
  1272.    /* Here is where we set the relative costs of the different filters.  We
  1273.     * should take the desired compression level into account when setting
  1274.     * the costs, so that Paeth, for instance, has a high relative cost at low
  1275.     * compression levels, while it has a lower relative cost at higher
  1276.     * compression settings.  The filter types are in order of increasing
  1277.     * relative cost, so it would be possible to do this with an algorithm.
  1278.     */
  1279.    for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
  1280.    {
  1281.       if (filter_costs == NULL || filter_costs[i] < 0.0)
  1282.       {
  1283.          png_ptr->inv_filter_costs[i] =
  1284.          png_ptr->filter_costs[i] = PNG_COST_FACTOR;
  1285.       }
  1286.       else if (filter_costs[i] >= 1.0)
  1287.       {
  1288.          png_ptr->inv_filter_costs[i] =
  1289.             (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);
  1290.          png_ptr->filter_costs[i] =
  1291.             (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);
  1292.       }
  1293.    }
  1294. }
  1295. #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
  1296.  
  1297. void PNGAPI
  1298. png_set_compression_level(png_structp png_ptr, int level)
  1299. {
  1300.    png_debug(1, "in png_set_compression_level\n");
  1301.    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
  1302.    png_ptr->zlib_level = level;
  1303. }
  1304.  
  1305. void PNGAPI
  1306. png_set_compression_mem_level(png_structp png_ptr, int mem_level)
  1307. {
  1308.    png_debug(1, "in png_set_compression_mem_level\n");
  1309.    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
  1310.    png_ptr->zlib_mem_level = mem_level;
  1311. }
  1312.  
  1313. void PNGAPI
  1314. png_set_compression_strategy(png_structp png_ptr, int strategy)
  1315. {
  1316.    png_debug(1, "in png_set_compression_strategy\n");
  1317.    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
  1318.    png_ptr->zlib_strategy = strategy;
  1319. }
  1320.  
  1321. void PNGAPI
  1322. png_set_compression_window_bits(png_structp png_ptr, int window_bits)
  1323. {
  1324.    if (window_bits > 15)
  1325.       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
  1326.    else if (window_bits < 8)
  1327.       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
  1328. #ifndef WBITS_8_OK
  1329.    /* avoid libpng bug with 256-byte windows */
  1330.    if (window_bits == 8)
  1331.      {
  1332.        png_warning(png_ptr, "Compression window is being reset to 512");
  1333.        window_bits=9;
  1334.      }
  1335. #endif
  1336.    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
  1337.    png_ptr->zlib_window_bits = window_bits;
  1338. }
  1339.  
  1340. void PNGAPI
  1341. png_set_compression_method(png_structp png_ptr, int method)
  1342. {
  1343.    png_debug(1, "in png_set_compression_method\n");
  1344.    if (method != 8)
  1345.       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
  1346.    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;
  1347.    png_ptr->zlib_method = method;
  1348. }
  1349.  
  1350. void PNGAPI
  1351. png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
  1352. {
  1353.    png_ptr->write_row_fn = write_row_fn;
  1354. }
  1355.  
  1356. #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
  1357. void PNGAPI
  1358. png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
  1359.    write_user_transform_fn)
  1360. {
  1361.    png_debug(1, "in png_set_write_user_transform_fn\n");
  1362.    png_ptr->transformations |= PNG_USER_TRANSFORM;
  1363.    png_ptr->write_user_transform_fn = write_user_transform_fn;
  1364. }
  1365. #endif
  1366.  
  1367.  
  1368. #if defined(PNG_INFO_IMAGE_SUPPORTED)
  1369. void PNGAPI
  1370. png_write_png(png_structp png_ptr, png_infop info_ptr,
  1371.               int transforms, voidp params)
  1372. {
  1373. #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  1374.    /* invert the alpha channel from opacity to transparency */
  1375.    if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
  1376.        png_set_invert_alpha(png_ptr);
  1377. #endif
  1378.  
  1379.    /* Write the file header information. */
  1380.    png_write_info(png_ptr, info_ptr);
  1381.  
  1382.    /* ------ these transformations don't touch the info structure ------- */
  1383.  
  1384. #if defined(PNG_WRITE_INVERT_SUPPORTED)
  1385.    /* invert monochrome pixels */
  1386.    if (transforms & PNG_TRANSFORM_INVERT_MONO)
  1387.        png_set_invert_mono(png_ptr);
  1388. #endif
  1389.  
  1390. #if defined(PNG_WRITE_SHIFT_SUPPORTED)
  1391.    /* Shift the pixels up to a legal bit depth and fill in
  1392.     * as appropriate to correctly scale the image.
  1393.     */
  1394.    if ((transforms & PNG_TRANSFORM_SHIFT)
  1395.                && (info_ptr->valid & PNG_INFO_sBIT))
  1396.        png_set_shift(png_ptr, &info_ptr->sig_bit);
  1397. #endif
  1398.  
  1399. #if defined(PNG_WRITE_PACK_SUPPORTED)
  1400.    /* pack pixels into bytes */
  1401.    if (transforms & PNG_TRANSFORM_PACKING)
  1402.        png_set_packing(png_ptr);
  1403. #endif
  1404.  
  1405. #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  1406.    /* swap location of alpha bytes from ARGB to RGBA */
  1407.    if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
  1408.        png_set_swap_alpha(png_ptr);
  1409. #endif
  1410.  
  1411. #if defined(PNG_WRITE_FILLER_SUPPORTED)
  1412.    /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
  1413.     * RGB (4 channels -> 3 channels). The second parameter is not used.
  1414.     */
  1415.    if (transforms & PNG_TRANSFORM_STRIP_FILLER)
  1416.        png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
  1417. #endif
  1418.  
  1419. #if defined(PNG_WRITE_BGR_SUPPORTED)
  1420.    /* flip BGR pixels to RGB */
  1421.    if (transforms & PNG_TRANSFORM_BGR)
  1422.        png_set_bgr(png_ptr);
  1423. #endif
  1424.  
  1425. #if defined(PNG_WRITE_SWAP_SUPPORTED)
  1426.    /* swap bytes of 16-bit files to most significant byte first */
  1427.    if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
  1428.        png_set_swap(png_ptr);
  1429. #endif
  1430.  
  1431. #if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  1432.    /* swap bits of 1, 2, 4 bit packed pixel formats */
  1433.    if (transforms & PNG_TRANSFORM_PACKSWAP)
  1434.        png_set_packswap(png_ptr);
  1435. #endif
  1436.  
  1437.    /* ----------------------- end of transformations ------------------- */
  1438.  
  1439.    /* write the bits */
  1440.    if (info_ptr->valid & PNG_INFO_IDAT)
  1441.        png_write_image(png_ptr, info_ptr->row_pointers);
  1442.  
  1443.    /* It is REQUIRED to call this to finish writing the rest of the file */
  1444.    png_write_end(png_ptr, info_ptr);
  1445.  
  1446.    if(transforms == 0 || params == NULL)
  1447.       /* quiet compiler warnings */ return;
  1448. }
  1449. #endif
  1450. #endif /* PNG_WRITE_SUPPORTED */
  1451.