Added PNG reading/writing

ChangeLog.md

@@ -2,6 +2,9 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140622 ]
+    * Wrote simple image reader/writer utilizing libpng
+
     [ 20140621 ]
     * Created StaticMesh class replacing model_mesh_t stuff
     * Simplified StaticMesh’s data storage

README.md

@@ -30,10 +30,11 @@ Basically, OpenRaider depends on the following:
 
 * OpenGL
 * SDL2
-* SDL2-TTF (if you want to use TTF fonts)
+* SDL2-TTF (optional, needed if you want to use TTF fonts)
 * OpenAL & ALUT
 * zlib
 * cmake as build system
+* libpng (optional)
 
 On Mac OS X 10.9 with [XCode](https://developer.apple.com/xcode/) and [MacPorts](http://www.macports.org) installed, the following should be enough to get all dependencies that are available as port:
 

TODO.md

@@ -10,6 +10,7 @@
     * Rewrite Console and use operator << to write to the console?
 * SDL_TTF 2.0.12+ can do line breaks, use it: http://stackoverflow.com/questions/17847818/how-to-do-line-breaks-and-line-wrapping-with-sdl-ttf/18418688#18418688
 * Mesh has 2 different approaches of storing the same data (eg. mColors and mColorArray), but half of ‘em isn’t implemented. Unify this, probably even reusing the Mesh class for the model_meshes...
+* glTexImage2D has alignment requirements?!?! https://www.khronos.org/opengles/sdk/1.1/docs/man/glTexImage2D.xml
 
 ## Changes
 

include/config.h.in

@@ -12,6 +12,7 @@
 #define BUILD_HOST "@OpenRaider_BUILD_HOST@ @OpenRaider_HOSTNAME@"
 
 #cmakedefine USING_AL
+#cmakedefine USING_PNG
 
 #cmakedefine HAVE_EXECINFO_H
 #cmakedefine HAVE_BACKTRACE

include/utils/png.h

@@ -0,0 +1,32 @@
+/*!
+ * \file include/utils/png.h
+ * \brief PNG image reader
+ *
+ * \author xythobuz
+ */
+
+#ifndef _UTILS_PNG_H_
+#define _UTILS_PNG_H_
+
+/*!
+ * \brief Load a PNG image file into an RGBA buffer
+ * \param filename path of file to read
+ * \param image place where allocated buffer of size (width * height * 4) will be allocated
+ * \param width place where image width will be stored
+ * \param height place where image height will be stored
+ * \returns 0 on success
+ */
+int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height);
+
+/*!
+ * \brief Create a PNG image file from an RGBA buffer
+ * \param filename path of file to create
+ * \param image buffer of size (width * height * 4)
+ * \param width image width
+ * \param height image height
+ * \returns 0 on success
+ */
+int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height);
+
+#endif
+

src/CMakeLists.txt

@@ -36,6 +36,14 @@ if (OPENAL_FOUND)
     endif (ALUT_FOUND)
 endif (OPENAL_FOUND)
 
+# Add PNG Library
+find_package (PNG)
+if (PNG_FOUND)
+    include_directories (SYSTEM ${PNG_INCLUDE_DIRS})
+    set (LIBS ${LIBS} ${PNG_LIBRARIES})
+    add_definitions (${PNG_DEFINITIONS})
+endif (PNG_FOUND)
+
 #################################################################
 
 # Set Source files
@@ -87,6 +95,12 @@ else (SDL2_FOUND)
     message (FATAL_ERROR "SDL2 is required at the moment!")
 endif (SDL2_FOUND)
 
+if (PNG_FOUND)
+    set (USING_PNG TRUE)
+else (PNG_FOUND)
+    set (USING_PNG FALSE)
+endif (PNG_FOUND)
+
 #################################################################
 
 # Check for header/function presence

src/utils/CMakeLists.txt

@@ -4,6 +4,10 @@ set (UTIL_SRCS ${UTIL_SRCS} "strings.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "tga.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "time.cpp")
 
+if (USING_PNG)
+    set (UTIL_SRCS ${UTIL_SRCS} "png.cpp")
+endif (USING_PNG)
+
 # Include directory
 include_directories ("${PROJECT_SOURCE_DIR}/include")
 

src/utils/png.cpp

@@ -0,0 +1,207 @@
+/*!
+ * \file src/utils/png.cpp
+ * \brief PNG image reader
+ *
+ * https://github.com/DavidEGrayson/ahrs-visualizer/blob/master/png_texture.cpp
+ * http://zarb.org/~gc/html/libpng.html
+ *
+ * \author xythobuz
+ */
+
+#include <png.h>
+#include <cstdio>
+
+#include "global.h"
+#include "utils/png.h"
+
+#ifdef DEBUG
+#include "Console.h"
+#define pngPrint getConsole().print
+#else
+void pngPrint(...) { }
+#endif
+
+int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height) {
+    png_byte header[8];
+
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+    assert(image != NULL);
+    assert(width != NULL);
+    assert(height != NULL);
+
+    FILE *fp = fopen(filename, "rb");
+    if (fp == NULL) {
+        pngPrint("Could not open %s", filename);
+        return -1;
+    }
+
+    fread(header, 1, 8, fp);
+
+    if (png_sig_cmp(header, 0, 8)) {
+        pngPrint("File %s is not a PNG.", filename);
+        fclose(fp);
+        return -2;
+    }
+
+    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!png_ptr) {
+        pngPrint("png_create_read_struct returned 0.");
+        fclose(fp);
+        return -3;
+    }
+
+    png_infop info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        pngPrint("png_create_info_struct returned 0.");
+        png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+        fclose(fp);
+        return -4;
+    }
+
+    png_infop end_info = png_create_info_struct(png_ptr);
+    if (!end_info) {
+        pngPrint("png_create_info_struct returned 0.");
+        png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
+        fclose(fp);
+        return -5;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        pngPrint("Error from libpng");
+        png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+        fclose(fp);
+        return -6;
+    }
+
+    png_init_io(png_ptr, fp);
+    png_set_sig_bytes(png_ptr, 8);
+    png_read_info(png_ptr, info_ptr);
+
+    int bit_depth, color_type;
+
+    png_get_IHDR(png_ptr, info_ptr, width, height, &bit_depth, &color_type,
+            NULL, NULL, NULL);
+
+    if (bit_depth != 8) {
+        pngPrint("%s: Unsupported bit depth %d.  Must be 8.", filename, bit_depth);
+        return -7;
+    }
+
+    png_read_update_info(png_ptr, info_ptr);
+
+    int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+
+    png_byte *image_data = new png_byte[(rowbytes * *height) + 15];
+    png_bytep *row_pointers = new png_bytep[*height];
+
+    for (unsigned int i = 0; i < *height; i++)
+        row_pointers[*height - 1 - i] = image_data + i * rowbytes;
+
+    png_read_image(png_ptr, row_pointers);
+
+    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+    delete [] row_pointers;
+    fclose(fp);
+
+    if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
+        *image = image_data;
+    } else {
+        *image = new unsigned char[*width * *height * 4];
+        if (color_type == PNG_COLOR_TYPE_RGB) {
+            for (unsigned int i = 0; i < (*width * *height); i++) {
+                *image[i * 4] = image_data[i * 3];
+                *image[(i * 4) + 1] = image_data[(i * 3) + 1];
+                *image[(i * 4) + 2] = image_data[(i * 3) + 2];
+                *image[(i * 4) + 3] = 255;
+            }
+        } else {
+            pngPrint("%s: Unknown libpng color type %d.", filename, color_type);
+            delete [] image_data;
+            delete [] *image;
+            *image = NULL;
+            return -8;
+        }
+        delete [] image_data;
+    }
+
+    return 0;
+}
+
+int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height) {
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
+
+    FILE *fp = fopen(filename, "wb");
+    if (!fp) {
+        pngPrint("File %s could not be opened for writing", filename);
+        return -1;
+    }
+
+    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+
+    if (!png_ptr) {
+        pngPrint("png_create_write_struct failed");
+        fclose(fp);
+        return -2;
+    }
+
+    png_infop info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        pngPrint("png_create_info_struct failed");
+        fclose(fp);
+        return -3;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        pngPrint("Error during init_io");
+        fclose(fp);
+        return -4;
+    }
+
+    png_init_io(png_ptr, fp);
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        pngPrint("Error during writing header");
+        fclose(fp);
+        return -5;
+    }
+
+    png_set_IHDR(png_ptr, info_ptr, width, height,
+            8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
+            PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+    png_write_info(png_ptr, info_ptr);
+
+    png_bytep *row_pointers = new png_bytep[height];
+
+    for (unsigned int i = 0; i < height; i++)
+        row_pointers[height - 1 - i] = image + (i * width * 4);
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        pngPrint("Error during writing bytes");
+        delete [] row_pointers;
+        fclose(fp);
+        return -6;
+    }
+
+    png_write_image(png_ptr, row_pointers);
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        pngPrint("Error during end of write");
+        delete [] row_pointers;
+        fclose(fp);
+        return -7;
+    }
+
+    png_write_end(png_ptr, NULL);
+
+    delete [] row_pointers;
+    fclose(fp);
+
+    return 0;
+}
+