Use SDL_RWops directly on top of PhysFS

This avoids the creation of a temporary buffer containing a complete
file for the sole purpose of wrapping it up in an SDL_RWops.

The necessary wrapper is by Ryan C. Gordon and is included in the
PhysFS repository under 'extras'.

Reviewed-by: Yohann Ferreira

12 files changed, 316 insertions, 52 deletions

diff --git a/mana.files b/mana.files
index 26ef803c..0e360705 100644
--- a/mana.files
+++ b/mana.files
@@ -540,6 +540,8 @@ src/utils/mathutils.h
 src/utils/mkdir.cpp
 src/utils/mkdir.h
 src/utils/mutex.h
+src/utils/physfsrwops.c
+src/utils/physfsrwops.h
 src/utils/sha256.cpp
 src/utils/sha256.h
 src/utils/specialfolder.cpp
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 575a00f0..895fd349 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -412,6 +412,8 @@ SET(SRCS
     utils/dtor.h
     utils/gettext.h
     utils/mathutils.h
+    utils/physfsrwops.c
+    utils/physfsrwops.h
     utils/sha256.cpp
     utils/sha256.h
     utils/stringutils.cpp
diff --git a/src/resources/image.cpp b/src/resources/image.cpp
index 63f1bd2c..7f14a73e 100644
--- a/src/resources/image.cpp
+++ b/src/resources/image.cpp
@@ -105,10 +105,8 @@ Image::~Image()
     unload();
 }
 
-Resource *Image::load(void *buffer, unsigned bufferSize)
+Resource *Image::load(SDL_RWops *rw)
 {
-    // Load the raw file data from the buffer in an RWops structure
-    SDL_RWops *rw = SDL_RWFromMem(buffer, bufferSize);
     SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
 
     if (!tmpImage)
@@ -123,9 +121,8 @@ Resource *Image::load(void *buffer, unsigned bufferSize)
     return image;
 }
 
-Resource *Image::load(void *buffer, unsigned bufferSize, Dye const &dye)
+Resource *Image::load(SDL_RWops *rw, Dye const &dye)
 {
-    SDL_RWops *rw = SDL_RWFromMem(buffer, bufferSize);
     SDL_Surface *tmpImage = IMG_Load_RW(rw, 1);
 
     if (!tmpImage)
diff --git a/src/resources/image.h b/src/resources/image.h
index 5b361e1a..85db0c17 100644
--- a/src/resources/image.h
+++ b/src/resources/image.h
@@ -56,28 +56,25 @@ class Image : public Resource
         virtual ~Image();
 
         /**
-         * Loads an image from a buffer in memory.
+         * Loads an image from an SDL_RWops structure.
          *
-         * @param buffer     The memory buffer containing the image data.
-         * @param bufferSize The size of the memory buffer in bytes.
+         * @param rw         The SDL_RWops to load the image from.
          *
          * @return <code>NULL</code> if an error occurred, a valid pointer
          *         otherwise.
          */
-        static Resource *load(void *buffer, unsigned bufferSize);
+        static Resource *load(SDL_RWops *rw);
 
         /**
-         * Loads an image from a buffer in memory and recolors it.
+         * Loads an image from an SDL_RWops structure and recolors it.
          *
-         * @param buffer     The memory buffer containing the image data.
-         * @param bufferSize The size of the memory buffer in bytes.
+         * @param rw         The SDL_RWops to load the image from.
          * @param dye        The dye used to recolor the image.
          *
          * @return <code>NULL</code> if an error occurred, a valid pointer
          *         otherwise.
          */
-        static Resource *load(void *buffer, unsigned bufferSize,
-                              Dye const &dye);
+        static Resource *load(SDL_RWops *rw, Dye const &dye);
 
         /**
          * Loads an image from an SDL surface.
diff --git a/src/resources/music.cpp b/src/resources/music.cpp
index c55bddfe..2154fb5f 100644
--- a/src/resources/music.cpp
+++ b/src/resources/music.cpp
@@ -35,11 +35,8 @@ Music::~Music()
     Mix_FreeChunk(mChunk);
 }
 
-Resource *Music::load(void *buffer, unsigned bufferSize)
+Resource *Music::load(SDL_RWops *rw)
 {
-    // Load the raw file data from the buffer in an RWops structure
-    SDL_RWops *rw = SDL_RWFromMem(buffer, bufferSize);
-
     // Use Mix_LoadMUS to load the raw music data
     //Mix_Music* music = Mix_LoadMUS_RW(rw); Need to be implemeted
     Mix_Chunk *tmpMusic = Mix_LoadWAV_RW(rw, 1);
diff --git a/src/resources/music.h b/src/resources/music.h
index 1d040706..6a4cabd5 100644
--- a/src/resources/music.h
+++ b/src/resources/music.h
@@ -41,13 +41,12 @@ class Music : public Resource
         /**
          * Loads a music from a buffer in memory.
          *
-         * @param buffer     The memory buffer containing the music data.
-         * @param bufferSize The size of the memory buffer in bytes.
+         * @param rw         The SDL_RWops to load the music data from.
          *
          * @return <code>NULL</code> if the an error occurred, a valid pointer
          *         otherwise.
          */
-        static Resource *load(void *buffer, unsigned bufferSize);
+        static Resource *load(SDL_RWops *rw);
 
         /**
          * Plays the music.
diff --git a/src/resources/resourcemanager.cpp b/src/resources/resourcemanager.cpp
index 00e4726e..c7e20111 100644
--- a/src/resources/resourcemanager.cpp
+++ b/src/resources/resourcemanager.cpp
@@ -32,6 +32,7 @@
 #include "resources/spritedef.h"
 
 #include "utils/zlib.h"
+#include "utils/physfsrwops.h"
 
 #include <physfs.h>
 
@@ -273,14 +274,14 @@ struct ResourceLoader
     ResourceManager *manager;
     std::string path;
     ResourceManager::loader fun;
+
     static Resource *load(void *v)
     {
         ResourceLoader *l = static_cast< ResourceLoader * >(v);
-        int fileSize;
-        void *buffer = l->manager->loadFile(l->path, fileSize);
-        if (!buffer) return NULL;
-        Resource *res = l->fun(buffer, fileSize);
-        free(buffer);
+        SDL_RWops *rw = PHYSFSRWOPS_openRead(l->path.c_str());
+        if (!rw)
+            return NULL;
+        Resource *res = l->fun(rw);
         return res;
     }
 };
@@ -316,16 +317,14 @@ struct DyedImageLoader
             d = new Dye(path.substr(p + 1));
             path = path.substr(0, p);
         }
-        int fileSize;
-        void *buffer = l->manager->loadFile(path, fileSize);
-        if (!buffer)
+        SDL_RWops *rw = PHYSFSRWOPS_openRead(path.c_str());
+        if (!rw)
         {
             delete d;
             return NULL;
         }
-        Resource *res = d ? Image::load(buffer, fileSize, *d)
-                          : Image::load(buffer, fileSize);
-        free(buffer);
+        Resource *res = d ? Image::load(rw, *d)
+                          : Image::load(rw);
         delete d;
         return res;
     }
@@ -520,18 +519,10 @@ std::vector<std::string> ResourceManager::loadTextFile(
 
 SDL_Surface *ResourceManager::loadSDLSurface(const std::string &filename)
 {
-    int fileSize;
-    void *buffer = loadFile(filename, fileSize);
-    SDL_Surface *tmp = NULL;
-
-    if (buffer)
-    {
-        SDL_RWops *rw = SDL_RWFromMem(buffer, fileSize);
-        tmp = IMG_Load_RW(rw, 1);
-        ::free(buffer);
-    }
-
-    return tmp;
+    SDL_Surface *surface = 0;
+    if (SDL_RWops *rw = PHYSFSRWOPS_openRead(filename.c_str()))
+        surface = IMG_Load_RW(rw, 1);
+    return surface;
 }
 
 void ResourceManager::scheduleDelete(SDL_Surface* surface)
diff --git a/src/resources/resourcemanager.h b/src/resources/resourcemanager.h
index 9b40814f..d2b4261e 100644
--- a/src/resources/resourcemanager.h
+++ b/src/resources/resourcemanager.h
@@ -34,7 +34,9 @@ class Music;
 class Resource;
 class SoundEffect;
 class SpriteDef;
+
 struct SDL_Surface;
+struct SDL_RWops;
 
 /**
  * A class for loading and managing resources.
@@ -45,7 +47,7 @@ class ResourceManager
 
     public:
 
-        typedef Resource *(*loader)(void *, unsigned);
+        typedef Resource *(*loader)(SDL_RWops *);
         typedef Resource *(*generator)(void *);
 
         ResourceManager();
diff --git a/src/resources/soundeffect.cpp b/src/resources/soundeffect.cpp
index 1a8f9671..31bb75bf 100644
--- a/src/resources/soundeffect.cpp
+++ b/src/resources/soundeffect.cpp
@@ -28,11 +28,8 @@ SoundEffect::~SoundEffect()
     Mix_FreeChunk(mChunk);
 }
 
-Resource *SoundEffect::load(void *buffer, unsigned bufferSize)
+Resource *SoundEffect::load(SDL_RWops *rw)
 {
-    // Load the raw file data from the buffer in an RWops structure
-    SDL_RWops *rw = SDL_RWFromMem(buffer, bufferSize);
-
     // Load the music data and free the RWops structure
     Mix_Chunk *tmpSoundEffect = Mix_LoadWAV_RW(rw, 1);
 
diff --git a/src/resources/soundeffect.h b/src/resources/soundeffect.h
index 5c493678..85265ef5 100644
--- a/src/resources/soundeffect.h
+++ b/src/resources/soundeffect.h
@@ -41,13 +41,12 @@ class SoundEffect : public Resource
         /**
          * Loads a sample from a buffer in memory.
          *
-         * @param buffer     The memory buffer containing the sample data.
-         * @param bufferSize The size of the memory buffer in bytes.
+         * @param rw         The SDL_RWops to load the sample data from.
          *
          * @return <code>NULL</code> if the an error occurred, a valid pointer
          *         otherwise.
          */
-        static Resource *load(void *buffer, unsigned bufferSize);
+        static Resource *load(SDL_RWops *rw);
 
         /**
          * Plays the sample.
diff --git a/src/utils/physfsrwops.c b/src/utils/physfsrwops.c
new file mode 100644
index 00000000..1a5a7137
--- /dev/null
+++ b/src/utils/physfsrwops.c
@@ -0,0 +1,193 @@
+/*
+ * This code provides a glue layer between PhysicsFS and Simple Directmedia
+ *  Layer's (SDL) RWops i/o abstraction.
+ *
+ * License: this code is public domain. I make no warranty that it is useful,
+ *  correct, harmless, or environmentally safe.
+ *
+ * This particular file may be used however you like, including copying it
+ *  verbatim into a closed-source project, exploiting it commercially, and
+ *  removing any trace of my name from the source (although I hope you won't
+ *  do that). I welcome enhancements and corrections to this file, but I do
+ *  not require you to send me patches if you make changes. This code has
+ *  NO WARRANTY.
+ *
+ * Unless otherwise stated, the rest of PhysicsFS falls under the zlib license.
+ *  Please see LICENSE.txt in the root of the source tree.
+ *
+ * SDL falls under the LGPL license. You can get SDL at http://www.libsdl.org/
+ *
+ *  This file was written by Ryan C. Gordon. (icculus@icculus.org).
+ */
+
+#include <stdio.h>  /* used for SEEK_SET, SEEK_CUR, SEEK_END ... */
+#include "physfsrwops.h"
+
+static int physfsrwops_seek(SDL_RWops *rw, int offset, int whence)
+{
+    PHYSFS_File *handle = (PHYSFS_File *) rw->hidden.unknown.data1;
+    int pos = 0;
+
+    if (whence == SEEK_SET)
+    {
+        pos = offset;
+    } /* if */
+
+    else if (whence == SEEK_CUR)
+    {
+        PHYSFS_sint64 current = PHYSFS_tell(handle);
+        if (current == -1)
+        {
+            SDL_SetError("Can't find position in file: %s",
+                          PHYSFS_getLastError());
+            return(-1);
+        } /* if */
+
+        pos = (int) current;
+        if ( ((PHYSFS_sint64) pos) != current )
+        {
+            SDL_SetError("Can't fit current file position in an int!");
+            return(-1);
+        } /* if */
+
+        if (offset == 0)  /* this is a "tell" call. We're done. */
+            return(pos);
+
+        pos += offset;
+    } /* else if */
+
+    else if (whence == SEEK_END)
+    {
+        PHYSFS_sint64 len = PHYSFS_fileLength(handle);
+        if (len == -1)
+        {
+            SDL_SetError("Can't find end of file: %s", PHYSFS_getLastError());
+            return(-1);
+        } /* if */
+
+        pos = (int) len;
+        if ( ((PHYSFS_sint64) pos) != len )
+        {
+            SDL_SetError("Can't fit end-of-file position in an int!");
+            return(-1);
+        } /* if */
+
+        pos += offset;
+    } /* else if */
+
+    else
+    {
+        SDL_SetError("Invalid 'whence' parameter.");
+        return(-1);
+    } /* else */
+
+    if ( pos < 0 )
+    {
+        SDL_SetError("Attempt to seek past start of file.");
+        return(-1);
+    } /* if */
+
+    if (!PHYSFS_seek(handle, (PHYSFS_uint64) pos))
+    {
+        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
+        return(-1);
+    } /* if */
+
+    return(pos);
+} /* physfsrwops_seek */
+
+
+static int physfsrwops_read(SDL_RWops *rw, void *ptr, int size, int maxnum)
+{
+    PHYSFS_File *handle = (PHYSFS_File *) rw->hidden.unknown.data1;
+    PHYSFS_sint64 rc = PHYSFS_read(handle, ptr, size, maxnum);
+    if (rc != maxnum)
+    {
+        if (!PHYSFS_eof(handle)) /* not EOF? Must be an error. */
+            SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
+    } /* if */
+
+    return((int) rc);
+} /* physfsrwops_read */
+
+
+static int physfsrwops_write(SDL_RWops *rw, const void *ptr, int size, int num)
+{
+    PHYSFS_File *handle = (PHYSFS_File *) rw->hidden.unknown.data1;
+    PHYSFS_sint64 rc = PHYSFS_write(handle, ptr, size, num);
+    if (rc != num)
+        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
+
+    return((int) rc);
+} /* physfsrwops_write */
+
+
+static int physfsrwops_close(SDL_RWops *rw)
+{
+    PHYSFS_File *handle = (PHYSFS_File *) rw->hidden.unknown.data1;
+    if (!PHYSFS_close(handle))
+    {
+        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
+        return(-1);
+    } /* if */
+
+    SDL_FreeRW(rw);
+    return(0);
+} /* physfsrwops_close */
+
+
+static SDL_RWops *create_rwops(PHYSFS_File *handle)
+{
+    SDL_RWops *retval = NULL;
+
+    if (handle == NULL)
+        SDL_SetError("PhysicsFS error: %s", PHYSFS_getLastError());
+    else
+    {
+        retval = SDL_AllocRW();
+        if (retval != NULL)
+        {
+            retval->seek  = physfsrwops_seek;
+            retval->read  = physfsrwops_read;
+            retval->write = physfsrwops_write;
+            retval->close = physfsrwops_close;
+            retval->hidden.unknown.data1 = handle;
+        } /* if */
+    } /* else */
+
+    return(retval);
+} /* create_rwops */
+
+
+SDL_RWops *PHYSFSRWOPS_makeRWops(PHYSFS_File *handle)
+{
+    SDL_RWops *retval = NULL;
+    if (handle == NULL)
+        SDL_SetError("NULL pointer passed to PHYSFSRWOPS_makeRWops().");
+    else
+        retval = create_rwops(handle);
+
+    return(retval);
+} /* PHYSFSRWOPS_makeRWops */
+
+
+SDL_RWops *PHYSFSRWOPS_openRead(const char *fname)
+{
+    return(create_rwops(PHYSFS_openRead(fname)));
+} /* PHYSFSRWOPS_openRead */
+
+
+SDL_RWops *PHYSFSRWOPS_openWrite(const char *fname)
+{
+    return(create_rwops(PHYSFS_openWrite(fname)));
+} /* PHYSFSRWOPS_openWrite */
+
+
+SDL_RWops *PHYSFSRWOPS_openAppend(const char *fname)
+{
+    return(create_rwops(PHYSFS_openAppend(fname)));
+} /* PHYSFSRWOPS_openAppend */
+
+
+/* end of physfsrwops.c ... */
+
diff --git a/src/utils/physfsrwops.h b/src/utils/physfsrwops.h
new file mode 100644
index 00000000..406fba6f
--- /dev/null
+++ b/src/utils/physfsrwops.h
@@ -0,0 +1,88 @@
+/*
+ * This code provides a glue layer between PhysicsFS and Simple Directmedia
+ *  Layer's (SDL) RWops i/o abstraction.
+ *
+ * License: this code is public domain. I make no warranty that it is useful,
+ *  correct, harmless, or environmentally safe.
+ *
+ * This particular file may be used however you like, including copying it
+ *  verbatim into a closed-source project, exploiting it commercially, and
+ *  removing any trace of my name from the source (although I hope you won't
+ *  do that). I welcome enhancements and corrections to this file, but I do
+ *  not require you to send me patches if you make changes. This code has
+ *  NO WARRANTY.
+ *
+ * Unless otherwise stated, the rest of PhysicsFS falls under the zlib license.
+ *  Please see LICENSE.txt in the root of the source tree.
+ *
+ * SDL falls under the LGPL license. You can get SDL at http://www.libsdl.org/
+ *
+ *  This file was written by Ryan C. Gordon. (icculus@icculus.org).
+ */
+
+#ifndef _INCLUDE_PHYSFSRWOPS_H_
+#define _INCLUDE_PHYSFSRWOPS_H_
+
+#include "physfs.h"
+#include "SDL.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Open a platform-independent filename for reading, and make it accessible
+ *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
+ *  RWops is closed. PhysicsFS should be configured to your liking before
+ *  opening files through this method.
+ *
+ *   @param filename File to open in platform-independent notation.
+ *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
+ *           of the error can be gleaned from PHYSFS_getLastError().
+ */
+__EXPORT__ SDL_RWops *PHYSFSRWOPS_openRead(const char *fname);
+
+/**
+ * Open a platform-independent filename for writing, and make it accessible
+ *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
+ *  RWops is closed. PhysicsFS should be configured to your liking before
+ *  opening files through this method.
+ *
+ *   @param filename File to open in platform-independent notation.
+ *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
+ *           of the error can be gleaned from PHYSFS_getLastError().
+ */
+__EXPORT__ SDL_RWops *PHYSFSRWOPS_openWrite(const char *fname);
+
+/**
+ * Open a platform-independent filename for appending, and make it accessible
+ *  via an SDL_RWops structure. The file will be closed in PhysicsFS when the
+ *  RWops is closed. PhysicsFS should be configured to your liking before
+ *  opening files through this method.
+ *
+ *   @param filename File to open in platform-independent notation.
+ *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
+ *           of the error can be gleaned from PHYSFS_getLastError().
+ */
+__EXPORT__ SDL_RWops *PHYSFSRWOPS_openAppend(const char *fname);
+
+/**
+ * Make a SDL_RWops from an existing PhysicsFS file handle. You should
+ *  dispose of any references to the handle after successful creation of
+ *  the RWops. The actual PhysicsFS handle will be destroyed when the
+ *  RWops is closed.
+ *
+ *   @param handle a valid PhysicsFS file handle.
+ *  @return A valid SDL_RWops structure on success, NULL on error. Specifics
+ *           of the error can be gleaned from PHYSFS_getLastError().
+ */
+__EXPORT__ SDL_RWops *PHYSFSRWOPS_makeRWops(PHYSFS_File *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* include-once blocker */
+
+/* end of physfsrwops.h ... */
+