remove usage of libpng with custom save_png

src/framework/CMakeLists.txt

@@ -87,7 +87,6 @@ FIND_PACKAGE(OpenAL REQUIRED)
 FIND_PACKAGE(VorbisFile REQUIRED)
 FIND_PACKAGE(Vorbis REQUIRED)
 FIND_PACKAGE(Ogg REQUIRED)
-FIND_PACKAGE(PNG REQUIRED)
 
 IF(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
     MESSAGE(STATUS "Debug information: ON")
@@ -148,7 +147,6 @@ INCLUDE_DIRECTORIES(
     ${PHYSFS_INCLUDE_DIR}
     ${GMP_INCLUDE_DIR}
     ${ZLIB_INCLUDE_DIR}
-    ${PNG_INCLUDE_DIR}
     "${CMAKE_CURRENT_LIST_DIR}/.."
 )
 
@@ -161,7 +159,6 @@ SET(framework_LIBRARIES
     ${VORBISFILE_LIBRARY} ${VORBIS_LIBRARY} ${OGG_LIBRARY}
     ${OPENGL_LIBRARIES}
     ${OPENAL_LIBRARY}
-    ${PNG_LIBRARY}
     ${ADDITIONAL_LIBRARIES}
 )
 

src/framework/cmake/FindPNG.cmake

@@ -3,7 +3,7 @@
 #  PNG_INCLUDE_DIR - the PNG include directory
 #  PNG_LIBRARY - the PNG library
 
-FIND_PATH(PNG_INCLUDE_DIR NAMES png.h)
+FIND_PATH(PNG_INCLUDE_DIR NAMES png.h PATH_SUFFIXES libpng15 libpng)
 FIND_LIBRARY(PNG_LIBRARY NAMES libpng15.a libpng.a png15 png)
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(PNG DEFAULT_MSG PNG_LIBRARY PNG_INCLUDE_DIR)

src/framework/core/resourcemanager.cpp

@@ -181,6 +181,12 @@ bool ResourceManager::deleteFile(const std::string& fileName)
     return PHYSFS_delete(resolvePath(fileName).c_str()) != 0;
 }
 
+
+bool ResourceManager::makeDir(const std::string directory)
+{
+    return PHYSFS_mkdir(directory.c_str());
+}
+
 std::list<std::string> ResourceManager::listDirectoryFiles(const std::string& directoryPath)
 {
     std::list<std::string> files;

src/framework/core/resourcemanager.h

@@ -50,6 +50,7 @@ public:
     FileStreamPtr createFile(const std::string& fileName);
     bool deleteFile(const std::string& fileName);
 
+    bool makeDir(const std::string directory);
     std::list<std::string> listDirectoryFiles(const std::string& directoryPath = "");
 
     std::string resolvePath(const std::string& path);

src/framework/thirdparty/apngloader.cpp

@@ -557,7 +557,7 @@ int load_apng(std::stringstream& file, struct apng_data *apng)
     unsigned char * pImg2;
     unsigned char * pDst1;
     unsigned char * pDst2;
-    unsigned int  * frames_delay;
+    unsigned short* frames_delay;
 
     file.read((char*)sig, 8);
     if(!file.eof() && memcmp(sig, png_sign, 8) == 0) {
@@ -677,7 +677,7 @@ int load_apng(std::stringstream& file, struct apng_data *apng)
                     frames = read32(file);
                     if(frames_delay)
                         free(frames_delay);
-                    frames_delay = (unsigned int*)malloc(frames*sizeof(int));
+                    frames_delay = (unsigned short*)malloc(frames*sizeof(int));
                     loops  = read32(file);
                     crc = read32(file);
                     if (pOut1)
@@ -862,6 +862,279 @@ int load_apng(std::stringstream& file, struct apng_data *apng)
     return 0;
 }
 
+void write_chunk(std::ostream& f, const char* name, unsigned char* data, unsigned int length)
+{
+    unsigned int crc = crc32(0, Z_NULL, 0);
+    unsigned int len = swap32(length);
+
+    f.write((char*)&len, 4);
+    f.write(name, 4);
+    crc = crc32(crc, (const Bytef*)name, 4);
+
+    if(data != NULL && length > 0) {
+        f.write((char*)data, length);
+        crc = crc32(crc, data, length);
+    }
+
+    crc = swap32(crc);
+    f.write((char*)&crc, 4);
+}
+
+void write_IDATs(std::ostream& f, unsigned char* data, unsigned int length, unsigned int idat_size)
+{
+    unsigned int z_cmf = data[0];
+
+    if((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) {
+        if(length >= 2) {
+            unsigned int z_cinfo = z_cmf >> 4;
+            unsigned int half_z_window_size = 1 << (z_cinfo + 7);
+
+            while(idat_size <= half_z_window_size && half_z_window_size >= 256) {
+                z_cinfo--;
+                half_z_window_size >>= 1;
+            }
+
+            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
+
+            if(data[0] != (unsigned char)z_cmf) {
+                data[0] = (unsigned char)z_cmf;
+                data[1] &= 0xe0;
+                data[1] += (unsigned char)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);
+            }
+        }
+    }
+
+    while(length > 0) {
+        unsigned int ds = length;
+
+        if(ds > PNG_ZBUF_SIZE)
+            ds = PNG_ZBUF_SIZE;
+
+        write_chunk(f, "IDAT", data, ds);
+
+        data += ds;
+        length -= ds;
+    }
+}
+
+void save_png(std::stringstream& f, int width, int height, int channels, unsigned char *pixels)
+{
+    unsigned int bpp = 4;
+    unsigned char coltype = 0;
+
+    if(channels == 3)
+        coltype = 2;
+    else if (channels == 2)
+        coltype = 4;
+    else if (channels == 4)
+        coltype = 6;
+
+    struct IHDR {
+        unsigned int    mWidth;
+        unsigned int    mHeight;
+        unsigned char   mDepth;
+        unsigned char   mColorType;
+        unsigned char   mCompression;
+        unsigned char   mFilterMethod;
+        unsigned char   mInterlaceMethod;
+    } ihdr = { swap32(width), swap32(height), 8, coltype, 0, 0, 0 };
+
+    z_stream        zstream1;
+    z_stream        zstream2;
+    unsigned int    i, j;
+
+    unsigned int rowbytes  = width * bpp;
+    unsigned int idat_size = (rowbytes + 1) * height;
+    unsigned int zbuf_size = idat_size + ((idat_size + 7) >> 3) + ((idat_size + 63) >> 6) + 11;
+
+    unsigned char* row_buf   = (unsigned char*)malloc(rowbytes + 1);
+    unsigned char* sub_row   = (unsigned char*)malloc(rowbytes + 1);
+    unsigned char* up_row    = (unsigned char*)malloc(rowbytes + 1);
+    unsigned char* avg_row   = (unsigned char*)malloc(rowbytes + 1);
+    unsigned char* paeth_row = (unsigned char*)malloc(rowbytes + 1);
+    unsigned char* zbuf1     = (unsigned char*)malloc(zbuf_size);
+    unsigned char* zbuf2     = (unsigned char*)malloc(zbuf_size);
+
+    if(!row_buf || !sub_row || !up_row || !avg_row || !paeth_row || !zbuf1 || !zbuf2)
+        return;
+
+    row_buf[0]   = 0;
+    sub_row[0]   = 1;
+    up_row[0]    = 2;
+    avg_row[0]   = 3;
+    paeth_row[0] = 4;
+
+    zstream1.data_type = Z_BINARY;
+    zstream1.zalloc    = Z_NULL;
+    zstream1.zfree     = Z_NULL;
+    zstream1.opaque    = Z_NULL;
+    deflateInit2(&zstream1, Z_BEST_COMPRESSION, 8, 15, 8, Z_DEFAULT_STRATEGY);
+
+    zstream2.data_type = Z_BINARY;
+    zstream2.zalloc    = Z_NULL;
+    zstream2.zfree     = Z_NULL;
+    zstream2.opaque    = Z_NULL;
+    deflateInit2(&zstream2, Z_BEST_COMPRESSION, 8, 15, 8, Z_FILTERED);
+
+    int a, b, c, pa, pb, pc, p, v;
+    unsigned char* prev;
+    unsigned char* row;
+
+    f.write((char*)png_sign, 8);
+    write_chunk(f, "IHDR", (unsigned char*)(&ihdr), 13);
+
+    if(palsize > 0)
+        write_chunk(f, "PLTE", (unsigned char*)(&pal), palsize * 3);
+
+    if(trnssize > 0)
+        write_chunk(f, "tRNS", trns, trnssize);
+
+    zstream1.next_out  = zbuf1;
+    zstream1.avail_out = zbuf_size;
+    zstream2.next_out  = zbuf2;
+    zstream2.avail_out = zbuf_size;
+
+    prev = NULL;
+    row  = pixels;
+
+    for(j = 0; j < (unsigned int)height; j++) {
+        unsigned char* out;
+        unsigned int    sum = 0;
+        unsigned char* best_row = row_buf;
+        unsigned int    mins = ((unsigned int)(-1)) >> 1;
+
+        out = row_buf + 1;
+
+        for(i = 0; i < rowbytes; i++) {
+            v = out[i] = row[i];
+            sum += (v < 128) ? v : 256 - v;
+        }
+
+        mins = sum;
+
+        sum = 0;
+        out = sub_row + 1;
+
+        for(i = 0; i < bpp; i++) {
+            v = out[i] = row[i];
+            sum += (v < 128) ? v : 256 - v;
+        }
+
+        for(i = bpp; i < rowbytes; i++) {
+            v = out[i] = row[i] - row[i - bpp];
+            sum += (v < 128) ? v : 256 - v;
+
+            if(sum > mins) break;
+        }
+
+        if(sum < mins) {
+            mins = sum;
+            best_row = sub_row;
+        }
+
+        if(prev) {
+            sum = 0;
+            out = up_row + 1;
+
+            for(i = 0; i < rowbytes; i++) {
+                v = out[i] = row[i] - prev[i];
+                sum += (v < 128) ? v : 256 - v;
+
+                if(sum > mins) break;
+            }
+
+            if(sum < mins) {
+                mins = sum;
+                best_row = up_row;
+            }
+
+            sum = 0;
+            out = avg_row + 1;
+
+            for(i = 0; i < bpp; i++) {
+                v = out[i] = row[i] - prev[i] / 2;
+                sum += (v < 128) ? v : 256 - v;
+            }
+
+            for(i = bpp; i < rowbytes; i++) {
+                v = out[i] = row[i] - (prev[i] + row[i - bpp]) / 2;
+                sum += (v < 128) ? v : 256 - v;
+
+                if(sum > mins) break;
+            }
+
+            if(sum < mins) {
+                mins = sum;
+                best_row = avg_row;
+            }
+
+            sum = 0;
+            out = paeth_row + 1;
+
+            for(i = 0; i < bpp; i++) {
+                v = out[i] = row[i] - prev[i];
+                sum += (v < 128) ? v : 256 - v;
+            }
+
+            for(i = bpp; i < rowbytes; i++) {
+                a = row[i - bpp];
+                b = prev[i];
+                c = prev[i - bpp];
+                p = b - c;
+                pc = a - c;
+                pa = abs(p);
+                pb = abs(pc);
+                pc = abs(p + pc);
+                p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+                v = out[i] = row[i] - p;
+                sum += (v < 128) ? v : 256 - v;
+
+                if(sum > mins) break;
+            }
+
+            if(sum < mins) {
+                best_row = paeth_row;
+            }
+        }
+
+        zstream1.next_in = row_buf;
+        zstream1.avail_in = rowbytes + 1;
+        deflate(&zstream1, Z_NO_FLUSH);
+
+        zstream2.next_in = best_row;
+        zstream2.avail_in = rowbytes + 1;
+        deflate(&zstream2, Z_NO_FLUSH);
+
+        prev = row;
+        row += rowbytes;
+    }
+
+    deflate(&zstream1, Z_FINISH);
+    deflate(&zstream2, Z_FINISH);
+
+    if(zstream1.total_out <= zstream2.total_out)
+        write_IDATs(f, zbuf1, zstream1.total_out, idat_size);
+    else
+        write_IDATs(f, zbuf2, zstream2.total_out, idat_size);
+
+    deflateReset(&zstream1);
+    zstream1.data_type = Z_BINARY;
+    deflateReset(&zstream2);
+    zstream2.data_type = Z_BINARY;
+
+    write_chunk(f, "IEND", 0, 0);
+
+    deflateEnd(&zstream1);
+    deflateEnd(&zstream2);
+    free(zbuf1);
+    free(zbuf2);
+    free(row_buf);
+    free(sub_row);
+    free(up_row);
+    free(avg_row);
+    free(paeth_row);
+}
+
 void free_apng(struct apng_data *apng)
 {
     if(apng->pdata)

src/framework/thirdparty/apngloader.h

@@ -35,11 +35,12 @@ struct apng_data {
     unsigned char coltype;
     unsigned int num_frames;
     unsigned int num_plays;
-    unsigned int *frames_delay; // each frame delay in ms
+    unsigned short *frames_delay; // each frame delay in ms
 };
 
 // returns -1 on error, 0 on success
 int load_apng(std::stringstream& file, struct apng_data *apng);
+void save_png(std::stringstream& file, int width, int height, int channels, unsigned char *pixels);
 void free_apng(struct apng_data *apng);
 
 #endif

src/otclient/core/spritemanager.cpp

@@ -25,6 +25,7 @@
 #include <framework/core/eventdispatcher.h>
 #include <framework/core/filestream.h>
 #include <framework/graphics/graphics.h>
+#include <framework/thirdparty/apngloader.h>
 #include <physfs.h>
 
 SpriteManager g_sprites;
@@ -166,6 +167,8 @@ TexturePtr& SpriteManager::getSpriteTexture(int id)
 
 bool SpriteManager::exportSprites()
 {
+    g_resources.makeDir("sprites");
+    std::stringstream ss;
 
     for(volatile int i = 1; i <= m_spritesCount; i++) {
         m_spritesFile->seek(((i-1) * 4) + 6);
@@ -225,57 +228,10 @@ bool SpriteManager::exportSprites()
         }
 
         // We should get the OTClient and export to that folder...
-        std::string fileName = Fw::formatString("%s/otclient/sprites/%d.png", PHYSFS_getUserDir(), i);
+        std::string fileName = Fw::formatString("sprites/%d.png", i);
-        FILE *pFile = fopen(fileName.c_str(), "wb");
+        ss.str("");
-
+        save_png(ss, SPRITE_WIDTH, SPRITE_HEIGHT, SPRITE_CHANNELS, pixels);
-        if(!pFile)
+        g_resources.saveFile(fileName, ss);
-            return false;
-
-        png_structp pPng = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-        if(!pPng) {
-            fclose(pFile);
-            return false;
-        }
-
-        png_infop pPngInfo = png_create_info_struct(pPng);
-        if(!pPngInfo) {
-            fclose(pFile);
-            png_destroy_write_struct(&pPng, NULL);
-            return false;
-        }
-
-        if(setjmp(png_jmpbuf(pPng))) {
-            fclose(pFile);
-            png_destroy_write_struct(&pPng, &pPngInfo);
-            return false;
-        }
-
-        png_init_io(pPng, pFile);
-        png_set_compression_level(pPng, PNG_COMPRESSION);
-
-        int bitDepthPerChannel = SPRITE_CHANNELS/4*8;
-        int colorType = PNG_COLOR_TYPE_RGB_ALPHA;
-
-        png_set_IHDR(pPng, pPngInfo, SPRITE_WIDTH, SPRITE_HEIGHT, bitDepthPerChannel, colorType,
-                     PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-
-        png_write_info(pPng, pPngInfo);
-
-        if(bitDepthPerChannel == 16) // Reverse endian order (PNG is Big Endian)
-            png_set_swap(pPng);
-
-        int bytesPerRow = SPRITE_WIDTH*SPRITE_CHANNELS;
-        uint8* pImgData = pixels;
-
-        for(int row=0; row < SPRITE_HEIGHT; row++) {  // Write non-interlaced buffer
-            png_write_row(pPng, pImgData);
-            pImgData += bytesPerRow;
-        }
-
-        png_write_end(pPng, NULL);
-        png_destroy_write_struct(&pPng, &pPngInfo);
-
-        fclose(pFile);
     }
 
     return true;

src/otclient/core/spritemanager.h

@@ -27,22 +27,15 @@
 #include <framework/graphics/texture.h>
 #include <png.h>
 
-#define SPRITE_WIDTH 32
-#define SPRITE_HEIGHT 32
-#define SPRITE_CHANNELS 4
-#define SPRITE_SIZE SPRITE_WIDTH*SPRITE_HEIGHT*SPRITE_CHANNELS
-
-/*
-    Compression levels:
-        None = 0
-        Fastest = 1
-        Best = 9
-*/
-
-#define PNG_COMPRESSION 6
-
 class SpriteManager
 {
+    enum {
+        SPRITE_WIDTH=32,
+        SPRITE_HEIGHT=32,
+        SPRITE_CHANNELS=4,
+        SPRITE_SIZE=SPRITE_WIDTH*SPRITE_HEIGHT*SPRITE_CHANNELS
+    };
+
 public:
     SpriteManager();