writepng.c
上传用户:sesekoo
上传日期:2020-07-18
资源大小:21543k
文件大小:13k
源码类别:

界面编程

开发平台:

Visual C++

  1. /*---------------------------------------------------------------------------
  2.    wpng - simple PNG-writing program                             writepng.c
  3.   ---------------------------------------------------------------------------
  4.       Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
  5.       This software is provided "as is," without warranty of any kind,
  6.       express or implied.  In no event shall the author or contributors
  7.       be held liable for any damages arising in any way from the use of
  8.       this software.
  9.       The contents of this file are DUAL-LICENSED.  You may modify and/or
  10.       redistribute this software according to the terms of one of the
  11.       following two licenses (at your option):
  12.       LICENSE 1 ("BSD-like with advertising clause"):
  13.       Permission is granted to anyone to use this software for any purpose,
  14.       including commercial applications, and to alter it and redistribute
  15.       it freely, subject to the following restrictions:
  16.       1. Redistributions of source code must retain the above copyright
  17.          notice, disclaimer, and this list of conditions.
  18.       2. Redistributions in binary form must reproduce the above copyright
  19.          notice, disclaimer, and this list of conditions in the documenta-
  20.          tion and/or other materials provided with the distribution.
  21.       3. All advertising materials mentioning features or use of this
  22.          software must display the following acknowledgment:
  23.             This product includes software developed by Greg Roelofs
  24.             and contributors for the book, "PNG: The Definitive Guide,"
  25.             published by O'Reilly and Associates.
  26.       LICENSE 2 (GNU GPL v2 or later):
  27.       This program is free software; you can redistribute it and/or modify
  28.       it under the terms of the GNU General Public License as published by
  29.       the Free Software Foundation; either version 2 of the License, or
  30.       (at your option) any later version.
  31.       This program is distributed in the hope that it will be useful,
  32.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  33.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34.       GNU General Public License for more details.
  35.       You should have received a copy of the GNU General Public License
  36.       along with this program; if not, write to the Free Software Foundation,
  37.       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  38.   ---------------------------------------------------------------------------*/
  39. #include <stdlib.h>     /* for exit() prototype */
  40. #include "png.h"        /* libpng header; includes zlib.h and setjmp.h */
  41. #include "writepng.h"   /* typedefs, common macros, public prototypes */
  42. /* local prototype */
  43. static void writepng_error_handler(png_structp png_ptr, png_const_charp msg);
  44. void writepng_version_info(void)
  45. {
  46.   fprintf(stderr, "   Compiled with libpng %s; using libpng %s.n",
  47.     PNG_LIBPNG_VER_STRING, png_libpng_ver);
  48.   fprintf(stderr, "   Compiled with zlib %s; using zlib %s.n",
  49.     ZLIB_VERSION, zlib_version);
  50. }
  51. /* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for
  52.  *  unexpected pnmtype; note that outfile might be stdout */
  53. int writepng_init(mainprog_info *mainprog_ptr)
  54. {
  55.     png_structp  png_ptr;       /* note:  temporary variables! */
  56.     png_infop  info_ptr;
  57.     int color_type, interlace_type;
  58.     /* could also replace libpng warning-handler (final NULL), but no need: */
  59.     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
  60.       writepng_error_handler, NULL);
  61.     if (!png_ptr)
  62.         return 4;   /* out of memory */
  63.     info_ptr = png_create_info_struct(png_ptr);
  64.     if (!info_ptr) {
  65.         png_destroy_write_struct(&png_ptr, NULL);
  66.         return 4;   /* out of memory */
  67.     }
  68.     /* setjmp() must be called in every function that calls a PNG-writing
  69.      * libpng function, unless an alternate error handler was installed--
  70.      * but compatible error handlers must either use longjmp() themselves
  71.      * (as in this program) or exit immediately, so here we go: */
  72.     if (setjmp(mainprog_ptr->jmpbuf)) {
  73.         png_destroy_write_struct(&png_ptr, &info_ptr);
  74.         return 2;
  75.     }
  76.     /* make sure outfile is (re)opened in BINARY mode */
  77.     png_init_io(png_ptr, mainprog_ptr->outfile);
  78.     /* set the compression levels--in general, always want to leave filtering
  79.      * turned on (except for palette images) and allow all of the filters,
  80.      * which is the default; want 32K zlib window, unless entire image buffer
  81.      * is 16K or smaller (unknown here)--also the default; usually want max
  82.      * compression (NOT the default); and remaining compression flags should
  83.      * be left alone */
  84.     png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
  85. /*
  86.     >> this is default for no filtering; Z_FILTERED is default otherwise:
  87.     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
  88.     >> these are all defaults:
  89.     png_set_compression_mem_level(png_ptr, 8);
  90.     png_set_compression_window_bits(png_ptr, 15);
  91.     png_set_compression_method(png_ptr, 8);
  92.  */
  93.     /* set the image parameters appropriately */
  94.     if (mainprog_ptr->pnmtype == 5)
  95.         color_type = PNG_COLOR_TYPE_GRAY;
  96.     else if (mainprog_ptr->pnmtype == 6)
  97.         color_type = PNG_COLOR_TYPE_RGB;
  98.     else if (mainprog_ptr->pnmtype == 8)
  99.         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
  100.     else {
  101.         png_destroy_write_struct(&png_ptr, &info_ptr);
  102.         return 11;
  103.     }
  104.     interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :
  105.                                                PNG_INTERLACE_NONE;
  106.     png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
  107.       mainprog_ptr->sample_depth, color_type, interlace_type,
  108.       PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
  109.     if (mainprog_ptr->gamma > 0.0)
  110.         png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
  111.     if (mainprog_ptr->have_bg) {   /* we know it's RGBA, not gray+alpha */
  112.         png_color_16  background;
  113.         background.red = mainprog_ptr->bg_red;
  114.         background.green = mainprog_ptr->bg_green;
  115.         background.blue = mainprog_ptr->bg_blue;
  116.         png_set_bKGD(png_ptr, info_ptr, &background);
  117.     }
  118.     if (mainprog_ptr->have_time) {
  119.         png_time  modtime;
  120.         png_convert_from_time_t(&modtime, mainprog_ptr->modtime);
  121.         png_set_tIME(png_ptr, info_ptr, &modtime);
  122.     }
  123.     if (mainprog_ptr->have_text) {
  124.         png_text  text[6];
  125.         int  num_text = 0;
  126.         if (mainprog_ptr->have_text & TEXT_TITLE) {
  127.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  128.             text[num_text].key = "Title";
  129.             text[num_text].text = mainprog_ptr->title;
  130.             ++num_text;
  131.         }
  132.         if (mainprog_ptr->have_text & TEXT_AUTHOR) {
  133.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  134.             text[num_text].key = "Author";
  135.             text[num_text].text = mainprog_ptr->author;
  136.             ++num_text;
  137.         }
  138.         if (mainprog_ptr->have_text & TEXT_DESC) {
  139.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  140.             text[num_text].key = "Description";
  141.             text[num_text].text = mainprog_ptr->desc;
  142.             ++num_text;
  143.         }
  144.         if (mainprog_ptr->have_text & TEXT_COPY) {
  145.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  146.             text[num_text].key = "Copyright";
  147.             text[num_text].text = mainprog_ptr->copyright;
  148.             ++num_text;
  149.         }
  150.         if (mainprog_ptr->have_text & TEXT_EMAIL) {
  151.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  152.             text[num_text].key = "E-mail";
  153.             text[num_text].text = mainprog_ptr->email;
  154.             ++num_text;
  155.         }
  156.         if (mainprog_ptr->have_text & TEXT_URL) {
  157.             text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
  158.             text[num_text].key = "URL";
  159.             text[num_text].text = mainprog_ptr->url;
  160.             ++num_text;
  161.         }
  162.         png_set_text(png_ptr, info_ptr, text, num_text);
  163.     }
  164.     /* write all chunks up to (but not including) first IDAT */
  165.     png_write_info(png_ptr, info_ptr);
  166.     /* if we wanted to write any more text info *after* the image data, we
  167.      * would set up text struct(s) here and call png_set_text() again, with
  168.      * just the new data; png_set_tIME() could also go here, but it would
  169.      * have no effect since we already called it above (only one tIME chunk
  170.      * allowed) */
  171.     /* set up the transformations:  for now, just pack low-bit-depth pixels
  172.      * into bytes (one, two or four pixels per byte) */
  173.     png_set_packing(png_ptr);
  174. /*  png_set_shift(png_ptr, &sig_bit);  to scale low-bit-depth values */
  175.     /* make sure we save our pointers for use in writepng_encode_image() */
  176.     mainprog_ptr->png_ptr = png_ptr;
  177.     mainprog_ptr->info_ptr = info_ptr;
  178.     /* OK, that's all we need to do for now; return happy */
  179.     return 0;
  180. }
  181. /* returns 0 for success, 2 for libpng (longjmp) problem */
  182. int writepng_encode_image(mainprog_info *mainprog_ptr)
  183. {
  184.     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
  185.     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
  186.     /* as always, setjmp() must be called in every function that calls a
  187.      * PNG-writing libpng function */
  188.     if (setjmp(mainprog_ptr->jmpbuf)) {
  189.         png_destroy_write_struct(&png_ptr, &info_ptr);
  190.         mainprog_ptr->png_ptr = NULL;
  191.         mainprog_ptr->info_ptr = NULL;
  192.         return 2;
  193.     }
  194.     /* and now we just write the whole image; libpng takes care of interlacing
  195.      * for us */
  196.     png_write_image(png_ptr, mainprog_ptr->row_pointers);
  197.     /* since that's it, we also close out the end of the PNG file now--if we
  198.      * had any text or time info to write after the IDATs, second argument
  199.      * would be info_ptr, but we optimize slightly by sending NULL pointer: */
  200.     png_write_end(png_ptr, NULL);
  201.     return 0;
  202. }
  203. /* returns 0 if succeeds, 2 if libpng problem */
  204. int writepng_encode_row(mainprog_info *mainprog_ptr)  /* NON-interlaced only! */
  205. {
  206.     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
  207.     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
  208.     /* as always, setjmp() must be called in every function that calls a
  209.      * PNG-writing libpng function */
  210.     if (setjmp(mainprog_ptr->jmpbuf)) {
  211.         png_destroy_write_struct(&png_ptr, &info_ptr);
  212.         mainprog_ptr->png_ptr = NULL;
  213.         mainprog_ptr->info_ptr = NULL;
  214.         return 2;
  215.     }
  216.     /* image_data points at our one row of image data */
  217.     png_write_row(png_ptr, mainprog_ptr->image_data);
  218.     return 0;
  219. }
  220. /* returns 0 if succeeds, 2 if libpng problem */
  221. int writepng_encode_finish(mainprog_info *mainprog_ptr)   /* NON-interlaced! */
  222. {
  223.     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
  224.     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
  225.     /* as always, setjmp() must be called in every function that calls a
  226.      * PNG-writing libpng function */
  227.     if (setjmp(mainprog_ptr->jmpbuf)) {
  228.         png_destroy_write_struct(&png_ptr, &info_ptr);
  229.         mainprog_ptr->png_ptr = NULL;
  230.         mainprog_ptr->info_ptr = NULL;
  231.         return 2;
  232.     }
  233.     /* close out PNG file; if we had any text or time info to write after
  234.      * the IDATs, second argument would be info_ptr: */
  235.     png_write_end(png_ptr, NULL);
  236.     return 0;
  237. }
  238. void writepng_cleanup(mainprog_info *mainprog_ptr)
  239. {
  240.     png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
  241.     png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
  242.     if (png_ptr && info_ptr)
  243.         png_destroy_write_struct(&png_ptr, &info_ptr);
  244. }
  245. static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)
  246. {
  247.     mainprog_info  *mainprog_ptr;
  248.     /* This function, aside from the extra step of retrieving the "error
  249.      * pointer" (below) and the fact that it exists within the application
  250.      * rather than within libpng, is essentially identical to libpng's
  251.      * default error handler.  The second point is critical:  since both
  252.      * setjmp() and longjmp() are called from the same code, they are
  253.      * guaranteed to have compatible notions of how big a jmp_buf is,
  254.      * regardless of whether _BSD_SOURCE or anything else has (or has not)
  255.      * been defined. */
  256.     fprintf(stderr, "writepng libpng error: %sn", msg);
  257.     fflush(stderr);
  258.     mainprog_ptr = png_get_error_ptr(png_ptr);
  259.     if (mainprog_ptr == NULL) {         /* we are completely hosed now */
  260.         fprintf(stderr,
  261.           "writepng severe error:  jmpbuf not recoverable; terminating.n");
  262.         fflush(stderr);
  263.         exit(99);
  264.     }
  265.     longjmp(mainprog_ptr->jmpbuf, 1);
  266. }