rwops: Reworked RWops for SDL3.

- SDL_RWops is now an opaque struct.
- SDL_AllocRW is gone. If an app is creating a custom RWops, they pass the
  function pointers to SDL_CreateRW(), which are stored internally.
- SDL_RWclose is gone, there is only SDL_DestroyRW(), which calls the
  implementation's `->close` method before freeing other things.
- There is only one path to create and use RWops now, so we don't have to
  worry about whether `->close` will call SDL_DestroyRW, or if this will
  risk any Properties not being released, etc.
- SDL_RWFrom* still works as expected, for getting a RWops without having
  to supply your own implementation. Objects from these functions are also
  destroyed with SDL_DestroyRW.
- Lots of other cleanup and SDL3ization of the library code.

docs/README-migration.md

@@ -1156,7 +1156,11 @@ The following symbols have been renamed:
 * RW_SEEK_END => SDL_RW_SEEK_END
 * RW_SEEK_SET => SDL_RW_SEEK_SET
 
-SDL_RWread and SDL_RWwrite (and SDL_RWops::read, SDL_RWops::write) have a different function signature in SDL3.
+SDL_RWops is now an opaque structure. The existing APIs to create a RWops (SDL_RWFromFile, etc) still function as expected, but to make a custom RWops with app-provided function pointers, call SDL_CreateRW and provide the function pointers through there. To call into a RWops's functionality, use the standard APIs (SDL_RWread, etc) instead of calling into function pointers directly.
+
+The RWops function pointers are now in a separate structure called SDL_RWopsInteface, which is provided to SDL_CreateRW. All the functions now take a `void *` userdata argument for their first parameter instead of an SDL_RWops, since that's now an opaque structure.
+
+SDL_RWread and SDL_RWwrite (and SDL_RWopsInterface::read, SDL_RWopsInterface::write) have a different function signature in SDL3.
 
 Previously they looked more like stdio:
 
@@ -1168,19 +1172,19 @@ size_t SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size, size_t maxn
 But now they look more like POSIX:
 
 ```c
-size_t SDL_RWread(SDL_RWops *context, void *ptr, size_t size);
-size_t SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size);
+size_t SDL_RWread(void *userdata, void *ptr, size_t size);
+size_t SDL_RWwrite(void *userdata, const void *ptr, size_t size);
 ```
 
 Code that used to look like this:
-```
+```c
 size_t custom_read(void *ptr, size_t size, size_t nitems, SDL_RWops *stream)
 {
     return SDL_RWread(stream, ptr, size, nitems);
 }
 ```
 should be changed to:
-```
+```c
 size_t custom_read(void *ptr, size_t size, size_t nitems, SDL_RWops *stream)
 {
     if (size > 0 && nitems > 0) {
@@ -1190,15 +1194,28 @@ size_t custom_read(void *ptr, size_t size, size_t nitems, SDL_RWops *stream)
 }
 ```
 
+SDL_RWops::type was removed and has no replacement; it wasn't meaningful for app-provided implementations at all, and wasn't much use for SDL's internal implementations, either.
+
+SDL_RWopsInterface::close implementations should clean up their own userdata, but not call SDL_DestroyRW on themselves; now the contract is always that SDL_DestroyRW is called, which calls `->close` and then frees the opaque object.
+
 SDL_RWFromFP has been removed from the API, due to issues when the SDL library uses a different C runtime from the application.
 
+SDL_AllocRW(), SDL_FreeRW(), SDL_RWclose() and direct access to the `->close` function pointer have been removed from the API, so there's only one path to manage RWops lifetimes now: SDL_CreateRW() and SDL_DestroyRW().
+
+
 You can implement this in your own code easily:
 ```c
 #include <stdio.h>
 
+typedef struct RWopsStdioFPData
+{
+    FILE *fp;
+    SDL_bool autoclose;
+} RWopsStdioFPData;
 
-static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
+static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
 {
+    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
     int stdiowhence;
 
     switch (whence) {
@@ -1215,8 +1232,8 @@ static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
         return SDL_SetError("Unknown value for 'whence'");
     }
 
-    if (fseek((FILE *)context->hidden.stdio.fp, (fseek_off_t)offset, stdiowhence) == 0) {
-        Sint64 pos = ftell((FILE *)context->hidden.stdio.fp);
+    if (fseek(fp, (fseek_off_t)offset, stdiowhence) == 0) {
+        const Sint64 pos = ftell(fp);
         if (pos < 0) {
             return SDL_SetError("Couldn't get stream offset");
         }
@@ -1225,53 +1242,62 @@ static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
     return SDL_Error(SDL_EFSEEK);
 }
 
-static size_t SDLCALL stdio_read(SDL_RWops *context, void *ptr, size_t size)
+static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size)
 {
-    size_t bytes;
-
-    bytes = fread(ptr, 1, size, (FILE *)context->hidden.stdio.fp);
-    if (bytes == 0 && ferror((FILE *)context->hidden.stdio.fp)) {
+    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
+    const size_t bytes = fread(ptr, 1, size, fp);
+    if (bytes == 0 && ferror(fp)) {
         SDL_Error(SDL_EFREAD);
     }
     return bytes;
 }
 
-static size_t SDLCALL stdio_write(SDL_RWops *context, const void *ptr, size_t size)
+static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size)
 {
-    size_t bytes;
-
-    bytes = fwrite(ptr, 1, size, (FILE *)context->hidden.stdio.fp);
-    if (bytes == 0 && ferror((FILE *)context->hidden.stdio.fp)) {
+    FILE *fp = ((RWopsStdioFPData *) userdata)->fp;
+    const size_t bytes = fwrite(ptr, 1, size, fp);
+    if (bytes == 0 && ferror(fp)) {
         SDL_Error(SDL_EFWRITE);
     }
     return bytes;
 }
 
-static int SDLCALL stdio_close(SDL_RWops *context)
+static int SDLCALL stdio_close(void *userdata)
 {
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
     int status = 0;
-    if (context->hidden.stdio.autoclose) {
-        if (fclose((FILE *)context->hidden.stdio.fp) != 0) {
+    if (rwopsdata->autoclose) {
+        if (fclose(rwopsdata->fp) != 0) {
             status = SDL_Error(SDL_EFWRITE);
         }
     }
-    SDL_DestroyRW(context);
     return status;
 }
 
-SDL_RWops *SDL_RWFromFP(void *fp, SDL_bool autoclose)
+SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
 {
-    SDL_RWops *rwops = NULL;
-
-    rwops = SDL_CreateRW();
-    if (rwops != NULL) {
-        rwops->seek = stdio_seek;
-        rwops->read = stdio_read;
-        rwops->write = stdio_write;
-        rwops->close = stdio_close;
-        rwops->hidden.stdio.fp = fp;
-        rwops->hidden.stdio.autoclose = autoclose;
-        rwops->type = SDL_RWOPS_STDFILE;
+    SDL_RWopsInterface iface;
+    RWopsStdioFPData *rwopsdata;
+    SDL_RWops *rwops;
+
+    rwopsdata = (RWopsStdioFPData *) SDL_malloc(sizeof (*rwopsdata));
+    if (!rwopsdata) {
+        return NULL;
+    }
+
+    SDL_zero(iface);
+    /* There's no stdio_size because SDL_RWsize emulates it the same way we'd do it for stdio anyhow. */
+    iface.seek = stdio_seek;
+    iface.read = stdio_read;
+    iface.write = stdio_write;
+    iface.close = stdio_close;
+
+    rwopsdata->fp = fp;
+    rwopsdata->autoclose = autoclose;
+
+    rwops = SDL_CreateRW(&iface, rwopsdata);
+    if (!rwops) {
+        iface.close(rwopsdata);
     }
     return rwops;
 }
@@ -1280,8 +1306,6 @@ SDL_RWops *SDL_RWFromFP(void *fp, SDL_bool autoclose)
 The functions SDL_ReadU8(), SDL_ReadU16LE(), SDL_ReadU16BE(), SDL_ReadU32LE(), SDL_ReadU32BE(), SDL_ReadU64LE(), and SDL_ReadU64BE() now return SDL_TRUE if the read succeeded and SDL_FALSE if it didn't, and store the data in a pointer passed in as a parameter.
 
 The following functions have been renamed:
-* SDL_AllocRW() => SDL_CreateRW()
-* SDL_FreeRW() => SDL_DestroyRW()
 * SDL_ReadBE16() => SDL_ReadU16BE()
 * SDL_ReadBE32() => SDL_ReadU32BE()
 * SDL_ReadBE64() => SDL_ReadU64BE()

include/SDL3/SDL_audio.h

@@ -1317,7 +1317,7 @@ extern DECLSPEC int SDLCALL SDL_SetAudioPostmixCallback(SDL_AudioDeviceID devid,
  * ```
  *
  * \param src The data source for the WAVE data
- * \param freesrc If SDL_TRUE, calls SDL_RWclose() on `src` before returning,
+ * \param freesrc If SDL_TRUE, calls SDL_DestroyRW() on `src` before returning,
  *                even in the case of an error
  * \param spec A pointer to an SDL_AudioSpec that will be set to the WAVE
  *             data's format details on successful return

include/SDL3/SDL_gamepad.h

@@ -268,7 +268,7 @@ extern DECLSPEC int SDLCALL SDL_AddGamepadMapping(const char *mapping);
  * constrained environment.
  *
  * \param src the data stream for the mappings to be added
- * \param freesrc if SDL_TRUE, calls SDL_RWclose() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_DestroyRW() on `src` before returning,
  *                even in the case of an error
  * \returns the number of mappings added or -1 on error; call SDL_GetError()
  *          for more information.

include/SDL3/SDL_rwops.h

@@ -39,15 +39,8 @@
 extern "C" {
 #endif
 
-/* RWops types */
-#define SDL_RWOPS_UNKNOWN   0   /**< Unknown stream type */
-#define SDL_RWOPS_WINFILE   1   /**< Win32 file */
-#define SDL_RWOPS_STDFILE   2   /**< Stdio file */
-#define SDL_RWOPS_JNIFILE   3   /**< Android asset */
-#define SDL_RWOPS_MEMORY    4   /**< Memory stream */
-#define SDL_RWOPS_MEMORY_RO 5   /**< Read-Only memory stream */
-
 /* RWops status, set by a read or write operation */
+/* !!! FIXME: make this an enum? */
 #define SDL_RWOPS_STATUS_READY          0   /**< Everything is ready */
 #define SDL_RWOPS_STATUS_ERROR          1   /**< Read or write I/O error */
 #define SDL_RWOPS_STATUS_EOF            2   /**< End of file */
@@ -55,17 +48,14 @@ extern "C" {
 #define SDL_RWOPS_STATUS_READONLY       4   /**< Tried to write a read-only buffer */
 #define SDL_RWOPS_STATUS_WRITEONLY      5   /**< Tried to read a write-only buffer */
 
-/**
- * This is the read/write operation structure -- very basic.
- */
-typedef struct SDL_RWops
+typedef struct SDL_RWopsInterface
 {
     /**
      *  Return the number of bytes in this rwops
      *
      *  \return the total size of the data stream, or -1 on error.
      */
-    Sint64 (SDLCALL *size)(struct SDL_RWops *context);
+    Sint64 (SDLCALL *size)(void *userdata);
 
     /**
      *  Seek to \c offset relative to \c whence, one of stdio's whence values:
@@ -73,7 +63,7 @@ typedef struct SDL_RWops
      *
      *  \return the final offset in the data stream, or -1 on error.
      */
-    Sint64 (SDLCALL *seek)(struct SDL_RWops *context, Sint64 offset, int whence);
+    Sint64 (SDLCALL *seek)(void *userdata, Sint64 offset, int whence);
 
     /**
      *  Read up to \c size bytes from the data stream to the area pointed
@@ -81,7 +71,7 @@ typedef struct SDL_RWops
      *
      *  \return the number of bytes read
      */
-    size_t (SDLCALL *read)(struct SDL_RWops *context, void *ptr, size_t size);
+    size_t (SDLCALL *read)(void *userdata, void *ptr, size_t size);
 
     /**
      *  Write exactly \c size bytes from the area pointed at by \c ptr
@@ -89,61 +79,24 @@ typedef struct SDL_RWops
      *
      *  \return the number of bytes written
      */
-    size_t (SDLCALL *write)(struct SDL_RWops *context, const void *ptr, size_t size);
+    size_t (SDLCALL *write)(void *userdata, const void *ptr, size_t size);
 
     /**
-     *  Close and free an allocated SDL_RWops structure.
+     *  Close and free any allocated resources.
+     *
+     *  The RWops is still destroyed even if this fails, so clean up anything
+     *  even if flushing to disk returns an error.
      *
      *  \return 0 if successful or -1 on write error when flushing data.
      */
-    int (SDLCALL *close)(struct SDL_RWops *context);
-
-    Uint32 type;
-    Uint32 status;
-    SDL_PropertiesID props;
-    union
-    {
-#ifdef SDL_PLATFORM_ANDROID
-        struct
-        {
-            void *asset;
-        } androidio;
-
-#elif defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
-        struct
-        {
-            SDL_bool append;
-            void *h;
-            struct
-            {
-                void *data;
-                size_t size;
-                size_t left;
-            } buffer;
-        } windowsio;
-#endif
-
-        struct
-        {
-            SDL_bool autoclose;
-            void *fp;
-        } stdio;
-
-        struct
-        {
-            Uint8 *base;
-            Uint8 *here;
-            Uint8 *stop;
-        } mem;
+    int (SDLCALL *close)(void *userdata);
+} SDL_RWopsInterface;
 
-        struct
-        {
-            void *data1;
-            void *data2;
-        } unknown;
-    } hidden;
 
-} SDL_RWops;
+/**
+ * This is the read/write operation structure -- opaque, as of SDL3!
+ */
+typedef struct SDL_RWops SDL_RWops;
 
 
 /**
@@ -195,7 +148,7 @@ typedef struct SDL_RWops
  * As a fallback, SDL_RWFromFile() will transparently open a matching filename
  * in an Android app's `assets`.
  *
- * Closing the SDL_RWops will close the file handle SDL is holding internally.
+ * Destroying the SDL_RWops will close the file handle SDL is holding internally.
  *
  * \param file a UTF-8 string representing the filename to open
  * \param mode an ASCII string representing the mode to be used for opening
@@ -205,7 +158,6 @@ typedef struct SDL_RWops
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromMem
  * \sa SDL_RWread
@@ -236,7 +188,6 @@ extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file, const char *
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -270,7 +221,6 @@ extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromMem(void *mem, size_t size);
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -284,20 +234,14 @@ extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem, size_t si
 
 
 /**
- * Use this function to allocate an empty, unpopulated SDL_RWops structure.
+ * Use this function to allocate a SDL_RWops structure.
  *
  * Applications do not need to use this function unless they are providing
  * their own SDL_RWops implementation. If you just need an SDL_RWops to
  * read/write a common data source, you should use the built-in
  * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc.
  *
- * You must free the returned pointer with SDL_DestroyRW(). Depending on your
- * operating system and compiler, there may be a difference between the
- * malloc() and free() your program uses and the versions SDL calls
- * internally. Trying to mix the two can cause crashing such as segmentation
- * faults. Since all SDL_RWops must free themselves when their **close**
- * method is called, all SDL_RWops must be allocated through this function, so
- * they can all be freed correctly with SDL_DestroyRW().
+ * You must free the returned pointer with SDL_DestroyRW().
  *
  * \returns a pointer to the allocated memory on success, or NULL on failure;
  *          call SDL_GetError() for more information.
@@ -306,32 +250,33 @@ extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem, size_t si
  *
  * \sa SDL_DestroyRW
  */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_CreateRW(void);
+extern DECLSPEC SDL_RWops *SDLCALL SDL_CreateRW(const SDL_RWopsInterface *iface, void *userdata);
 
 /**
- * Use this function to free an SDL_RWops structure allocated by
- * SDL_CreateRW().
+ * Close and free an allocated SDL_RWops structure.
  *
- * Applications do not need to use this function unless they are providing
- * their own SDL_RWops implementation. If you just need an SDL_RWops to
- * read/write a common data source, you should use the built-in
- * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and
- * call the **close** method on those SDL_RWops pointers when you are done
- * with them.
+ * SDL_DestroyRW() closes and cleans up the SDL_RWops stream. It releases any
+ * resources used by the stream and frees the SDL_RWops itself with
+ * SDL_DestroyRW(). This returns 0 on success, or -1 if the stream failed to
+ * flush to its output (e.g. to disk).
  *
- * Only use SDL_DestroyRW() on pointers returned by SDL_CreateRW(). The
- * pointer is invalid as soon as this function returns. Any extra memory
- * allocated during creation of the SDL_RWops is not freed by SDL_DestroyRW();
- * the programmer must be responsible for managing that memory in their
- * **close** method.
+ * Note that if this fails to flush the stream to disk, this function reports
+ * an error, but the SDL_RWops is still invalid once this function returns.
  *
- * \param context the SDL_RWops structure to be freed
+ * \param context SDL_RWops structure to close
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_CreateRW
+ * \sa SDL_RWFromConstMem
+ * \sa SDL_RWFromFile
+ * \sa SDL_RWFromMem
+ * \sa SDL_RWread
+ * \sa SDL_RWseek
+ * \sa SDL_RWwrite
  */
-extern DECLSPEC void SDLCALL SDL_DestroyRW(SDL_RWops *context);
+extern DECLSPEC int SDLCALL SDL_DestroyRW(SDL_RWops *context);
 
 /**
  * Get the properties associated with an SDL_RWops.
@@ -389,7 +334,6 @@ extern DECLSPEC Sint64 SDLCALL SDL_RWsize(SDL_RWops *context);
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -413,7 +357,6 @@ extern DECLSPEC Sint64 SDLCALL SDL_RWseek(SDL_RWops *context, Sint64 offset, int
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -444,7 +387,6 @@ extern DECLSPEC Sint64 SDLCALL SDL_RWtell(SDL_RWops *context);
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -482,7 +424,6 @@ extern DECLSPEC size_t SDLCALL SDL_RWread(SDL_RWops *context, void *ptr, size_t
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -506,7 +447,6 @@ extern DECLSPEC size_t SDLCALL SDL_RWwrite(SDL_RWops *context, const void *ptr,
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -529,7 +469,6 @@ extern DECLSPEC size_t SDLCALL SDL_RWprintf(SDL_RWops *context, SDL_PRINTF_FORMA
  *
  * \since This function is available since SDL 3.0.0.
  *
- * \sa SDL_RWclose
  * \sa SDL_RWFromConstMem
  * \sa SDL_RWFromFile
  * \sa SDL_RWFromMem
@@ -539,32 +478,6 @@ extern DECLSPEC size_t SDLCALL SDL_RWprintf(SDL_RWops *context, SDL_PRINTF_FORMA
  */
 extern DECLSPEC size_t SDLCALL SDL_RWvprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(2);
 
-/**
- * Close and free an allocated SDL_RWops structure.
- *
- * SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any
- * resources used by the stream and frees the SDL_RWops itself with
- * SDL_DestroyRW(). This returns 0 on success, or -1 if the stream failed to
- * flush to its output (e.g. to disk).
- *
- * Note that if this fails to flush the stream to disk, this function reports
- * an error, but the SDL_RWops is still invalid once this function returns.
- *
- * \param context SDL_RWops structure to close
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 3.0.0.
- *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWwrite
- */
-extern DECLSPEC int SDLCALL SDL_RWclose(SDL_RWops *context);
-
 /**
  * Load all the data from an SDL data stream.
  *
@@ -576,7 +489,7 @@ extern DECLSPEC int SDLCALL SDL_RWclose(SDL_RWops *context);
  *
  * \param src the SDL_RWops to read all available data from
  * \param datasize if not NULL, will store the number of bytes read
- * \param freesrc if SDL_TRUE, calls SDL_RWclose() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_DestroyRW() on `src` before returning,
  *                even in the case of an error
  * \returns the data, or NULL if there was an error.
  *

include/SDL3/SDL_surface.h

@@ -328,7 +328,7 @@ extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
  * will result in a memory leak.
  *
  * \param src the data stream for the surface
- * \param freesrc if SDL_TRUE, calls SDL_RWclose() on `src` before returning,
+ * \param freesrc if SDL_TRUE, calls SDL_DestroyRW() on `src` before returning,
  *                even in the case of an error
  * \returns a pointer to a new SDL_Surface structure or NULL if there was an
  *          error; call SDL_GetError() for more information.
@@ -370,7 +370,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP(const char *file);
  *
  * \param surface the SDL_Surface structure containing the image to be saved
  * \param dst a data stream to save to
- * \param freedst if SDL_TRUE, calls SDL_RWclose() on `dst` before returning,
+ * \param freedst if SDL_TRUE, calls SDL_DestroyRW() on `dst` before returning,
  *                even in the case of an error
  * \returns 0 on success or a negative error code on failure; call
  *          SDL_GetError() for more information.

src/audio/SDL_wave.c

@@ -1629,7 +1629,7 @@ static int WaveReadFormat(WaveFile *file)
             return -1;
         }
     } else if (format->encoding == PCM_CODE) {
-        SDL_RWclose(fmtsrc);
+        SDL_DestroyRW(fmtsrc);
         return SDL_SetError("Missing wBitsPerSample field in WAVE fmt chunk");
     }
 
@@ -1649,7 +1649,7 @@ static int WaveReadFormat(WaveFile *file)
 
         /* Extensible header must be at least 22 bytes. */
         if (fmtlen < 40 || format->extsize < 22) {
-            SDL_RWclose(fmtsrc);
+            SDL_DestroyRW(fmtsrc);
             return SDL_SetError("Extensible WAVE header too small");
         }
 
@@ -1661,7 +1661,7 @@ static int WaveReadFormat(WaveFile *file)
         format->encoding = WaveGetFormatGUIDEncoding(format);
     }
 
-    SDL_RWclose(fmtsrc);
+    SDL_DestroyRW(fmtsrc);
 
     return 0;
 }
@@ -2117,7 +2117,7 @@ int SDL_LoadWAV_RW(SDL_RWops *src, SDL_bool freesrc, SDL_AudioSpec *spec, Uint8
     SDL_free(file.decoderdata);
 done:
     if (freesrc && src) {
-        SDL_RWclose(src);
+        SDL_DestroyRW(src);
     }
     return result;
 }

src/audio/disk/SDL_diskaudio.c

@@ -68,7 +68,7 @@ static int DISKAUDIO_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, in
         buflen -= br;
         buffer = ((Uint8 *)buffer) + br;
         if (buflen > 0) { // EOF (or error, but whatever).
-            SDL_RWclose(h->io);
+            SDL_DestroyRW(h->io);
             h->io = NULL;
         }
     }
@@ -88,7 +88,7 @@ static void DISKAUDIO_CloseDevice(SDL_AudioDevice *device)
 {
     if (device->hidden) {
         if (device->hidden->io) {
-            SDL_RWclose(device->hidden->io);
+            SDL_DestroyRW(device->hidden->io);
         }
         SDL_free(device->hidden->mixbuf);
         SDL_free(device->hidden);

src/core/android/SDL_android.c

@@ -1956,11 +1956,12 @@ static void Internal_Android_Destroy_AssetManager()
     }
 }
 
-int Android_JNI_FileOpen(SDL_RWops *ctx,
-                         const char *fileName, const char *mode)
+int Android_JNI_FileOpen(void **puserdata, const char *fileName, const char *mode)
 {
+    SDL_assert(puserdata != NULL);
+
     AAsset *asset = NULL;
-    ctx->hidden.androidio.asset = NULL;
+    *puserdata = NULL;
 
     if (!asset_manager) {
         Internal_Android_Create_AssetManager();
@@ -1975,14 +1976,13 @@ int Android_JNI_FileOpen(SDL_RWops *ctx,
         return SDL_SetError("Couldn't open asset '%s'", fileName);
     }
 
-    ctx->hidden.androidio.asset = (void *)asset;
+    *puserdata = (void *)asset;
     return 0;
 }
 
-size_t Android_JNI_FileRead(SDL_RWops *ctx, void *buffer, size_t size)
+size_t Android_JNI_FileRead(void *userdata, void *buffer, size_t size)
 {
-    AAsset *asset = (AAsset *)ctx->hidden.androidio.asset;
-    int bytes = AAsset_read(asset, buffer, size);
+    const int bytes = AAsset_read((AAsset *)userdata, buffer, size);
     if (bytes < 0) {
         SDL_SetError("AAsset_read() failed");
         return 0;
@@ -1990,31 +1990,24 @@ size_t Android_JNI_FileRead(SDL_RWops *ctx, void *buffer, size_t size)
     return (size_t)bytes;
 }
 
-size_t Android_JNI_FileWrite(SDL_RWops *ctx, const void *buffer, size_t size)
+size_t Android_JNI_FileWrite(void *userdata, const void *buffer, size_t size)
 {
     return SDL_SetError("Cannot write to Android package filesystem");
 }
 
-Sint64 Android_JNI_FileSize(SDL_RWops *ctx)
+Sint64 Android_JNI_FileSize(void *userdata)
 {
-    off64_t result;
-    AAsset *asset = (AAsset *)ctx->hidden.androidio.asset;
-    result = AAsset_getLength64(asset);
-    return result;
+    return (Sint64) AAsset_getLength64((AAsset *)userdata);
 }
 
-Sint64 Android_JNI_FileSeek(SDL_RWops *ctx, Sint64 offset, int whence)
+Sint64 Android_JNI_FileSeek(void *userdata, Sint64 offset, int whence)
 {
-    off64_t result;
-    AAsset *asset = (AAsset *)ctx->hidden.androidio.asset;
-    result = AAsset_seek64(asset, offset, whence);
-    return result;
+    return (Sint64) AAsset_seek64((AAsset *)userdata, offset, whence);
 }
 
-int Android_JNI_FileClose(SDL_RWops *ctx)
+int Android_JNI_FileClose(void *userdata)
 {
-    AAsset *asset = (AAsset *)ctx->hidden.androidio.asset;
-    AAsset_close(asset);
+    AAsset_close((AAsset *)userdata);
     return 0;
 }
 

src/core/android/SDL_android.h

@@ -66,12 +66,12 @@ extern void Android_JNI_CloseAudioDevice(const int iscapture);
 extern SDL_bool Android_IsDeXMode(void);
 extern SDL_bool Android_IsChromebook(void);
 
-int Android_JNI_FileOpen(SDL_RWops *ctx, const char *fileName, const char *mode);
-Sint64 Android_JNI_FileSize(SDL_RWops *ctx);
-Sint64 Android_JNI_FileSeek(SDL_RWops *ctx, Sint64 offset, int whence);
-size_t Android_JNI_FileRead(SDL_RWops *ctx, void *buffer, size_t size);
-size_t Android_JNI_FileWrite(SDL_RWops *ctx, const void *buffer, size_t size);
-int Android_JNI_FileClose(SDL_RWops *ctx);
+int Android_JNI_FileOpen(void **puserdata, const char *fileName, const char *mode);
+Sint64 Android_JNI_FileSize(void *userdata);
+Sint64 Android_JNI_FileSeek(void *userdata, Sint64 offset, int whence);
+size_t Android_JNI_FileRead(void *userdata, void *buffer, size_t size);
+size_t Android_JNI_FileWrite(void *userdata, const void *buffer, size_t size);
+int Android_JNI_FileClose(void *userdata);
 
 /* Environment support */
 void Android_JNI_GetManifestEnvironmentVariables(void);

src/dynapi/SDL_dynapi.sym

@@ -469,7 +469,6 @@ SDL3_0.0.0 {
     SDL_RWFromConstMem;
     SDL_RWFromFile;
     SDL_RWFromMem;
-    SDL_RWclose;
     SDL_RWread;
     SDL_RWseek;
     SDL_RWsize;

src/dynapi/SDL_dynapi_overrides.h

@@ -493,7 +493,6 @@
 #define SDL_RWFromConstMem SDL_RWFromConstMem_REAL
 #define SDL_RWFromFile SDL_RWFromFile_REAL
 #define SDL_RWFromMem SDL_RWFromMem_REAL
-#define SDL_RWclose SDL_RWclose_REAL
 #define SDL_RWread SDL_RWread_REAL
 #define SDL_RWseek SDL_RWseek_REAL
 #define SDL_RWsize SDL_RWsize_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -142,7 +142,7 @@ SDL_DYNAPI_PROC(SDL_Mutex*,SDL_CreateMutex,(void),(),return)
 SDL_DYNAPI_PROC(SDL_Palette*,SDL_CreatePalette,(int a),(a),return)
 SDL_DYNAPI_PROC(SDL_PixelFormat*,SDL_CreatePixelFormat,(SDL_PixelFormatEnum a),(a),return)
 SDL_DYNAPI_PROC(SDL_Window*,SDL_CreatePopupWindow,(SDL_Window *a, int b, int c, int d, int e, Uint32 f),(a,b,c,d,e,f),return)
-SDL_DYNAPI_PROC(SDL_RWops*,SDL_CreateRW,(void),(),return)
+SDL_DYNAPI_PROC(SDL_RWops*,SDL_CreateRW,(const SDL_RWopsInterface *a, void *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_RWLock*,SDL_CreateRWLock,(void),(),return)
 SDL_DYNAPI_PROC(SDL_Renderer*,SDL_CreateRenderer,(SDL_Window *a, const char *b, Uint32 c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_Semaphore*,SDL_CreateSemaphore,(Uint32 a),(a),return)
@@ -166,7 +166,7 @@ SDL_DYNAPI_PROC(void,SDL_DestroyCursor,(SDL_Cursor *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyMutex,(SDL_Mutex *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyPalette,(SDL_Palette *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyPixelFormat,(SDL_PixelFormat *a),(a),)
-SDL_DYNAPI_PROC(void,SDL_DestroyRW,(SDL_RWops *a),(a),)
+SDL_DYNAPI_PROC(int,SDL_DestroyRW,(SDL_RWops *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_DestroyRWLock,(SDL_RWLock *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyRenderer,(SDL_Renderer *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroySemaphore,(SDL_Semaphore *a),(a),)
@@ -538,7 +538,6 @@ SDL_DYNAPI_PROC(void,SDL_QuitSubSystem,(Uint32 a),(a),)
 SDL_DYNAPI_PROC(SDL_RWops*,SDL_RWFromConstMem,(const void *a, size_t b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_RWops*,SDL_RWFromFile,(const char *a, const char *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_RWops*,SDL_RWFromMem,(void *a, size_t b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_RWclose,(SDL_RWops *a),(a),return)
 SDL_DYNAPI_PROC(size_t,SDL_RWread,(SDL_RWops *a, void *b, size_t c),(a,b,c),return)
 SDL_DYNAPI_PROC(Sint64,SDL_RWseek,(SDL_RWops *a, Sint64 b, int c),(a,b,c),return)
 SDL_DYNAPI_PROC(Sint64,SDL_RWsize,(SDL_RWops *a),(a),return)

src/file/SDL_rwops.c

@@ -36,6 +36,15 @@
    data sources.  It can easily be extended to files, memory, etc.
 */
 
+struct SDL_RWops
+{
+    SDL_RWopsInterface iface;
+    void *userdata;
+    Uint32 status;
+    SDL_PropertiesID props;
+};
+
+
 #ifdef SDL_PLATFORM_APPLE
 #include "cocoa/SDL_rwopsbundlesupport.h"
 #endif /* SDL_PLATFORM_APPLE */
@@ -50,6 +59,16 @@
 
 #if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
 
+typedef struct RWopsWindowsData
+{
+    SDL_bool append;
+    HANDLE h;
+    void *data;
+    size_t size;
+    size_t left;
+} RWopsWindowsData;
+
+
 /* Functions to read/write Win32 API file pointers */
 #ifndef INVALID_SET_FILE_POINTER
 #define INVALID_SET_FILE_POINTER 0xFFFFFFFF
@@ -57,7 +76,7 @@
 
 #define READAHEAD_BUFFER_SIZE 1024
 
-static int SDLCALL windows_file_open(SDL_RWops *context, const char *filename, const char *mode)
+static int SDLCALL windows_file_open(RWopsWindowsData *rwopsdata, const char *filename, const char *mode)
 {
 #if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) && !defined(SDL_PLATFORM_WINRT)
     UINT old_error_mode;
@@ -67,10 +86,8 @@ static int SDLCALL windows_file_open(SDL_RWops *context, const char *filename, c
     DWORD must_exist, truncate;
     int a_mode;
 
-    context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* mark this as unusable */
-    context->hidden.windowsio.buffer.data = NULL;
-    context->hidden.windowsio.buffer.size = 0;
-    context->hidden.windowsio.buffer.left = 0;
+    SDL_zerop(rwopsdata);
+    rwopsdata->h = INVALID_HANDLE_VALUE; /* mark this as unusable */
 
     /* "r" = reading, file must exist */
     /* "w" = writing, truncate existing, file may not exist */
@@ -90,9 +107,8 @@ static int SDLCALL windows_file_open(SDL_RWops *context, const char *filename, c
     }
     /* failed (invalid call) */
 
-    context->hidden.windowsio.buffer.data =
-        (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
-    if (!context->hidden.windowsio.buffer.data) {
+    rwopsdata->data = (char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
+    if (!rwopsdata->data) {
         return -1;
     }
 #if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) && !defined(SDL_PLATFORM_WINRT)
@@ -131,38 +147,40 @@ static int SDLCALL windows_file_open(SDL_RWops *context, const char *filename, c
 #endif
 
     if (h == INVALID_HANDLE_VALUE) {
-        SDL_free(context->hidden.windowsio.buffer.data);
-        context->hidden.windowsio.buffer.data = NULL;
+        SDL_free(rwopsdata->data);
+        rwopsdata->data = NULL;
         SDL_SetError("Couldn't open %s", filename);
         return -2; /* failed (CreateFile) */
     }
-    context->hidden.windowsio.h = h;
-    context->hidden.windowsio.append = a_mode ? SDL_TRUE : SDL_FALSE;
+    rwopsdata->h = h;
+    rwopsdata->append = a_mode ? SDL_TRUE : SDL_FALSE;
 
     return 0; /* ok */
 }
 
-static Sint64 SDLCALL windows_file_size(SDL_RWops *context)
+static Sint64 SDLCALL windows_file_size(void *userdata)
 {
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
     LARGE_INTEGER size;
 
-    if (!GetFileSizeEx(context->hidden.windowsio.h, &size)) {
+    if (!GetFileSizeEx(rwopsdata->h, &size)) {
         return WIN_SetError("windows_file_size");
     }
 
     return size.QuadPart;
 }
 
-static Sint64 SDLCALL windows_file_seek(SDL_RWops *context, Sint64 offset, int whence)
+static Sint64 SDLCALL windows_file_seek(void *userdata, Sint64 offset, int whence)
 {
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
     DWORD windowswhence;
     LARGE_INTEGER windowsoffset;
 
-    /* FIXME: We may be able to satisfy the seek within buffered data */
-    if (whence == SDL_RW_SEEK_CUR && context->hidden.windowsio.buffer.left) {
-        offset -= context->hidden.windowsio.buffer.left;
+    // FIXME: We may be able to satisfy the seek within buffered data
+    if ((whence == SDL_RW_SEEK_CUR) && (rwopsdata->left)) {
+        offset -= rwopsdata->left;
     }
-    context->hidden.windowsio.buffer.left = 0;
+    rwopsdata->left = 0;
 
     switch (whence) {
     case SDL_RW_SEEK_SET:
@@ -179,26 +197,27 @@ static Sint64 SDLCALL windows_file_seek(SDL_RWops *context, Sint64 offset, int w
     }
 
     windowsoffset.QuadPart = offset;
-    if (!SetFilePointerEx(context->hidden.windowsio.h, windowsoffset, &windowsoffset, windowswhence)) {
+    if (!SetFilePointerEx(rwopsdata->h, windowsoffset, &windowsoffset, windowswhence)) {
         return WIN_SetError("windows_file_seek");
     }
     return windowsoffset.QuadPart;
 }
 
-static size_t SDLCALL windows_file_read(SDL_RWops *context, void *ptr, size_t size)
+static size_t SDLCALL windows_file_read(void *userdata, void *ptr, size_t size)
 {
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
     size_t total_need = size;
     size_t total_read = 0;
     size_t read_ahead;
     DWORD bytes;
 
-    if (context->hidden.windowsio.buffer.left > 0) {
-        void *data = (char *)context->hidden.windowsio.buffer.data +
-                     context->hidden.windowsio.buffer.size -
-                     context->hidden.windowsio.buffer.left;
-        read_ahead = SDL_min(total_need, context->hidden.windowsio.buffer.left);
+    if (rwopsdata->left > 0) {
+        void *data = (char *)rwopsdata->data +
+                     rwopsdata->size -
+                     rwopsdata->left;
+        read_ahead = SDL_min(total_need, rwopsdata->left);
         SDL_memcpy(ptr, data, read_ahead);
-        context->hidden.windowsio.buffer.left -= read_ahead;
+        rwopsdata->left -= read_ahead;
 
         if (read_ahead == total_need) {
             return size;
@@ -209,18 +228,17 @@ static size_t SDLCALL windows_file_read(SDL_RWops *context, void *ptr, size_t si
     }
 
     if (total_need < READAHEAD_BUFFER_SIZE) {
-        if (!ReadFile(context->hidden.windowsio.h, context->hidden.windowsio.buffer.data,
-                      READAHEAD_BUFFER_SIZE, &bytes, NULL)) {
+        if (!ReadFile(rwopsdata->h, rwopsdata->data, READAHEAD_BUFFER_SIZE, &bytes, NULL)) {
             SDL_Error(SDL_EFREAD);
             return 0;
         }
         read_ahead = SDL_min(total_need, bytes);
-        SDL_memcpy(ptr, context->hidden.windowsio.buffer.data, read_ahead);
-        context->hidden.windowsio.buffer.size = bytes;
-        context->hidden.windowsio.buffer.left = bytes - read_ahead;
+        SDL_memcpy(ptr, rwopsdata->data, read_ahead);
+        rwopsdata->size = bytes;
+        rwopsdata->left = bytes - read_ahead;
         total_read += read_ahead;
     } else {
-        if (!ReadFile(context->hidden.windowsio.h, ptr, (DWORD)total_need, &bytes, NULL)) {
+        if (!ReadFile(rwopsdata->h, ptr, (DWORD)total_need, &bytes, NULL)) {
             SDL_Error(SDL_EFREAD);
             return 0;
         }
@@ -229,32 +247,31 @@ static size_t SDLCALL windows_file_read(SDL_RWops *context, void *ptr, size_t si
     return total_read;
 }
 
-static size_t SDLCALL windows_file_write(SDL_RWops *context, const void *ptr, size_t size)
+static size_t SDLCALL windows_file_write(void *userdata, const void *ptr, size_t size)
 {
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
     const size_t total_bytes = size;
     DWORD bytes;
 
-    if (context->hidden.windowsio.buffer.left) {
-        if (!SetFilePointer(context->hidden.windowsio.h,
-                       -(LONG)context->hidden.windowsio.buffer.left, NULL,
-                       FILE_CURRENT)) {
+    if (rwopsdata->left) {
+        if (!SetFilePointer(rwopsdata->h, -(LONG)rwopsdata->left, NULL, FILE_CURRENT)) {
             SDL_Error(SDL_EFSEEK);
             return 0;
         }
-        context->hidden.windowsio.buffer.left = 0;
+        rwopsdata->left = 0;
     }
 
     /* if in append mode, we must go to the EOF before write */
-    if (context->hidden.windowsio.append) {
+    if (rwopsdata->append) {
         LARGE_INTEGER windowsoffset;
         windowsoffset.QuadPart = 0;
-        if (!SetFilePointerEx(context->hidden.windowsio.h, windowsoffset, &windowsoffset, FILE_END)) {
+        if (!SetFilePointerEx(rwopsdata->h, windowsoffset, &windowsoffset, FILE_END)) {
             SDL_Error(SDL_EFSEEK);
             return 0;
         }
     }
 
-    if (!WriteFile(context->hidden.windowsio.h, ptr, (DWORD)total_bytes, &bytes, NULL)) {
+    if (!WriteFile(rwopsdata->h, ptr, (DWORD)total_bytes, &bytes, NULL)) {
         SDL_Error(SDL_EFWRITE);
         return 0;
     }
@@ -262,17 +279,15 @@ static size_t SDLCALL windows_file_write(SDL_RWops *context, const void *ptr, si
     return bytes;
 }
 
-static int SDLCALL windows_file_close(SDL_RWops *context)
+static int SDLCALL windows_file_close(void *userdata)
 {
-    if (context->hidden.windowsio.h != INVALID_HANDLE_VALUE) {
-        CloseHandle(context->hidden.windowsio.h);
-        context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* to be sure */
-    }
-    if (context->hidden.windowsio.buffer.data) {
-        SDL_free(context->hidden.windowsio.buffer.data);
-        context->hidden.windowsio.buffer.data = NULL;
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) userdata;
+    if (rwopsdata->h != INVALID_HANDLE_VALUE) {
+        CloseHandle(rwopsdata->h);
+        rwopsdata->h = INVALID_HANDLE_VALUE; /* to be sure */
     }
-    SDL_DestroyRW(context);
+    SDL_free(rwopsdata->data);
+    SDL_free(rwopsdata);
     return 0;
 }
 #endif /* defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) */
@@ -281,6 +296,12 @@ static int SDLCALL windows_file_close(SDL_RWops *context)
 
 /* Functions to read/write stdio file pointers. Not used for windows. */
 
+typedef struct RWopsStdioData
+{
+    FILE *fp;
+    SDL_bool autoclose;
+} RWopsStdioData;
+
 #ifdef HAVE_FOPEN64
 #define fopen fopen64
 #endif
@@ -317,8 +338,9 @@ static int SDLCALL windows_file_close(SDL_RWops *context)
 #define fseek_off_t long
 #endif
 
-static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
+static Sint64 SDLCALL stdio_seek(void *userdata, Sint64 offset, int whence)
 {
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
     int stdiowhence;
 
     switch (whence) {
@@ -341,8 +363,8 @@ static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
     }
 #endif
 
-    if (fseek((FILE *)context->hidden.stdio.fp, (fseek_off_t)offset, stdiowhence) == 0) {
-        Sint64 pos = ftell((FILE *)context->hidden.stdio.fp);
+    if (fseek(rwopsdata->fp, (fseek_off_t)offset, stdiowhence) == 0) {
+        const Sint64 pos = ftell(rwopsdata->fp);
         if (pos < 0) {
             return SDL_SetError("Couldn't get stream offset");
         }
@@ -351,53 +373,60 @@ static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
     return SDL_Error(SDL_EFSEEK);
 }
 
-static size_t SDLCALL stdio_read(SDL_RWops *context, void *ptr, size_t size)
+static size_t SDLCALL stdio_read(void *userdata, void *ptr, size_t size)
 {
-    size_t bytes;
-
-    bytes = fread(ptr, 1, size, (FILE *)context->hidden.stdio.fp);
-    if (bytes == 0 && ferror((FILE *)context->hidden.stdio.fp)) {
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
+    const size_t bytes = fread(ptr, 1, size, rwopsdata->fp);
+    if (bytes == 0 && ferror(rwopsdata->fp)) {
         SDL_Error(SDL_EFREAD);
     }
     return bytes;
 }
 
-static size_t SDLCALL stdio_write(SDL_RWops *context, const void *ptr, size_t size)
+static size_t SDLCALL stdio_write(void *userdata, const void *ptr, size_t size)
 {
-    size_t bytes;
-
-    bytes = fwrite(ptr, 1, size, (FILE *)context->hidden.stdio.fp);
-    if (bytes == 0 && ferror((FILE *)context->hidden.stdio.fp)) {
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
+    const size_t bytes = fwrite(ptr, 1, size, rwopsdata->fp);
+    if (bytes == 0 && ferror(rwopsdata->fp)) {
         SDL_Error(SDL_EFWRITE);
     }
     return bytes;
 }
 
-static int SDLCALL stdio_close(SDL_RWops *context)
+static int SDLCALL stdio_close(void *userdata)
 {
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) userdata;
     int status = 0;
-    if (context->hidden.stdio.autoclose) {
-        if (fclose((FILE *)context->hidden.stdio.fp) != 0) {
+    if (rwopsdata->autoclose) {
+        if (fclose(rwopsdata->fp) != 0) {
             status = SDL_Error(SDL_EFWRITE);
         }
     }
-    SDL_DestroyRW(context);
+    SDL_free(rwopsdata);
     return status;
 }
 
-static SDL_RWops *SDL_RWFromFP(void *fp, SDL_bool autoclose)
+static SDL_RWops *SDL_RWFromFP(FILE *fp, SDL_bool autoclose)
 {
-    SDL_RWops *rwops = NULL;
+    RWopsStdioData *rwopsdata = (RWopsStdioData *) SDL_malloc(sizeof (*rwopsdata));
+    if (!rwopsdata) {
+        return NULL;
+    }
 
-    rwops = SDL_CreateRW();
-    if (rwops) {
-        rwops->seek = stdio_seek;
-        rwops->read = stdio_read;
-        rwops->write = stdio_write;
-        rwops->close = stdio_close;
-        rwops->hidden.stdio.fp = fp;
-        rwops->hidden.stdio.autoclose = autoclose;
-        rwops->type = SDL_RWOPS_STDFILE;
+    SDL_RWopsInterface iface;
+    SDL_zero(iface);
+    // There's no stdio_size because SDL_RWsize emulates it the same way we'd do it for stdio anyhow.
+    iface.seek = stdio_seek;
+    iface.read = stdio_read;
+    iface.write = stdio_write;
+    iface.close = stdio_close;
+
+    rwopsdata->fp = fp;
+    rwopsdata->autoclose = autoclose;
+
+    SDL_RWops *rwops = SDL_CreateRW(&iface, rwopsdata);
+    if (!rwops) {
+        iface.close(rwopsdata);
     }
     return rwops;
 }
@@ -405,57 +434,69 @@ static SDL_RWops *SDL_RWFromFP(void *fp, SDL_bool autoclose)
 
 /* Functions to read/write memory pointers */
 
-static Sint64 SDLCALL mem_size(SDL_RWops *context)
+typedef struct RWopsMemData
 {
-    return (context->hidden.mem.stop - context->hidden.mem.base);
+    Uint8 *base;
+    Uint8 *here;
+    Uint8 *stop;
+} RWopsMemData;
+
+static Sint64 SDLCALL mem_size(void *userdata)
+{
+    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
+    return (rwopsdata->stop - rwopsdata->base);
 }
 
-static Sint64 SDLCALL mem_seek(SDL_RWops *context, Sint64 offset, int whence)
+static Sint64 SDLCALL mem_seek(void *userdata, Sint64 offset, int whence)
 {
+    RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
     Uint8 *newpos;
 
     switch (whence) {
     case SDL_RW_SEEK_SET:
-        newpos = context->hidden.mem.base + offset;
+        newpos = rwopsdata->base + offset;
         break;
     case SDL_RW_SEEK_CUR:
-        newpos = context->hidden.mem.here + offset;
+        newpos = rwopsdata->here + offset;
         break;
     case SDL_RW_SEEK_END:
-        newpos = context->hidden.mem.stop + offset;
+        newpos = rwopsdata->stop + offset;
         break;
     default:
         return SDL_SetError("Unknown value for 'whence'");
     }
-    if (newpos < context->hidden.mem.base) {
-        newpos = context->hidden.mem.base;
+    if (newpos < rwopsdata->base) {
+        newpos = rwopsdata->base;
     }
-    if (newpos > context->hidden.mem.stop) {
-        newpos = context->hidden.mem.stop;
+    if (newpos > rwopsdata->stop) {
+        newpos = rwopsdata->stop;
     }
-    context->hidden.mem.here = newpos;
-    return (Sint64)(context->hidden.mem.here - context->hidden.mem.base);
+    rwopsdata->here = newpos;
+    return (Sint64)(rwopsdata->here - rwopsdata->base);
 }
 
-static size_t mem_io(SDL_RWops *context, void *dst, const void *src, size_t size)
+static size_t mem_io(void *userdata, void *dst, const void *src, size_t size)
 {
-    const size_t mem_available = (context->hidden.mem.stop - context->hidden.mem.here);
+    RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
+    const size_t mem_available = (rwopsdata->stop - rwopsdata->here);
     if (size > mem_available) {
         size = mem_available;
     }
     SDL_memcpy(dst, src, size);
-    context->hidden.mem.here += size;
+    rwopsdata->here += size;
     return size;
 }
 
-static size_t SDLCALL mem_read(SDL_RWops *context, void *ptr, size_t size)
+static size_t SDLCALL mem_read(void *userdata, void *ptr, size_t size)
 {
-    return mem_io(context, ptr, context->hidden.mem.here, size);
+    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
+    return mem_io(userdata, ptr, rwopsdata->here, size);
 }
 
-static size_t SDLCALL mem_write(SDL_RWops *context, const void *ptr, size_t size)
+static size_t SDLCALL mem_write(void *userdata, const void *ptr, size_t size)
 {
-    return mem_io(context, context->hidden.mem.here, ptr, size);
+    const RWopsMemData *rwopsdata = (RWopsMemData *) userdata;
+    return mem_io(userdata, rwopsdata->here, ptr, size);
 }
 
 /* Functions to create SDL_RWops structures from various data sources */
@@ -501,15 +542,12 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
         }
     } else {
         /* Try opening it from internal storage if it's a relative path */
-        char *path;
-        FILE *fp;
-
-        /* !!! FIXME: why not just "char path[PATH_MAX];" ? */
-        path = SDL_stack_alloc(char, PATH_MAX);
+        // !!! FIXME: why not just "char path[PATH_MAX];"
+        char *path = SDL_stack_alloc(char, PATH_MAX);
         if (path) {
             SDL_snprintf(path, PATH_MAX, "%s/%s",
                          SDL_AndroidGetInternalStoragePath(), file);
-            fp = fopen(path, mode);
+            FILE *fp = fopen(path, mode);
             SDL_stack_free(path);
             if (fp) {
                 if (!IsRegularFileOrPipe(fp)) {
@@ -524,50 +562,66 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
 #endif /* HAVE_STDIO_H */
 
     /* Try to open the file from the asset system */
-    rwops = SDL_CreateRW();
-    if (!rwops) {
-        return NULL; /* SDL_SetError already setup by SDL_CreateRW() */
-    }
 
-    if (Android_JNI_FileOpen(rwops, file, mode) < 0) {
+    void *rwopsdata = NULL;
+    if (Android_JNI_FileOpen(&rwopsdata, file, mode) < 0) {
         SDL_DestroyRW(rwops);
         return NULL;
     }
-    rwops->size = Android_JNI_FileSize;
-    rwops->seek = Android_JNI_FileSeek;
-    rwops->read = Android_JNI_FileRead;
-    rwops->write = Android_JNI_FileWrite;
-    rwops->close = Android_JNI_FileClose;
-    rwops->type = SDL_RWOPS_JNIFILE;
 
-#elif defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
-    rwops = SDL_CreateRW();
+    SDL_RWopsInterface iface;
+    SDL_zero(iface);
+    iface.size = Android_JNI_FileSize;
+    iface.seek = Android_JNI_FileSeek;
+    iface.read = Android_JNI_FileRead;
+    iface.write = Android_JNI_FileWrite;
+    iface.close = Android_JNI_FileClose;
+
+    rwops = SDL_CreateRW(&iface, rwopsdata);
     if (!rwops) {
-        return NULL; /* SDL_SetError already setup by SDL_CreateRW() */
+        iface.close(rwopsdata);
     }
+    return rwops;
+
 
-    if (windows_file_open(rwops, file, mode) < 0) {
+#elif defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_GDK) || defined(SDL_PLATFORM_WINRT)
+    RWopsWindowsData *rwopsdata = (RWopsWindowsData *) SDL_malloc(sizeof (*rwopsdata));
+    if (!rwopsdata) {
+        return NULL;
+    }
+
+    if (windows_file_open(rwopsdata, file, mode) < 0) {
         SDL_DestroyRW(rwops);
         return NULL;
     }
-    rwops->size = windows_file_size;
-    rwops->seek = windows_file_seek;
-    rwops->read = windows_file_read;
-    rwops->write = windows_file_write;
-    rwops->close = windows_file_close;
-    rwops->type = SDL_RWOPS_WINFILE;
+
+    SDL_RWopsInterface iface;
+    SDL_zero(iface);
+    iface.size = windows_file_size;
+    iface.seek = windows_file_seek;
+    iface.read = windows_file_read;
+    iface.write = windows_file_write;
+    iface.close = windows_file_close;
+
+    rwops = SDL_CreateRW(&iface, rwopsdata);
+    if (!rwops) {
+        windows_file_close(rwopsdata);
+    }
+    return rwops;
+
 #elif defined(HAVE_STDIO_H)
     {
-#if defined(SDL_PLATFORM_APPLE)
+        #if defined(SDL_PLATFORM_APPLE)
         FILE *fp = SDL_OpenFPFromBundleOrFallback(file, mode);
-#elif defined(SDL_PLATFORM_WINRT)
+        #elif defined(SDL_PLATFORM_WINRT)
         FILE *fp = NULL;
         fopen_s(&fp, file, mode);
-#elif defined(SDL_PLATFORM_3DS)
+        #elif defined(SDL_PLATFORM_3DS)
         FILE *fp = N3DS_FileOpen(file, mode);
-#else
+        #else
         FILE *fp = fopen(file, mode);
-#endif
+        #endif
+
         if (!fp) {
             SDL_SetError("Couldn't open %s", file);
         } else if (!IsRegularFileOrPipe(fp)) {
@@ -578,6 +632,7 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
             rwops = SDL_RWFromFP(fp, SDL_TRUE);
         }
     }
+
 #else
     SDL_SetError("SDL not compiled with stdio support");
 #endif /* !HAVE_STDIO_H */
@@ -587,72 +642,96 @@ SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
 
 SDL_RWops *SDL_RWFromMem(void *mem, size_t size)
 {
-    SDL_RWops *rwops = NULL;
-
     if (!mem) {
         SDL_InvalidParamError("mem");
         return NULL;
-    }
-    if (!size) {
+    } else if (!size) {
         SDL_InvalidParamError("size");
         return NULL;
     }
 
-    rwops = SDL_CreateRW();
-    if (rwops) {
-        rwops->size = mem_size;
-        rwops->seek = mem_seek;
-        rwops->read = mem_read;
-        rwops->write = mem_write;
-        rwops->hidden.mem.base = (Uint8 *)mem;
-        rwops->hidden.mem.here = rwops->hidden.mem.base;
-        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
-        rwops->type = SDL_RWOPS_MEMORY;
+    RWopsMemData *rwopsdata = (RWopsMemData *) SDL_malloc(sizeof (*rwopsdata));
+    if (!rwopsdata) {
+        return NULL;
+    }
+
+    SDL_RWopsInterface iface;
+    SDL_zero(iface);
+    iface.size = mem_size;
+    iface.seek = mem_seek;
+    iface.read = mem_read;
+    iface.write = mem_write;
+
+    rwopsdata->base = (Uint8 *)mem;
+    rwopsdata->here = rwopsdata->base;
+    rwopsdata->stop = rwopsdata->base + size;
+
+    SDL_RWops *rwops = SDL_CreateRW(&iface, rwopsdata);
+    if (!rwops) {
+        SDL_free(rwopsdata);
     }
     return rwops;
 }
 
 SDL_RWops *SDL_RWFromConstMem(const void *mem, size_t size)
 {
-    SDL_RWops *rwops = NULL;
-
     if (!mem) {
         SDL_InvalidParamError("mem");
         return NULL;
-    }
-    if (!size) {
+    } else if (!size) {
         SDL_InvalidParamError("size");
         return NULL;
     }
 
-    rwops = SDL_CreateRW();
-    if (rwops) {
-        rwops->size = mem_size;
-        rwops->seek = mem_seek;
-        rwops->read = mem_read;
-        rwops->hidden.mem.base = (Uint8 *)mem;
-        rwops->hidden.mem.here = rwops->hidden.mem.base;
-        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
-        rwops->type = SDL_RWOPS_MEMORY_RO;
+    RWopsMemData *rwopsdata = (RWopsMemData *) SDL_malloc(sizeof (*rwopsdata));
+    if (!rwopsdata) {
+        return NULL;
+    }
+
+    SDL_RWopsInterface iface;
+    SDL_zero(iface);
+    iface.size = mem_size;
+    iface.seek = mem_seek;
+    iface.read = mem_read;
+    // leave iface.write as NULL.
+
+    rwopsdata->base = (Uint8 *)mem;
+    rwopsdata->here = rwopsdata->base;
+    rwopsdata->stop = rwopsdata->base + size;
+
+    SDL_RWops *rwops = SDL_CreateRW(&iface, rwopsdata);
+    if (!rwops) {
+        SDL_free(rwopsdata);
     }
     return rwops;
 }
 
-SDL_RWops *SDL_CreateRW(void)
+SDL_RWops *SDL_CreateRW(const SDL_RWopsInterface *iface, void *userdata)
 {
-    SDL_RWops *context;
+    if (!iface) {
+        SDL_InvalidParamError("iface");
+        return NULL;
+    }
 
-    context = (SDL_RWops *)SDL_calloc(1, sizeof(*context));
-    if (context) {
-        context->type = SDL_RWOPS_UNKNOWN;
+    SDL_RWops *rwops = (SDL_RWops *)SDL_calloc(1, sizeof(*rwops));
+    if (rwops) {
+        SDL_copyp(&rwops->iface, iface);
+        rwops->userdata = userdata;
     }
-    return context;
+    return rwops;
 }
 
-void SDL_DestroyRW(SDL_RWops *context)
+int SDL_DestroyRW(SDL_RWops *rwops)
 {
-    SDL_DestroyProperties(context->props);
-    SDL_free(context);
+    int retval = 0;
+    if (rwops) {
+        if (rwops->iface.close) {
+            retval = rwops->iface.close(rwops->userdata);
+        }
+        SDL_DestroyProperties(rwops->props);
+        SDL_free(rwops);
+    }
+    return retval;
 }
 
 /* Load all the data from an SDL data stream */
@@ -718,7 +797,7 @@ done:
         *datasize = (size_t)size_total;
     }
     if (freesrc && src) {
-        SDL_RWclose(src);
+        SDL_DestroyRW(src);
     }
     return data;
 }
@@ -746,7 +825,7 @@ Sint64 SDL_RWsize(SDL_RWops *context)
     if (!context) {
         return SDL_InvalidParamError("context");
     }
-    if (!context->size) {
+    if (!context->iface.size) {
         Sint64 pos, size;
 
         pos = SDL_RWseek(context, 0, SDL_RW_SEEK_CUR);
@@ -758,18 +837,17 @@ Sint64 SDL_RWsize(SDL_RWops *context)
         SDL_RWseek(context, pos, SDL_RW_SEEK_SET);
         return size;
     }
-    return context->size(context);
+    return context->iface.size(context->userdata);
 }
 
 Sint64 SDL_RWseek(SDL_RWops *context, Sint64 offset, int whence)
 {
     if (!context) {
         return SDL_InvalidParamError("context");
-    }
-    if (!context->seek) {
+    } else if (!context->iface.seek) {
         return SDL_Unsupported();
     }
-    return context->seek(context, offset, whence);
+    return context->iface.seek(context->userdata, offset, whence);
 }
 
 Sint64 SDL_RWtell(SDL_RWops *context)
@@ -784,8 +862,7 @@ size_t SDL_RWread(SDL_RWops *context, void *ptr, size_t size)
     if (!context) {
         SDL_InvalidParamError("context");
         return 0;
-    }
-    if (!context->read) {
+    } else if (!context->iface.read) {
         context->status = SDL_RWOPS_STATUS_WRITEONLY;
         SDL_Unsupported();
         return 0;
@@ -798,7 +875,7 @@ size_t SDL_RWread(SDL_RWops *context, void *ptr, size_t size)
         return 0;
     }
 
-    bytes = context->read(context, ptr, size);
+    bytes = context->iface.read(context->userdata, ptr, size);
     if (bytes == 0 && context->status == SDL_RWOPS_STATUS_READY) {
         if (*SDL_GetError()) {
             context->status = SDL_RWOPS_STATUS_ERROR;
@@ -816,8 +893,7 @@ size_t SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size)
     if (!context) {
         SDL_InvalidParamError("context");
         return 0;
-    }
-    if (!context->write) {
+    } else if (!context->iface.write) {
         context->status = SDL_RWOPS_STATUS_READONLY;
         SDL_Unsupported();
         return 0;
@@ -830,8 +906,8 @@ size_t SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size)
         return 0;
     }
 
-    bytes = context->write(context, ptr, size);
-    if (bytes == 0 && context->status == SDL_RWOPS_STATUS_READY) {
+    bytes = context->iface.write(context->userdata, ptr, size);
+    if ((bytes == 0) && (context->status == SDL_RWOPS_STATUS_READY)) {
         context->status = SDL_RWOPS_STATUS_ERROR;
     }
     return bytes;
@@ -872,18 +948,6 @@ size_t SDL_RWvprintf(SDL_RWops *context, SDL_PRINTF_FORMAT_STRING const char *fm
     return bytes;
 }
 
-int SDL_RWclose(SDL_RWops *context)
-{
-    if (!context) {
-        return SDL_InvalidParamError("context");
-    }
-    if (!context->close) {
-        SDL_DestroyRW(context);
-        return 0;
-    }
-    return context->close(context);
-}
-
 /* Functions for dynamically reading and writing endian-specific values */
 
 SDL_bool SDL_ReadU8(SDL_RWops *src, Uint8 *value)

src/test/SDL_test_common.c

@@ -1913,7 +1913,7 @@ static const void *SDLTest_ScreenShotClipboardProvider(void *context, const char
                     image = NULL;
                 }
             }
-            SDL_RWclose(file);
+            SDL_DestroyRW(file);
 
             if (image) {
                 data->image = image;
@@ -1984,7 +1984,7 @@ static void SDLTest_PasteScreenShot(void)
             if (file) {
                 SDL_Log("Writing clipboard image to %s", filename);
                 SDL_RWwrite(file, data, size);
-                SDL_RWclose(file);
+                SDL_DestroyRW(file);
             }
             SDL_free(data);
             return;

src/video/SDL_bmp.c

@@ -578,7 +578,7 @@ done:
         surface = NULL;
     }
     if (freesrc && src) {
-        SDL_RWclose(src);
+        SDL_DestroyRW(src);
     }
     return surface;
 }
@@ -857,7 +857,7 @@ done:
         SDL_DestroySurface(intermediate_surface);
     }
     if (freedst && dst) {
-        if (SDL_RWclose(dst) < 0) {
+        if (SDL_DestroyRW(dst) < 0) {
             was_error = SDL_TRUE;
         }
     }

test/testautomation_rwops.c

@@ -269,15 +269,12 @@ static int rwops_testMem(void *arg)
         return TEST_ABORTED;
     }
 
-    /* Check type */
-    SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY, "Verify RWops type is SDL_RWOPS_MEMORY; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_MEMORY, rw->type);
-
     /* Run generic tests */
     testGenericRWopsValidations(rw, SDL_TRUE);
 
     /* Close */
-    result = SDL_RWclose(rw);
-    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
+    result = SDL_DestroyRW(rw);
+    SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -304,15 +301,12 @@ static int rwops_testConstMem(void *arg)
         return TEST_ABORTED;
     }
 
-    /* Check type */
-    SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY_RO, "Verify RWops type is SDL_RWOPS_MEMORY_RO; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_MEMORY_RO, rw->type);
-
     /* Run generic tests */
     testGenericRWopsValidations(rw, SDL_FALSE);
 
     /* Close handle */
-    result = SDL_RWclose(rw);
-    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
+    result = SDL_DestroyRW(rw);
+    SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -339,27 +333,12 @@ static int rwops_testFileRead(void *arg)
         return TEST_ABORTED;
     }
 
-    /* Check type */
-#ifdef SDL_PLATFORM_ANDROID
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_STDFILE || rw->type == SDL_RWOPS_JNIFILE,
-        "Verify RWops type is SDL_RWOPS_STDFILE or SDL_RWOPS_JNIFILE; expected: %d|%d, got: %d", SDL_RWOPS_STDFILE, SDL_RWOPS_JNIFILE, rw->type);
-#elif defined(SDL_PLATFORM_WIN32)
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_WINFILE,
-        "Verify RWops type is SDL_RWOPS_WINFILE; expected: %d, got: %d", SDL_RWOPS_WINFILE, rw->type);
-#else
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_STDFILE,
-        "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_STDFILE, rw->type);
-#endif
-
     /* Run generic tests */
     testGenericRWopsValidations(rw, SDL_FALSE);
 
     /* Close handle */
-    result = SDL_RWclose(rw);
-    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
+    result = SDL_DestroyRW(rw);
+    SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -386,27 +365,12 @@ static int rwops_testFileWrite(void *arg)
         return TEST_ABORTED;
     }
 
-    /* Check type */
-#ifdef SDL_PLATFORM_ANDROID
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_STDFILE || rw->type == SDL_RWOPS_JNIFILE,
-        "Verify RWops type is SDL_RWOPS_STDFILE or SDL_RWOPS_JNIFILE; expected: %d|%d, got: %d", SDL_RWOPS_STDFILE, SDL_RWOPS_JNIFILE, rw->type);
-#elif defined(SDL_PLATFORM_WIN32)
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_WINFILE,
-        "Verify RWops type is SDL_RWOPS_WINFILE; expected: %d, got: %d", SDL_RWOPS_WINFILE, rw->type);
-#else
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_STDFILE,
-        "Verify RWops type is SDL_RWOPS_STDFILE; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_STDFILE, rw->type);
-#endif
-
     /* Run generic tests */
     testGenericRWopsValidations(rw, SDL_TRUE);
 
     /* Close handle */
-    result = SDL_RWclose(rw);
-    SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
+    result = SDL_DestroyRW(rw);
+    SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
     SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
     return TEST_COMPLETED;
@@ -421,18 +385,17 @@ static int rwops_testFileWrite(void *arg)
 static int rwops_testAllocFree(void *arg)
 {
     /* Allocate context */
-    SDL_RWops *rw = SDL_CreateRW();
+    SDL_RWopsInterface iface;
+    SDL_RWops *rw;
+
+    SDL_zero(iface);
+    rw = SDL_CreateRW(&iface, NULL);
     SDLTest_AssertPass("Call to SDL_CreateRW() succeeded");
     SDLTest_AssertCheck(rw != NULL, "Validate result from SDL_CreateRW() is not NULL");
     if (rw == NULL) {
         return TEST_ABORTED;
     }
 
-    /* Check type */
-    SDLTest_AssertCheck(
-        rw->type == SDL_RWOPS_UNKNOWN,
-        "Verify RWops type is SDL_RWOPS_UNKNOWN; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_UNKNOWN, rw->type);
-
     /* Free context again */
     SDL_DestroyRW(rw);
     SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
@@ -472,8 +435,8 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
         SDLTest_AssertPass("Call to SDL_RWread(mem, size=%d)", size * 6);
         sv_mem = SDL_RWseek(rwops_mem, 0, SEEK_END);
         SDLTest_AssertPass("Call to SDL_RWseek(mem,SEEK_END)");
-        result = SDL_RWclose(rwops_mem);
-        SDLTest_AssertPass("Call to SDL_RWclose(mem)");
+        result = SDL_DestroyRW(rwops_mem);
+        SDLTest_AssertPass("Call to SDL_DestroyRW(mem)");
         SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
         /* Read/see from file */
@@ -483,8 +446,8 @@ static int rwops_testCompareRWFromMemWithRWFromFile(void *arg)
         SDLTest_AssertPass("Call to SDL_RWread(file, size=%d)", size * 6);
         sv_file = SDL_RWseek(rwops_file, 0, SEEK_END);
         SDLTest_AssertPass("Call to SDL_RWseek(file,SEEK_END)");
-        result = SDL_RWclose(rwops_file);
-        SDLTest_AssertPass("Call to SDL_RWclose(file)");
+        result = SDL_DestroyRW(rwops_file);
+        SDLTest_AssertPass("Call to SDL_DestroyRW(file)");
         SDLTest_AssertCheck(result == 0, "Verify result value is 0; got: %d", result);
 
         /* Compare */
@@ -627,8 +590,8 @@ static int rwops_testFileWriteReadEndian(void *arg)
         SDLTest_AssertCheck(LE64test == LE64value, "Validate object read from SDL_ReadU64LE, expected: %" SDL_PRIu64 ", got: %" SDL_PRIu64, LE64value, LE64test);
 
         /* Close handle */
-        cresult = SDL_RWclose(rw);
-        SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
+        cresult = SDL_DestroyRW(rw);
+        SDLTest_AssertPass("Call to SDL_DestroyRW() succeeded");
         SDLTest_AssertCheck(cresult == 0, "Verify result value is 0; got: %d", cresult);
     }
 

test/testfile.c

@@ -55,7 +55,7 @@ rwops_error_quit(unsigned line, SDL_RWops *rwops)
 {
     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "testfile.c(%d): failed\n", line);
     if (rwops) {
-        SDL_RWclose(rwops); /* This calls SDL_DestroyRW(rwops); */
+        SDL_DestroyRW(rwops);
     }
     cleanup();
     SDLTest_CommonDestroyState(state);
@@ -126,25 +126,25 @@ int main(int argc, char *argv[])
     if (!rwops) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     unlink(FBASENAME2);
     rwops = SDL_RWFromFile(FBASENAME2, "wb+");
     if (!rwops) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     unlink(FBASENAME2);
     rwops = SDL_RWFromFile(FBASENAME2, "ab");
     if (!rwops) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     unlink(FBASENAME2);
     rwops = SDL_RWFromFile(FBASENAME2, "ab+");
     if (!rwops) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     unlink(FBASENAME2);
     SDL_Log("test2 OK\n");
 
@@ -171,7 +171,7 @@ int main(int argc, char *argv[])
         RWOP_ERR_QUIT(rwops); /* we are in write only mode */
     }
 
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
 
     rwops = SDL_RWFromFile(FBASENAME1, "rb"); /* read mode, file must exist */
     if (!rwops) {
@@ -208,7 +208,7 @@ int main(int argc, char *argv[])
         RWOP_ERR_QUIT(rwops); /* readonly mode */
     }
 
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
 
     /* test 3: same with w+ mode */
     rwops = SDL_RWFromFile(FBASENAME1, "wb+"); /* write + read + truncation */
@@ -258,7 +258,7 @@ int main(int argc, char *argv[])
     if (SDL_memcmp(test_buf, "12345678901234567890", 20) != 0) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     SDL_Log("test3 OK\n");
 
     /* test 4: same in r+ mode */
@@ -309,7 +309,7 @@ int main(int argc, char *argv[])
     if (SDL_memcmp(test_buf, "12345678901234567890", 20) != 0) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     SDL_Log("test4 OK\n");
 
     /* test5 : append mode */
@@ -366,7 +366,7 @@ int main(int argc, char *argv[])
     if (SDL_memcmp(test_buf, "123456789012345678901234567123", 30) != 0) {
         RWOP_ERR_QUIT(rwops);
     }
-    SDL_RWclose(rwops);
+    SDL_DestroyRW(rwops);
     SDL_Log("test5 OK\n");
     cleanup();
     SDL_Quit();

test/testime.c

@@ -223,7 +223,7 @@ static int unifont_init(const char *fontname)
         lineNumber++;
     } while (bytesRead > 0);
 
-    SDL_RWclose(hexFile);
+    SDL_DestroyRW(hexFile);
     SDL_Log("unifont: Loaded %" SDL_PRIu32 " glyphs.\n", numGlyphs);
     return 0;
 }

test/testoverlay.c

@@ -452,7 +452,7 @@ int main(int argc, char **argv)
 
     SDL_RWread(handle, RawMooseData, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
 
-    SDL_RWclose(handle);
+    SDL_DestroyRW(handle);
 
     /* Create the window and renderer */
     window_w = MOOSEPIC_W * scale;

test/testresample.c

@@ -141,7 +141,7 @@ int main(int argc, char **argv)
     SDL_WriteU32LE(io, dst_len);                                /* size */
     SDL_RWwrite(io, dst_buf, dst_len);
 
-    if (SDL_RWclose(io) == -1) {
+    if (SDL_DestroyRW(io) == -1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "fclose('%s') failed: %s\n", file_out, SDL_GetError());
         ret = 6;
         goto end;

test/teststreaming.c

@@ -171,7 +171,7 @@ int main(int argc, char **argv)
         quit(2);
     }
     SDL_RWread(handle, MooseFrames, MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
-    SDL_RWclose(handle);
+    SDL_DestroyRW(handle);
 
     /* Create the window and renderer */
     window = SDL_CreateWindow("Happy Moose", MOOSEPIC_W * 4, MOOSEPIC_H * 4, SDL_WINDOW_RESIZABLE);

test/testutils.c

@@ -44,7 +44,7 @@ GetNearbyFilename(const char *file)
 
         rw = SDL_RWFromFile(path, "rb");
         if (rw) {
-            SDL_RWclose(rw);
+            SDL_DestroyRW(rw);
             return path;
         }