Use FileStream instead of SDL2

src/openrct2/Imaging.cpp

@@ -15,6 +15,8 @@
 #pragma endregion
 
 #include <png.h>
+#include "core/Exception.hpp"
+#include "core/FileStream.hpp"
 #include "core/Guard.hpp"
 #include "core/Memory.hpp"
 
@@ -49,22 +51,19 @@ namespace Imaging
         }
 
         // Open PNG file
-        SDL_RWops * fp = SDL_RWFromFile(path, "rb");
-        if (fp == nullptr)
+        try
         {
-            return false;
-        }
+            auto fs = FileStream(path, FILE_MODE_OPEN);
 
             // Set error handling
             if (setjmp(png_jmpbuf(png_ptr)))
             {
                 png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
-            SDL_RWclose(fp);
                 return false;
             }
 
             // Setup png reading
-        png_set_read_fn(png_ptr, fp, PngReadData);
+            png_set_read_fn(png_ptr, &fs, PngReadData);
             png_set_sig_bytes(png_ptr, sig_read);
 
             // To simplify the reading process, convert 4-16 bit data to 24-32 bit data
@@ -95,7 +94,8 @@ namespace Imaging
                         *dst++ = 255;
                     }
                 }
-        } else
+            }
+            else
             {
                 // 32-bit PNG (with alpha)
                 Guard::Assert(rowBytes == pngWidth * 4, GUARD_LINE);
@@ -108,17 +108,27 @@ namespace Imaging
 
             // Close the PNG
             png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
-        SDL_RWclose(fp);
 
             // Return the output data
             *pixels = (uint8*)pngPixels;
             if (width != nullptr) *width = pngWidth;
             if (height != nullptr) *height = pngHeight;
+
             return true;
         }
+        catch (Exception)
+        {
+            *pixels = nullptr;
+            if (width != nullptr) *width = 0;
+            if (height != nullptr) *height = 0;
+            return false;
+        }
+    }
 
     bool PngWrite(const rct_drawpixelinfo * dpi, const rct_palette * palette, const utf8 * path)
     {
+        bool result = false;
+
         // Get image size
         int stride = dpi->width + dpi->pitch;
 
@@ -147,23 +157,16 @@ namespace Imaging
 
         png_set_PLTE(png_ptr, info_ptr, png_palette, PNG_MAX_PALETTE_LENGTH);
 
-        // Open file for writing
-        SDL_RWops * file = SDL_RWFromFile(path, "wb");
-        if (file == nullptr)
+        try
         {
-            png_free(png_ptr, png_palette);
-            png_destroy_write_struct(&png_ptr, (png_infopp)nullptr);
-            return false;
-        }
-        png_set_write_fn(png_ptr, file, PngWriteData, PngFlush);
+            // Open file for writing
+            auto fs = FileStream(path, FILE_MODE_WRITE);
+            png_set_write_fn(png_ptr, &fs, PngWriteData, PngFlush);
 
             // Set error handler
             if (setjmp(png_jmpbuf(png_ptr)))
             {
-            png_free(png_ptr, png_palette);
-            png_destroy_write_struct(&png_ptr, &info_ptr);
-            SDL_RWclose(file);
-            return false;
+                throw Exception("PNG ERROR");
             }
 
             // Write header
@@ -176,7 +179,7 @@ namespace Imaging
             png_write_info(png_ptr, info_ptr);
 
             // Write pixels
-        uint8 *bits = dpi->bits;
+            uint8 * bits = dpi->bits;
             for (int y = 0; y < dpi->height; y++)
             {
                 png_write_row(png_ptr, (png_byte *)bits);
@@ -185,15 +188,21 @@ namespace Imaging
 
             // Finish
             png_write_end(png_ptr, nullptr);
-        SDL_RWclose(file);
+            result = true;
+        }
+        catch (Exception)
+        {
+        }
 
         png_free(png_ptr, png_palette);
-        png_destroy_write_struct(&png_ptr, &info_ptr);
-        return true;
+        png_destroy_write_struct(&png_ptr, (png_infopp)nullptr);
+        return result;
     }
 
     bool PngWrite32bpp(sint32 width, sint32 height, const void * pixels, const utf8 * path)
     {
+        bool result = false;
+
         // Setup PNG
         png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, PngError, PngWarning);
         if (png_ptr == nullptr)
@@ -208,21 +217,16 @@ namespace Imaging
             return false;
         }
 
-        // Open file for writing
-        SDL_RWops * file = SDL_RWFromFile(path, "wb");
-        if (file == nullptr)
+        try
         {
-            png_destroy_write_struct(&png_ptr, (png_infopp)nullptr);
-            return false;
-        }
-        png_set_write_fn(png_ptr, file, PngWriteData, PngFlush);
+            // Open file for writing
+            auto fs = FileStream(path, FILE_MODE_WRITE);
+            png_set_write_fn(png_ptr, &fs, PngWriteData, PngFlush);
 
             // Set error handler
             if (setjmp(png_jmpbuf(png_ptr)))
             {
-            png_destroy_write_struct(&png_ptr, &info_ptr);
-            SDL_RWclose(file);
-            return false;
+                throw Exception("PNG ERROR");
             }
 
             // Write header
@@ -242,22 +246,26 @@ namespace Imaging
 
             // Finish
             png_write_end(png_ptr, nullptr);
-        SDL_RWclose(file);
+            result = true;
+        }
+        catch (Exception)
+        {
+        }
 
         png_destroy_write_struct(&png_ptr, &info_ptr);
-        return true;
+        return result;
     }
 
     static void PngReadData(png_structp png_ptr, png_bytep data, png_size_t length)
     {
-        SDL_RWops * file = (SDL_RWops *)png_get_io_ptr(png_ptr);
-        SDL_RWread(file, data, length, 1);
+        auto * fs = static_cast<FileStream *>(png_get_io_ptr(png_ptr));
+        fs->Read(data, length);
     }
 
     static void PngWriteData(png_structp png_ptr, png_bytep data, png_size_t length)
     {
-        SDL_RWops * file = (SDL_RWops *)png_get_io_ptr(png_ptr);
-        SDL_RWwrite(file, data, length, 1);
+        auto * fs = static_cast<FileStream *>(png_get_io_ptr(png_ptr));
+        fs->Write(data, length);
     }
 
     static void PngFlush(png_structp png_ptr)