Source/Utils/ImageIO.cpp

   1 /*
   2 Copyright (C) 2003, 2010 - Wolfire Games
   3 Copyright (C) 2010-2017 - Lugaru contributors (see AUTHORS file)
   4
   5 This file is part of Lugaru.
   6
   7 Lugaru is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 Lugaru 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
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "Utils/ImageIO.hpp"
  22
  23 #include "Game.hpp"
  24 #include "Utils/Folders.hpp"
  25
  26 #include <jpeglib.h>
  27 #include <png.h>
  28 #include <stdio.h>
  29 #include <zlib.h>
  30
  31 /* These two are needed for screenshot */
  32 extern int kContextWidth;
  33 extern int kContextHeight;
  34
  35 static bool load_png(const char* fname, ImageRec& tex);
  36 static bool load_jpg(const char* fname, ImageRec& tex);
  37 static bool save_screenshot_png(const char* fname);
  38
  39 ImageRec::ImageRec()
  40 {
  41     data = (GLubyte*)malloc(1024 * 1024 * 4);
  42 }
  43
  44 ImageRec::~ImageRec()
  45 {
  46     free(data);
  47     data = NULL;
  48 }
  49
  50 bool load_image(const char* file_name, ImageRec& tex)
  51 {
  52     Game::LoadingScreen();
  53
  54     if (tex.data == NULL) {
  55         return false;
  56     }
  57
  58     const char* ptr = strrchr((char*)file_name, '.');
  59     if (ptr) {
  60         if (strcasecmp(ptr + 1, "png") == 0) {
  61             return load_png(file_name, tex);
  62         } else if (strcasecmp(ptr + 1, "jpg") == 0) {
  63             return load_jpg(file_name, tex);
  64         }
  65     }
  66
  67     std::cerr << "Unsupported image type" << std::endl;
  68     return false;
  69 }
  70
  71 bool save_screenshot(const char* file_name)
  72 {
  73     const char* ptr = strrchr((char*)file_name, '.');
  74     if (ptr) {
  75         if (strcasecmp(ptr + 1, "png") == 0) {
  76             return save_screenshot_png((Folders::getScreenshotDir() + '/' + file_name).c_str());
  77         }
  78     }
  79
  80     std::cerr << "Unsupported image type" << std::endl;
  81     return false;
  82 }
  83
  84 struct my_error_mgr
  85 {
  86     struct jpeg_error_mgr pub; /* "public" fields */
  87     jmp_buf setjmp_buffer;     /* for return to caller */
  88 };
  89 typedef struct my_error_mgr* my_error_ptr;
  90
  91 static void my_error_exit(j_common_ptr cinfo)
  92 {
  93     struct my_error_mgr* err = (struct my_error_mgr*)cinfo->err;
  94     longjmp(err->setjmp_buffer, 1);
  95 }
  96
  97 /* stolen from public domain example.c code in libjpg distribution. */
  98 static bool load_jpg(const char* file_name, ImageRec& tex)
  99 {
 100     struct jpeg_decompress_struct cinfo;
 101     struct my_error_mgr jerr;
 102     JSAMPROW buffer[1]; /* Output row buffer */
 103     int row_stride;     /* physical row width in output buffer */
 104     errno = 0;
 105     FILE* infile = fopen(file_name, "rb");
 106
 107     if (infile == NULL) {
 108         perror((std::string("Couldn't open file ") + file_name).c_str());
 109         return false;
 110     }
 111
 112     cinfo.err = jpeg_std_error(&jerr.pub);
 113     jerr.pub.error_exit = my_error_exit;
 114     if (setjmp(jerr.setjmp_buffer)) {
 115         jpeg_destroy_decompress(&cinfo);
 116         fclose(infile);
 117         return false;
 118     }
 119
 120     jpeg_create_decompress(&cinfo);
 121     jpeg_stdio_src(&cinfo, infile);
 122     (void)jpeg_read_header(&cinfo, TRUE);
 123
 124     cinfo.out_color_space = JCS_RGB;
 125     cinfo.quantize_colors = FALSE;
 126     (void)jpeg_calc_output_dimensions(&cinfo);
 127     (void)jpeg_start_decompress(&cinfo);
 128
 129     row_stride = cinfo.output_width * cinfo.output_components;
 130     tex.sizeX = cinfo.output_width;
 131     tex.sizeY = cinfo.output_height;
 132     tex.bpp = 24;
 133
 134     while (cinfo.output_scanline < cinfo.output_height) {
 135         buffer[0] = (JSAMPROW)(char*)tex.data +
 136                     ((cinfo.output_height - 1) - cinfo.output_scanline) * row_stride;
 137         (void)jpeg_read_scanlines(&cinfo, buffer, 1);
 138     }
 139
 140     (void)jpeg_finish_decompress(&cinfo);
 141     jpeg_destroy_decompress(&cinfo);
 142     fclose(infile);
 143
 144     return true;
 145 }
 146
 147 /* stolen from public domain example.c code in libpng distribution. */
 148 static bool load_png(const char* file_name, ImageRec& tex)
 149 {
 150     bool hasalpha = false;
 151     png_structp png_ptr = NULL;
 152     png_infop info_ptr = NULL;
 153     png_uint_32 width, height;
 154     int bit_depth, color_type, interlace_type;
 155     bool retval = false;
 156     png_byte** row_pointers = NULL;
 157     errno = 0;
 158     FILE* fp = fopen(file_name, "rb");
 159
 160     if (fp == NULL) {
 161         perror((std::string("Couldn't open file ") + file_name).c_str());
 162         return false;
 163     }
 164
 165     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 166     if (png_ptr == NULL) {
 167         goto png_done;
 168     }
 169
 170     info_ptr = png_create_info_struct(png_ptr);
 171     if (info_ptr == NULL) {
 172         goto png_done;
 173     }
 174
 175     if (setjmp(png_jmpbuf(png_ptr))) {
 176         goto png_done;
 177     }
 178
 179     png_init_io(png_ptr, fp);
 180     png_read_png(png_ptr, info_ptr,
 181                  PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_PACKING,
 182                  NULL);
 183     png_get_IHDR(png_ptr, info_ptr, &width, &height,
 184                  &bit_depth, &color_type, &interlace_type, NULL, NULL);
 185
 186     if (bit_depth != 8) { // transform SHOULD handle this...
 187         goto png_done;
 188     }
 189
 190     if (color_type & PNG_COLOR_MASK_PALETTE) { // !!! FIXME?
 191         goto png_done;
 192     }
 193
 194     if ((color_type & PNG_COLOR_MASK_COLOR) == 0) { // !!! FIXME?
 195         goto png_done;
 196     }
 197
 198     hasalpha = ((color_type & PNG_COLOR_MASK_ALPHA) != 0);
 199     row_pointers = png_get_rows(png_ptr, info_ptr);
 200     if (!row_pointers) {
 201         goto png_done;
 202     }
 203
 204     if (!hasalpha) {
 205         png_byte* dst = tex.data;
 206         for (int i = height - 1; i >= 0; i--) {
 207             png_byte* src = row_pointers[i];
 208             for (unsigned j = 0; j < width; j++) {
 209                 dst[0] = src[0];
 210                 dst[1] = src[1];
 211                 dst[2] = src[2];
 212                 dst[3] = 0xFF;
 213                 src += 3;
 214                 dst += 4;
 215             }
 216         }
 217     }
 218
 219     else {
 220         png_byte* dst = tex.data;
 221         int pitch = width * 4;
 222         for (int i = height - 1; i >= 0; i--, dst += pitch) {
 223             memcpy(dst, row_pointers[i], pitch);
 224         }
 225     }
 226
 227     tex.sizeX = width;
 228     tex.sizeY = height;
 229     tex.bpp = 32;
 230     retval = true;
 231
 232 png_done:
 233     if (!retval) {
 234         cerr << "There was a problem loading " << file_name << endl;
 235     }
 236     png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 237     if (fp) {
 238         fclose(fp);
 239     }
 240     return (retval);
 241 }
 242
 243 static bool save_screenshot_png(const char* file_name)
 244 {
 245     FILE* fp = NULL;
 246     png_structp png_ptr = NULL;
 247     png_infop info_ptr = NULL;
 248     bool retval = false;
 249
 250     errno = 0;
 251     fp = fopen(file_name, "wb");
 252     if (fp == NULL) {
 253         perror((std::string("Couldn't open file ") + file_name).c_str());
 254         return false;
 255     }
 256
 257     png_bytep* row_pointers = new png_bytep[kContextHeight];
 258     png_bytep screenshot = new png_byte[kContextWidth * kContextHeight * 3];
 259     if ((!screenshot) || (!row_pointers)) {
 260         goto save_png_done;
 261     }
 262
 263     glGetError();
 264     glReadPixels(0, 0, kContextWidth, kContextHeight,
 265                  GL_RGB, GL_UNSIGNED_BYTE, screenshot);
 266     if (glGetError() != GL_NO_ERROR) {
 267         goto save_png_done;
 268     }
 269
 270     for (int i = 0; i < kContextHeight; i++) {
 271         row_pointers[i] = screenshot + ((kContextWidth * ((kContextHeight - 1) - i)) * 3);
 272     }
 273
 274     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 275     if (png_ptr == NULL) {
 276         goto save_png_done;
 277     }
 278
 279     info_ptr = png_create_info_struct(png_ptr);
 280     if (info_ptr == NULL) {
 281         goto save_png_done;
 282     }
 283
 284     if (setjmp(png_jmpbuf(png_ptr))) {
 285         goto save_png_done;
 286     }
 287
 288     png_init_io(png_ptr, fp);
 289
 290     if (setjmp(png_jmpbuf(png_ptr))) {
 291         goto save_png_done;
 292     }
 293
 294     png_set_IHDR(png_ptr, info_ptr, kContextWidth, kContextHeight,
 295                  8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
 296                  PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 297
 298     png_write_info(png_ptr, info_ptr);
 299
 300     if (setjmp(png_jmpbuf(png_ptr))) {
 301         goto save_png_done;
 302     }
 303
 304     png_write_image(png_ptr, row_pointers);
 305
 306     if (setjmp(png_jmpbuf(png_ptr))) {
 307         goto save_png_done;
 308     }
 309
 310     png_write_end(png_ptr, NULL);
 311     retval = true;
 312
 313 save_png_done:
 314     png_destroy_write_struct(&png_ptr, &info_ptr);
 315     delete[] screenshot;
 316     delete[] row_pointers;
 317     if (fp) {
 318         fclose(fp);
 319     }
 320     if (!retval) {
 321         unlink(file_name);
 322     }
 323     return retval;
 324 }