wrlib/png.c

   1 /* png.c - load PNG image from file
   2  *
   3  * Raster graphics library
   4  *
   5  * Copyright (c) 1997-2003 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24 /* AIX requires this to be the first thing in the file.  */
  25 #ifdef __GNUC__
  26 # define alloca __builtin_alloca
  27 #else
  28 # if HAVE_ALLOCA_H
  29 #  include <alloca.h>
  30 # else
  31 #  ifdef _AIX
  32 #   pragma alloca
  33 #  else
  34 #   ifndef alloca /* predefined by HP cc +Olibcalls */
  35 char *alloca ();
  36 #   endif
  37 #  endif
  38 # endif
  39 #endif
  40
  41
  42 #ifdef USE_PNG
  43
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47
  48 #include <png.h>
  49
  50 #include "wraster.h"
  51
  52
  53 RImage*
  54 RLoadPNG(RContext *context, char *file, int index)
  55 {
  56     char *tmp;
  57     RImage *image=NULL;
  58     FILE *f;
  59     png_structp png;
  60     png_infop pinfo, einfo;
  61     png_color_16p bkcolor;
  62     int alpha;
  63     int x, y, i;
  64     double gamma, sgamma;
  65     png_uint_32 width, height;
  66     int depth, junk, color_type;
  67     png_bytep *png_rows;
  68     unsigned char *ptr;
  69
  70     f = fopen(file, "rb");
  71     if (!f) {
  72         RErrorCode = RERR_OPEN;
  73         return NULL;
  74     }
  75     png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
  76                                  (png_error_ptr)NULL, (png_error_ptr)NULL);
  77     if (!png) {
  78         RErrorCode = RERR_NOMEMORY;
  79         fclose(f);
  80         return NULL;
  81     }
  82
  83     pinfo = png_create_info_struct(png);
  84     if (!pinfo) {
  85         RErrorCode = RERR_NOMEMORY;
  86         fclose(f);
  87         png_destroy_read_struct(&png, NULL, NULL);
  88         return NULL;
  89     }
  90
  91     einfo = png_create_info_struct(png);
  92     if (!einfo) {
  93         RErrorCode = RERR_NOMEMORY;
  94         fclose(f);
  95         png_destroy_read_struct(&png, &pinfo, NULL);
  96         return NULL;
  97     }
  98
  99     RErrorCode = RERR_INTERNAL;
 100     if (setjmp(png->jmpbuf)) {
 101         fclose(f);
 102         png_destroy_read_struct(&png, &pinfo, &einfo);
 103         if (image)
 104           RReleaseImage(image);
 105         return NULL;
 106     }
 107
 108     png_init_io(png, f);
 109
 110     png_read_info(png, pinfo);
 111
 112     png_get_IHDR(png, pinfo, &width, &height, &depth, &color_type,
 113                  &junk, &junk, &junk);
 114
 115
 116     /* sanity check */
 117     if (width < 1 || height < 1) {
 118         fclose(f);
 119         png_destroy_read_struct(&png, &pinfo, &einfo);
 120         RErrorCode = RERR_BADIMAGEFILE;
 121         return NULL;
 122     }
 123
 124
 125     /* check for an alpha channel */
 126     if (png_get_valid(png, pinfo, PNG_INFO_tRNS))
 127       alpha = True;
 128     else
 129       alpha = (color_type & PNG_COLOR_MASK_ALPHA);
 130
 131     /* allocate RImage */
 132     image = RCreateImage(width, height, alpha);
 133     if (!image) {
 134         fclose(f);
 135         png_destroy_read_struct(&png, &pinfo, &einfo);
 136         return NULL;
 137     }
 138
 139     /* normalize to 8bpp with alpha channel */
 140     if (color_type == PNG_COLOR_TYPE_PALETTE && depth <= 8)
 141         png_set_expand(png);
 142
 143     if (color_type == PNG_COLOR_TYPE_GRAY && depth <= 8)
 144         png_set_expand(png);
 145
 146     if (png_get_valid(png, pinfo, PNG_INFO_tRNS))
 147         png_set_expand(png);
 148
 149     if (depth == 16)
 150         png_set_strip_16(png);
 151
 152     if (color_type == PNG_COLOR_TYPE_GRAY ||
 153         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 154           png_set_gray_to_rgb(png);
 155
 156     /* set gamma correction */
 157     if ((context->attribs->flags & RC_GammaCorrection)
 158         && context->depth != 8) {
 159         sgamma = (context->attribs->rgamma + context->attribs->ggamma +
 160                   context->attribs->bgamma) / 3;
 161     } else if ((tmp = getenv("DISPLAY_GAMMA")) != NULL) {
 162         sgamma = atof(tmp);
 163         if (sgamma==0)
 164             sgamma = 1;
 165     } else {
 166         /* blah */
 167         sgamma = 2.2;
 168     }
 169
 170     if (png_get_gAMA(png, pinfo, &gamma))
 171       png_set_gamma(png, sgamma, gamma);
 172     else
 173       png_set_gamma(png, sgamma, 0.45);
 174
 175     /* do the transforms */
 176     png_read_update_info(png, pinfo);
 177
 178     /* set background color */
 179     if (png_get_bKGD(png, pinfo, &bkcolor)) {
 180         image->background.red = bkcolor->red >> 8;
 181         image->background.green = bkcolor->green >> 8;
 182         image->background.blue = bkcolor->blue >> 8;
 183     }
 184
 185     png_rows = alloca(sizeof(char*)*height);
 186     if (!png_rows) {
 187         RErrorCode = RERR_NOMEMORY;
 188         fclose(f);
 189         RReleaseImage(image);
 190         png_destroy_read_struct(&png, &pinfo, &einfo);
 191 #ifdef C_ALLOCA
 192         alloca(0);
 193 #endif
 194         return NULL;
 195     }
 196     for (y=0; y<height; y++) {
 197         png_rows[y] = alloca(png_get_rowbytes(png, pinfo));
 198         if (!png_rows[y]) {
 199             RErrorCode = RERR_NOMEMORY;
 200             fclose(f);
 201             RReleaseImage(image);
 202             png_destroy_read_struct(&png, &pinfo, &einfo);
 203 #ifdef C_ALLOCA
 204             alloca(0);
 205 #endif
 206             return NULL;
 207         }
 208     }
 209     /* read data */
 210     png_read_image(png, png_rows);
 211
 212     png_read_end(png, einfo);
 213
 214     png_destroy_read_struct(&png, &pinfo, &einfo);
 215
 216     fclose(f);
 217
 218     ptr = image->data;
 219
 220     /* convert to RImage */
 221     if (alpha) {
 222         for (y=0; y<height; y++) {
 223             for (x=0, i=width*4; x<i; x++, ptr++) {
 224                 *ptr = *(png_rows[y]+x);
 225             }
 226         }
 227     } else {
 228         for (y=0; y<height; y++) {
 229             for (x=0, i=width*3; x<i; x++, ptr++) {
 230                 *ptr = *(png_rows[y]+x);
 231             }
 232         }
 233     }
 234 #ifdef C_ALLOCA
 235     alloca(0);
 236 #endif
 237     return image;
 238 }
 239
 240 #endif /* USE_PNG */