share/base_image.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <png.h>
  16 #include <jpeglib.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <assert.h>
  20
  21 #include "base_config.h"
  22 #include "base_image.h"
  23
  24 #include "fs.h"
  25 #include "fs_png.h"
  26 #include "fs_jpg.h"
  27
  28 /*---------------------------------------------------------------------------*/
  29
  30 void image_size(int *W, int *H, int w, int h)
  31 {
  32     /* Round the image size up to the next power-of-two. */
  33
  34     *W = w ? 1 : 0;
  35     *H = h ? 1 : 0;
  36
  37     while (*W < w) *W *= 2;
  38     while (*H < h) *H *= 2;
  39 }
  40
  41 void image_near2(int *W, int *H, int w, int h)
  42 {
  43     image_size(W, H, w, h);
  44
  45     if (*W > 1 && (*W - w > w - (*W / 2)))
  46         *W /= 2;
  47     if (*H > 1 && (*H - h > h - (*H / 2)))
  48         *H /= 2;
  49 }
  50
  51 /*---------------------------------------------------------------------------*/
  52
  53 static void *image_load_png(const char *filename, int *width,
  54                                                   int *height,
  55                                                   int *bytes)
  56 {
  57     fs_file fh;
  58
  59     png_structp readp = NULL;
  60     png_infop   infop = NULL;
  61     png_bytep  *bytep = NULL;
  62     unsigned char  *p = NULL;
  63
  64     /* Initialize all PNG import data structures. */
  65
  66     if (!(fh = fs_open(filename, "r")))
  67         return NULL;
  68
  69     if (!(readp = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)))
  70         return NULL;
  71
  72     if (!(infop = png_create_info_struct(readp)))
  73         return NULL;
  74
  75     /* Enable the default PNG error handler. */
  76
  77     if (setjmp(png_jmpbuf(readp)) == 0)
  78     {
  79         int w, h, b, i;
  80
  81         /* Read the PNG header. */
  82
  83         png_set_read_fn(readp, fh, fs_png_read);
  84         png_read_info(readp, infop);
  85
  86         png_set_expand(readp);
  87         png_set_strip_16(readp);
  88         png_set_packing(readp);
  89
  90         png_read_update_info(readp, infop);
  91
  92         /* Extract and check image properties. */
  93
  94         w = (int) png_get_image_width (readp, infop);
  95         h = (int) png_get_image_height(readp, infop);
  96
  97         switch (png_get_color_type(readp, infop))
  98         {
  99         case PNG_COLOR_TYPE_GRAY:       b = 1; break;
 100         case PNG_COLOR_TYPE_GRAY_ALPHA: b = 2; break;
 101         case PNG_COLOR_TYPE_RGB:        b = 3; break;
 102         case PNG_COLOR_TYPE_RGB_ALPHA:  b = 4; break;
 103
 104         default: longjmp(png_jmpbuf(readp), -1);
 105         }
 106
 107         if (!(bytep = png_malloc(readp, h * sizeof (png_bytep))))
 108             longjmp(png_jmpbuf(readp), -1);
 109
 110         /* Allocate the final pixel buffer and read pixels there. */
 111
 112         if ((p = (unsigned char *) malloc(w * h * b)))
 113         {
 114             for (i = 0; i < h; i++)
 115                 bytep[i] = p + w * b * (h - i - 1);
 116
 117             png_read_image(readp, bytep);
 118             png_read_end(readp, NULL);
 119
 120             if (width)  *width  = w;
 121             if (height) *height = h;
 122             if (bytes)  *bytes  = b;
 123         }
 124
 125         png_free(readp, bytep);
 126     }
 127     else p = NULL;
 128
 129     /* Free all resources. */
 130
 131     png_destroy_read_struct(&readp, &infop, NULL);
 132     fs_close(fh);
 133
 134     return p;
 135 }
 136
 137 static void *image_load_jpg(const char *filename, int *width,
 138                                                   int *height,
 139                                                   int *bytes)
 140 {
 141     unsigned char *p = NULL;
 142     fs_file fp;
 143
 144     if ((fp = fs_open(filename, "r")))
 145     {
 146         struct jpeg_decompress_struct cinfo;
 147         struct jpeg_error_mgr         jerr;
 148
 149         int w, h, b, i = 0;
 150
 151         /* Initialize the JPG decompressor. */
 152
 153         cinfo.err = jpeg_std_error(&jerr);
 154         jpeg_create_decompress(&cinfo);
 155
 156         /* Set up a VFS source manager. */
 157
 158         fs_jpg_src(&cinfo, fp);
 159
 160         /* Grab the JPG header info. */
 161
 162         jpeg_read_header(&cinfo, TRUE);
 163         jpeg_start_decompress(&cinfo);
 164
 165         w = cinfo.output_width;
 166         h = cinfo.output_height;
 167         b = cinfo.output_components;
 168
 169         /* Allocate the final pixel buffer and copy pixels there. */
 170
 171         if ((p = (unsigned char *) malloc (w * h * b)))
 172         {
 173             while (cinfo.output_scanline < cinfo.output_height)
 174             {
 175                 unsigned char *buffer = p + w * b * (h - i - 1);
 176                 i += jpeg_read_scanlines(&cinfo, &buffer, 1);
 177             }
 178
 179             if (width)  *width  = w;
 180             if (height) *height = h;
 181             if (bytes)  *bytes  = b;
 182         }
 183
 184         jpeg_finish_decompress(&cinfo);
 185         jpeg_destroy_decompress(&cinfo);
 186
 187         fs_close(fp);
 188     }
 189
 190     return p;
 191 }
 192
 193 void *image_load(const char *filename, int *width,
 194                                        int *height,
 195                                        int *bytes)
 196 {
 197     if (filename)
 198     {
 199         const char *ext = filename + strlen(filename) - 4;
 200
 201         if      (strcmp(ext, ".png") == 0 || strcmp(ext, ".PNG") == 0)
 202             return image_load_png(filename, width, height, bytes);
 203         else if (strcmp(ext, ".jpg") == 0 || strcmp(ext, ".JPG") == 0)
 204             return image_load_jpg(filename, width, height, bytes);
 205     }
 206     return NULL;
 207 }
 208
 209 /*---------------------------------------------------------------------------*/
 210
 211 /*
 212  * Allocate and return a power-of-two image buffer with the given pixel buffer
 213  * centered within in.
 214  */
 215 void *image_next2(const void *p, int w, int h, int b, int *w2, int *h2)
 216 {
 217     unsigned char *src = (unsigned char *) p;
 218     unsigned char *dst = NULL;
 219
 220     int W;
 221     int H;
 222
 223     image_size(&W, &H, w, h);
 224
 225     if ((dst = (unsigned char *) calloc(W * H * b, sizeof (unsigned char))))
 226     {
 227         const int dr = (H - h) / 2;
 228         const int dc = (W - w) / 2;
 229
 230         int r;
 231
 232         for (r = 0; r < h; ++r)
 233         {
 234             const int R = r + dr;
 235             const int C =     dc;
 236
 237             memcpy(&dst[(R * W + C) * b], &src[(r * w) * b], w * b);
 238         }
 239
 240         if (w2) *w2 = W;
 241         if (h2) *h2 = H;
 242     }
 243
 244     return dst;
 245 }
 246
 247 /*
 248  * Allocate and return a new down-sampled image buffer.
 249  */
 250 void *image_scale(const void *p, int w, int h, int b, int *wn, int *hn, int n)
 251 {
 252     unsigned char *src = (unsigned char *) p;
 253     unsigned char *dst = NULL;
 254
 255     int W = w / n;
 256     int H = h / n;
 257
 258     if ((dst = (unsigned char *) calloc(W * H * b, sizeof (unsigned char))))
 259     {
 260         int si, di;
 261         int sj, dj;
 262         int i;
 263
 264         /* Iterate each component of each destination pixel. */
 265
 266         for (di = 0; di < H; di++)
 267             for (dj = 0; dj < W; dj++)
 268                 for (i = 0; i < b; i++)
 269                 {
 270                     int c = 0;
 271
 272                     /* Average the NxN source pixel block for each. */
 273
 274                     for (si = di * n; si < (di + 1) * n; si++)
 275                         for (sj = dj * n; sj < (dj + 1) * n; sj++)
 276                             c += src[(si * w + sj) * b + i];
 277
 278                     dst[(di * W + dj) * b + i] =
 279                         (unsigned char) (c / (n * n));
 280                 }
 281
 282         if (wn) *wn = W;
 283         if (hn) *hn = H;
 284     }
 285
 286     return dst;
 287 }
 288
 289 /*
 290  * Whiten the RGB channels of the given image without touching any alpha.
 291  */
 292 void image_white(void *p, int w, int h, int b)
 293 {
 294     unsigned char *s = (unsigned char *) p;
 295
 296     int i;
 297
 298     assert(b >= 1 && b <= 4);
 299
 300     if (b == 1 || b == 3)
 301     {
 302         memset(s, 0xFF, w * h * b);
 303     }
 304     else if (b == 2)
 305     {
 306         for (i = 0; i < w * h * b; i += 2)
 307             s[i] = 0xFF;
 308     }
 309     else
 310     {
 311         for (i = 0; i < w * h * b; i += 4)
 312         {
 313             s[i + 0] = 0xFF;
 314             s[i + 1] = 0xFF;
 315             s[i + 2] = 0xFF;
 316         }
 317     }
 318 }
 319
 320 /*
 321  * Allocate and return an image buffer of the given image flipped horizontally
 322  * and/or vertically.
 323  */
 324 void *image_flip(const void *p, int w, int h, int b, int hflip, int vflip)
 325 {
 326     unsigned char *q;
 327
 328     assert(hflip || vflip);
 329
 330     if (!p)
 331         return NULL;
 332
 333     if ((q = malloc(w * b * h)))
 334     {
 335         int r, c, i;
 336
 337         for (r = 0; r < h; r++)
 338             for (c = 0; c < w; c++)
 339                 for (i = 0; i < b; i++)
 340                 {
 341                     int pr = vflip ? h - r - 1 : r;
 342                     int pc = hflip ? w - c - 1 : c;
 343
 344                     int qi = r  * w * b + c  * b + i;
 345                     int pi = pr * w * b + pc * b + i;
 346
 347                     q[qi] = ((const unsigned char *) p)[pi];
 348                 }
 349         return q;
 350     }
 351     return NULL;
 352 }
 353
 354 /*---------------------------------------------------------------------------*/