]> git.jsancho.org Git - lugaru.git/blob - Source/Utils/ImageIO.cpp
Added braces to all statements with clang-tidy and ran clang-format again
[lugaru.git] / Source / Utils / ImageIO.cpp
1 /*
2 Copyright (C) 2003, 2010 - Wolfire Games
3 Copyright (C) 2010-2016 - 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 = 0;
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 }